[fio.git] / os / os-solaris.h

#ifndef FIO_OS_SOLARIS_H
#define FIO_OS_SOLARIS_H

#include <errno.h>
#include <malloc.h>
#include <sys/types.h>
#include <sys/fcntl.h>
#include <sys/pset.h>

#include "../file.h"

#define FIO_HAVE_POSIXAIO
#define FIO_HAVE_SOLARISAIO
#define FIO_HAVE_FALLOCATE
#define FIO_HAVE_POSIXAIO_FSYNC
#define FIO_HAVE_CPU_AFFINITY
#define FIO_HAVE_PSHARED_MUTEX
#define FIO_USE_GENERIC_BDEV_SIZE
#define FIO_HAVE_FDATASYNC

#define OS_MAP_ANON		MAP_ANON
#define OS_RAND_MAX		2147483648UL

struct solaris_rand_seed {
	unsigned short r[3];
};

typedef psetid_t os_cpu_mask_t;
typedef struct solaris_rand_seed os_random_state_t;

static inline int blockdev_invalidate_cache(struct fio_file *f)
{
	return EINVAL;
}

static inline unsigned long long os_phys_mem(void)
{
	return 0;
}

static inline void os_random_seed(unsigned long seed, os_random_state_t *rs)
{
	rs->r[0] = seed & 0xffff;
	seed >>= 16;
	rs->r[1] = seed & 0xffff;
	seed >>= 16;
	rs->r[2] = seed & 0xffff;
	seed48(rs->r);
}

static inline long os_random_long(os_random_state_t *rs)
{
	return nrand48(rs->r);
}

#define FIO_OS_DIRECTIO
extern int directio(int, int);
static inline int fio_set_odirect(int fd)
{
	if (directio(fd, DIRECTIO_ON) < 0)
		return errno;

	return 0;
}

/*
 * pset binding hooks for fio
 */
#define fio_setaffinity(pid, cpumask)		\
	pset_bind((cpumask), P_PID, (pid), NULL)
#define fio_getaffinity(pid, ptr)	({ 0; })

#define fio_cpu_clear(mask, cpu)	pset_assign(PS_NONE, (cpu), NULL)
#define fio_cpu_set(mask, cpu)		pset_assign(*(mask), (cpu), NULL)

static inline int fio_cpuset_init(os_cpu_mask_t *mask)
{
	int ret;

	if (pset_create(mask) < 0) {
		ret = errno;
		return -1;
	}

	return 0;
}

static inline int fio_cpuset_exit(os_cpu_mask_t *mask)
{
	int ret;

	if (pset_destroy(*mask) < 0) {
		ret = errno;
		return -1;
	}

	return 0;
}

/*
 * Should be enough, not aware of what (if any) restrictions Solaris has
 */
#define FIO_MAX_CPUS			16384

#ifdef MADV_FREE
#define FIO_MADV_FREE	MADV_FREE
#endif

#endif
Commit	Line	Data
	1	#ifndef FIO_OS_SOLARIS_H
	2	#define FIO_OS_SOLARIS_H
	3
	4	#include <errno.h>
	5	#include <malloc.h>
	6	#include <sys/types.h>
	7	#include <sys/fcntl.h>
	8	#include <sys/pset.h>
	9
	10	#include "../file.h"
	11
	12	#define FIO_HAVE_POSIXAIO
	13	#define FIO_HAVE_SOLARISAIO
	14	#define FIO_HAVE_FALLOCATE
	15	#define FIO_HAVE_POSIXAIO_FSYNC
	16	#define FIO_HAVE_CPU_AFFINITY
	17	#define FIO_HAVE_PSHARED_MUTEX
	18	#define FIO_USE_GENERIC_BDEV_SIZE
	19	#define FIO_HAVE_FDATASYNC
	20
	21	#define OS_MAP_ANON MAP_ANON
	22	#define OS_RAND_MAX 2147483648UL
	23
	24	struct solaris_rand_seed {
	25	unsigned short r[3];
	26	};
	27
	28	typedef psetid_t os_cpu_mask_t;
	29	typedef struct solaris_rand_seed os_random_state_t;
	30
	31	static inline int blockdev_invalidate_cache(struct fio_file *f)
	32	{
	33	return EINVAL;
	34	}
	35
	36	static inline unsigned long long os_phys_mem(void)
	37	{
	38	return 0;
	39	}
	40
	41	static inline void os_random_seed(unsigned long seed, os_random_state_t *rs)
	42	{
	43	rs->r[0] = seed & 0xffff;
	44	seed >>= 16;
	45	rs->r[1] = seed & 0xffff;
	46	seed >>= 16;
	47	rs->r[2] = seed & 0xffff;
	48	seed48(rs->r);
	49	}
	50
	51	static inline long os_random_long(os_random_state_t *rs)
	52	{
	53	return nrand48(rs->r);
	54	}
	55
	56	#define FIO_OS_DIRECTIO
	57	extern int directio(int, int);
	58	static inline int fio_set_odirect(int fd)
	59	{
	60	if (directio(fd, DIRECTIO_ON) < 0)
	61	return errno;
	62
	63	return 0;
	64	}
	65
	66	/*
	67	* pset binding hooks for fio
	68	*/
	69	#define fio_setaffinity(pid, cpumask) \
	70	pset_bind((cpumask), P_PID, (pid), NULL)
	71	#define fio_getaffinity(pid, ptr) ({ 0; })
	72
	73	#define fio_cpu_clear(mask, cpu) pset_assign(PS_NONE, (cpu), NULL)
	74	#define fio_cpu_set(mask, cpu) pset_assign(*(mask), (cpu), NULL)
	75
	76	static inline int fio_cpuset_init(os_cpu_mask_t *mask)
	77	{
	78	int ret;
	79
	80	if (pset_create(mask) < 0) {
	81	ret = errno;
	82	return -1;
	83	}
	84
	85	return 0;
	86	}
	87
	88	static inline int fio_cpuset_exit(os_cpu_mask_t *mask)
	89	{
	90	int ret;
	91
	92	if (pset_destroy(*mask) < 0) {
	93	ret = errno;
	94	return -1;
	95	}
	96
	97	return 0;
	98	}
	99
	100	/*
	101	* Should be enough, not aware of what (if any) restrictions Solaris has
	102	*/
	103	#define FIO_MAX_CPUS 16384
	104
	105	#ifdef MADV_FREE
	106	#define FIO_MADV_FREE MADV_FREE
	107	#endif
	108
	109	#endif