[mirror_ubuntu-artful-kernel.git] / include / linux / aio.h

#ifndef __LINUX__AIO_H
#define __LINUX__AIO_H

#include <linux/list.h>
#include <linux/workqueue.h>
#include <linux/aio_abi.h>
#include <linux/uio.h>

#include <asm/atomic.h>
#include <linux/uio.h>

#define AIO_MAXSEGS		4
#define AIO_KIOGRP_NR_ATOMIC	8

struct kioctx;

/* Notes on cancelling a kiocb:
 *	If a kiocb is cancelled, aio_complete may return 0 to indicate 
 *	that cancel has not yet disposed of the kiocb.  All cancel 
 *	operations *must* call aio_put_req to dispose of the kiocb 
 *	to guard against races with the completion code.
 */
#define KIOCB_C_CANCELLED	0x01
#define KIOCB_C_COMPLETE	0x02

#define KIOCB_SYNC_KEY		(~0U)

/* ki_flags bits */
/*
 * This may be used for cancel/retry serialization in the future, but
 * for now it's unused and we probably don't want modules to even
 * think they can use it.
 */
/* #define KIF_LOCKED		0 */
#define KIF_KICKED		1
#define KIF_CANCELLED		2

#define kiocbTryLock(iocb)	test_and_set_bit(KIF_LOCKED, &(iocb)->ki_flags)
#define kiocbTryKick(iocb)	test_and_set_bit(KIF_KICKED, &(iocb)->ki_flags)

#define kiocbSetLocked(iocb)	set_bit(KIF_LOCKED, &(iocb)->ki_flags)
#define kiocbSetKicked(iocb)	set_bit(KIF_KICKED, &(iocb)->ki_flags)
#define kiocbSetCancelled(iocb)	set_bit(KIF_CANCELLED, &(iocb)->ki_flags)

#define kiocbClearLocked(iocb)	clear_bit(KIF_LOCKED, &(iocb)->ki_flags)
#define kiocbClearKicked(iocb)	clear_bit(KIF_KICKED, &(iocb)->ki_flags)
#define kiocbClearCancelled(iocb)	clear_bit(KIF_CANCELLED, &(iocb)->ki_flags)

#define kiocbIsLocked(iocb)	test_bit(KIF_LOCKED, &(iocb)->ki_flags)
#define kiocbIsKicked(iocb)	test_bit(KIF_KICKED, &(iocb)->ki_flags)
#define kiocbIsCancelled(iocb)	test_bit(KIF_CANCELLED, &(iocb)->ki_flags)

/* is there a better place to document function pointer methods? */
/**
 * ki_retry	-	iocb forward progress callback
 * @kiocb:	The kiocb struct to advance by performing an operation.
 *
 * This callback is called when the AIO core wants a given AIO operation
 * to make forward progress.  The kiocb argument describes the operation
 * that is to be performed.  As the operation proceeds, perhaps partially,
 * ki_retry is expected to update the kiocb with progress made.  Typically
 * ki_retry is set in the AIO core and it itself calls file_operations
 * helpers.
 *
 * ki_retry's return value determines when the AIO operation is completed
 * and an event is generated in the AIO event ring.  Except the special
 * return values described below, the value that is returned from ki_retry
 * is transferred directly into the completion ring as the operation's
 * resulting status.  Once this has happened ki_retry *MUST NOT* reference
 * the kiocb pointer again.
 *
 * If ki_retry returns -EIOCBQUEUED it has made a promise that aio_complete()
 * will be called on the kiocb pointer in the future.  The AIO core will
 * not ask the method again -- ki_retry must ensure forward progress.
 * aio_complete() must be called once and only once in the future, multiple
 * calls may result in undefined behaviour.
 *
 * If ki_retry returns -EIOCBRETRY it has made a promise that kick_iocb()
 * will be called on the kiocb pointer in the future.  This may happen
 * through generic helpers that associate kiocb->ki_wait with a wait
 * queue head that ki_retry uses via current->io_wait.  It can also happen
 * with custom tracking and manual calls to kick_iocb(), though that is
 * discouraged.  In either case, kick_iocb() must be called once and only
 * once.  ki_retry must ensure forward progress, the AIO core will wait
 * indefinitely for kick_iocb() to be called.
 */
struct kiocb {
	struct list_head	ki_run_list;
	long			ki_flags;
	int			ki_users;
	unsigned		ki_key;		/* id of this request */

	struct file		*ki_filp;
	struct kioctx		*ki_ctx;	/* may be NULL for sync ops */
	int			(*ki_cancel)(struct kiocb *, struct io_event *);
	ssize_t			(*ki_retry)(struct kiocb *);
	void			(*ki_dtor)(struct kiocb *);

	union {
		void __user		*user;
		struct task_struct	*tsk;
	} ki_obj;

	__u64			ki_user_data;	/* user's data for completion */
	wait_queue_t		ki_wait;
	loff_t			ki_pos;

	atomic_t		ki_bio_count;	/* num bio used for this iocb */
	void			*private;
	/* State that we remember to be able to restart/retry  */
	unsigned short		ki_opcode;
	size_t			ki_nbytes; 	/* copy of iocb->aio_nbytes */
	char 			__user *ki_buf;	/* remaining iocb->aio_buf */
	size_t			ki_left; 	/* remaining bytes */
	struct iovec		ki_inline_vec;	/* inline vector */
 	struct iovec		*ki_iovec;
 	unsigned long		ki_nr_segs;
 	unsigned long		ki_cur_seg;

	struct list_head	ki_list;	/* the aio core uses this
						 * for cancellation */

	/*
	 * If the aio_resfd field of the userspace iocb is not zero,
	 * this is the underlying file* to deliver event to.
	 */
	struct file		*ki_eventfd;
};

#define is_sync_kiocb(iocb)	((iocb)->ki_key == KIOCB_SYNC_KEY)
#define init_sync_kiocb(x, filp)			\
	do {						\
		struct task_struct *tsk = current;	\
		(x)->ki_flags = 0;			\
		(x)->ki_users = 1;			\
		(x)->ki_key = KIOCB_SYNC_KEY;		\
		(x)->ki_filp = (filp);			\
		(x)->ki_ctx = NULL;			\
		(x)->ki_cancel = NULL;			\
		(x)->ki_retry = NULL;			\
		(x)->ki_dtor = NULL;			\
		(x)->ki_obj.tsk = tsk;			\
		(x)->ki_user_data = 0;                  \
		init_wait((&(x)->ki_wait));             \
	} while (0)

#define AIO_RING_MAGIC			0xa10a10a1
#define AIO_RING_COMPAT_FEATURES	1
#define AIO_RING_INCOMPAT_FEATURES	0
struct aio_ring {
	unsigned	id;	/* kernel internal index number */
	unsigned	nr;	/* number of io_events */
	unsigned	head;
	unsigned	tail;

	unsigned	magic;
	unsigned	compat_features;
	unsigned	incompat_features;
	unsigned	header_length;	/* size of aio_ring */


	struct io_event		io_events[0];
}; /* 128 bytes + ring size */

#define aio_ring_avail(info, ring)	(((ring)->head + (info)->nr - 1 - (ring)->tail) % (info)->nr)

#define AIO_RING_PAGES	8
struct aio_ring_info {
	unsigned long		mmap_base;
	unsigned long		mmap_size;

	struct page		**ring_pages;
	spinlock_t		ring_lock;
	long			nr_pages;

	unsigned		nr, tail;

	struct page		*internal_pages[AIO_RING_PAGES];
};

struct kioctx {
	atomic_t		users;
	int			dead;
	struct mm_struct	*mm;

	/* This needs improving */
	unsigned long		user_id;
	struct kioctx		*next;

	wait_queue_head_t	wait;

	spinlock_t		ctx_lock;

	int			reqs_active;
	struct list_head	active_reqs;	/* used for cancellation */
	struct list_head	run_list;	/* used for kicked reqs */

	/* sys_io_setup currently limits this to an unsigned int */
	unsigned		max_reqs;

	struct aio_ring_info	ring_info;

	struct delayed_work	wq;
};

/* prototypes */
extern unsigned aio_max_size;

extern ssize_t FASTCALL(wait_on_sync_kiocb(struct kiocb *iocb));
extern int FASTCALL(aio_put_req(struct kiocb *iocb));
extern void FASTCALL(kick_iocb(struct kiocb *iocb));
extern int FASTCALL(aio_complete(struct kiocb *iocb, long res, long res2));
extern void FASTCALL(__put_ioctx(struct kioctx *ctx));
struct mm_struct;
extern void FASTCALL(exit_aio(struct mm_struct *mm));
extern struct kioctx *lookup_ioctx(unsigned long ctx_id);
extern int FASTCALL(io_submit_one(struct kioctx *ctx,
			struct iocb __user *user_iocb, struct iocb *iocb));

/* semi private, but used by the 32bit emulations: */
struct kioctx *lookup_ioctx(unsigned long ctx_id);
int FASTCALL(io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
				  struct iocb *iocb));

#define get_ioctx(kioctx) do {						\
	BUG_ON(atomic_read(&(kioctx)->users) <= 0);			\
	atomic_inc(&(kioctx)->users);					\
} while (0)
#define put_ioctx(kioctx) do {						\
	BUG_ON(atomic_read(&(kioctx)->users) <= 0);			\
	if (unlikely(atomic_dec_and_test(&(kioctx)->users))) 		\
		__put_ioctx(kioctx);					\
} while (0)

#define in_aio() (unlikely(!is_sync_wait(current->io_wait)))

/* may be used for debugging */
#define warn_if_async()							\
do {									\
	if (in_aio()) {							\
		printk(KERN_ERR "%s(%s:%d) called in async context!\n",	\
			__FUNCTION__, __FILE__, __LINE__);		\
		dump_stack();						\
	}								\
} while (0)

#define io_wait_to_kiocb(wait) container_of(wait, struct kiocb, ki_wait)

#include <linux/aio_abi.h>

static inline struct kiocb *list_kiocb(struct list_head *h)
{
	return list_entry(h, struct kiocb, ki_list);
}

/* for sysctl: */
extern unsigned long aio_nr;
extern unsigned long aio_max_nr;

#endif /* __LINUX__AIO_H */
Commit	Line	Data
1da177e4 LT	1	#ifndef __LINUX__AIO_H
	2	#define __LINUX__AIO_H
	3
	4	#include <linux/list.h>
	5	#include <linux/workqueue.h>
	6	#include <linux/aio_abi.h>
027445c3	7	#include <linux/uio.h>
1da177e4 LT	8
1da177e4 LT	9	#include <asm/atomic.h>
eed4e51f	10	#include <linux/uio.h>
1da177e4 LT	11
	12	#define AIO_MAXSEGS 4
	13	#define AIO_KIOGRP_NR_ATOMIC 8
	14
	15	struct kioctx;
	16
	17	/* Notes on cancelling a kiocb:
	18	* If a kiocb is cancelled, aio_complete may return 0 to indicate
	19	* that cancel has not yet disposed of the kiocb. All cancel
	20	* operations must call aio_put_req to dispose of the kiocb
	21	* to guard against races with the completion code.
	22	*/
	23	#define KIOCB_C_CANCELLED 0x01
	24	#define KIOCB_C_COMPLETE 0x02
	25
	26	#define KIOCB_SYNC_KEY (~0U)
	27
	28	/* ki_flags bits */
4faa5285 ZB	29	/*
	30	* This may be used for cancel/retry serialization in the future, but
	31	* for now it's unused and we probably don't want modules to even
	32	* think they can use it.
	33	*/
	34	/* #define KIF_LOCKED 0 */
1da177e4 LT	35	#define KIF_KICKED 1
	36	#define KIF_CANCELLED 2
	37
	38	#define kiocbTryLock(iocb) test_and_set_bit(KIF_LOCKED, &(iocb)->ki_flags)
	39	#define kiocbTryKick(iocb) test_and_set_bit(KIF_KICKED, &(iocb)->ki_flags)
	40
	41	#define kiocbSetLocked(iocb) set_bit(KIF_LOCKED, &(iocb)->ki_flags)
	42	#define kiocbSetKicked(iocb) set_bit(KIF_KICKED, &(iocb)->ki_flags)
	43	#define kiocbSetCancelled(iocb) set_bit(KIF_CANCELLED, &(iocb)->ki_flags)
	44
	45	#define kiocbClearLocked(iocb) clear_bit(KIF_LOCKED, &(iocb)->ki_flags)
	46	#define kiocbClearKicked(iocb) clear_bit(KIF_KICKED, &(iocb)->ki_flags)
	47	#define kiocbClearCancelled(iocb) clear_bit(KIF_CANCELLED, &(iocb)->ki_flags)
	48
	49	#define kiocbIsLocked(iocb) test_bit(KIF_LOCKED, &(iocb)->ki_flags)
	50	#define kiocbIsKicked(iocb) test_bit(KIF_KICKED, &(iocb)->ki_flags)
	51	#define kiocbIsCancelled(iocb) test_bit(KIF_CANCELLED, &(iocb)->ki_flags)
	52
897f15fb ZB	53	/* is there a better place to document function pointer methods? */
	54	/**
	55	* ki_retry - iocb forward progress callback
	56	* @kiocb: The kiocb struct to advance by performing an operation.
	57	*
	58	* This callback is called when the AIO core wants a given AIO operation
	59	* to make forward progress. The kiocb argument describes the operation
	60	* that is to be performed. As the operation proceeds, perhaps partially,
	61	* ki_retry is expected to update the kiocb with progress made. Typically
	62	* ki_retry is set in the AIO core and it itself calls file_operations
	63	* helpers.
	64	*
	65	* ki_retry's return value determines when the AIO operation is completed
	66	* and an event is generated in the AIO event ring. Except the special
	67	* return values described below, the value that is returned from ki_retry
	68	* is transferred directly into the completion ring as the operation's
	69	* resulting status. Once this has happened ki_retry MUST NOT reference
	70	* the kiocb pointer again.
	71	*
	72	* If ki_retry returns -EIOCBQUEUED it has made a promise that aio_complete()
	73	* will be called on the kiocb pointer in the future. The AIO core will
	74	* not ask the method again -- ki_retry must ensure forward progress.
	75	* aio_complete() must be called once and only once in the future, multiple
	76	* calls may result in undefined behaviour.
	77	*
	78	* If ki_retry returns -EIOCBRETRY it has made a promise that kick_iocb()
	79	* will be called on the kiocb pointer in the future. This may happen
	80	* through generic helpers that associate kiocb->ki_wait with a wait
	81	* queue head that ki_retry uses via current->io_wait. It can also happen
	82	* with custom tracking and manual calls to kick_iocb(), though that is
	83	* discouraged. In either case, kick_iocb() must be called once and only
	84	* once. ki_retry must ensure forward progress, the AIO core will wait
	85	* indefinitely for kick_iocb() to be called.
	86	*/
1da177e4 LT	87	struct kiocb {
	88	struct list_head ki_run_list;
	89	long ki_flags;
	90	int ki_users;
	91	unsigned ki_key; /* id of this request */
	92
	93	struct file *ki_filp;
	94	struct kioctx ki_ctx; / may be NULL for sync ops */
	95	int (ki_cancel)(struct kiocb , struct io_event *);
	96	ssize_t (ki_retry)(struct kiocb );
	97	void (ki_dtor)(struct kiocb );
	98
1da177e4 LT	99	union {
	100	void __user *user;
	101	struct task_struct *tsk;
	102	} ki_obj;
59d9136b	103
1da177e4	104	__u64 ki_user_data; /* user's data for completion */
59d9136b	105	wait_queue_t ki_wait;
1da177e4	106	loff_t ki_pos;
59d9136b	107
e61c9018	108	atomic_t ki_bio_count; /* num bio used for this iocb */
59d9136b	109	void *private;
1da177e4 LT	110	/* State that we remember to be able to restart/retry */
	111	unsigned short ki_opcode;
	112	size_t ki_nbytes; /* copy of iocb->aio_nbytes */
	113	char __user ki_buf; / remaining iocb->aio_buf */
	114	size_t ki_left; /* remaining bytes */
027445c3	115	struct iovec ki_inline_vec; /* inline vector */
eed4e51f BP	116	struct iovec *ki_iovec;
	117	unsigned long ki_nr_segs;
	118	unsigned long ki_cur_seg;
1da177e4	119
59d9136b BL	120	struct list_head ki_list; /* the aio core uses this
59d9136b BL	121	* for cancellation */
9c3060be DL	122
	123	/*
	124	* If the aio_resfd field of the userspace iocb is not zero,
	125	* this is the underlying file* to deliver event to.
	126	*/
	127	struct file *ki_eventfd;
1da177e4 LT	128	};
	129
	130	#define is_sync_kiocb(iocb) ((iocb)->ki_key == KIOCB_SYNC_KEY)
	131	#define init_sync_kiocb(x, filp) \
	132	do { \
	133	struct task_struct *tsk = current; \
	134	(x)->ki_flags = 0; \
	135	(x)->ki_users = 1; \
	136	(x)->ki_key = KIOCB_SYNC_KEY; \
	137	(x)->ki_filp = (filp); \
20dcae32	138	(x)->ki_ctx = NULL; \
1da177e4	139	(x)->ki_cancel = NULL; \
59d9136b	140	(x)->ki_retry = NULL; \
1da177e4 LT	141	(x)->ki_dtor = NULL; \
	142	(x)->ki_obj.tsk = tsk; \
	143	(x)->ki_user_data = 0; \
	144	init_wait((&(x)->ki_wait)); \
	145	} while (0)
	146
	147	#define AIO_RING_MAGIC 0xa10a10a1
	148	#define AIO_RING_COMPAT_FEATURES 1
	149	#define AIO_RING_INCOMPAT_FEATURES 0
	150	struct aio_ring {
	151	unsigned id; /* kernel internal index number */
	152	unsigned nr; /* number of io_events */
	153	unsigned head;
	154	unsigned tail;
	155
	156	unsigned magic;
	157	unsigned compat_features;
	158	unsigned incompat_features;
	159	unsigned header_length; /* size of aio_ring */
	160
	161
	162	struct io_event io_events[0];
	163	}; /* 128 bytes + ring size */
	164
	165	#define aio_ring_avail(info, ring) (((ring)->head + (info)->nr - 1 - (ring)->tail) % (info)->nr)
	166
	167	#define AIO_RING_PAGES 8
	168	struct aio_ring_info {
	169	unsigned long mmap_base;
	170	unsigned long mmap_size;
	171
	172	struct page **ring_pages;
	173	spinlock_t ring_lock;
	174	long nr_pages;
	175
	176	unsigned nr, tail;
	177
	178	struct page *internal_pages[AIO_RING_PAGES];
	179	};
	180
	181	struct kioctx {
	182	atomic_t users;
	183	int dead;
	184	struct mm_struct *mm;
	185
	186	/* This needs improving */
	187	unsigned long user_id;
	188	struct kioctx *next;
	189
	190	wait_queue_head_t wait;
	191
	192	spinlock_t ctx_lock;
	193
	194	int reqs_active;
	195	struct list_head active_reqs; /* used for cancellation */
	196	struct list_head run_list; /* used for kicked reqs */
	197
d55b5fda	198	/* sys_io_setup currently limits this to an unsigned int */
1da177e4 LT	199	unsigned max_reqs;
	200
	201	struct aio_ring_info ring_info;
	202
52bad64d	203	struct delayed_work wq;
1da177e4 LT	204	};
	205
	206	/* prototypes */
	207	extern unsigned aio_max_size;
	208
	209	extern ssize_t FASTCALL(wait_on_sync_kiocb(struct kiocb *iocb));
	210	extern int FASTCALL(aio_put_req(struct kiocb *iocb));
	211	extern void FASTCALL(kick_iocb(struct kiocb *iocb));
	212	extern int FASTCALL(aio_complete(struct kiocb *iocb, long res, long res2));
	213	extern void FASTCALL(__put_ioctx(struct kioctx *ctx));
	214	struct mm_struct;
	215	extern void FASTCALL(exit_aio(struct mm_struct *mm));
	216	extern struct kioctx *lookup_ioctx(unsigned long ctx_id);
	217	extern int FASTCALL(io_submit_one(struct kioctx *ctx,
	218	struct iocb __user user_iocb, struct iocb iocb));
	219
	220	/* semi private, but used by the 32bit emulations: */
	221	struct kioctx *lookup_ioctx(unsigned long ctx_id);
	222	int FASTCALL(io_submit_one(struct kioctx ctx, struct iocb __user user_iocb,
	223	struct iocb *iocb));
	224
5ef1c49f	225	#define get_ioctx(kioctx) do { \
3a271111	226	BUG_ON(atomic_read(&(kioctx)->users) <= 0); \
5ef1c49f ZB	227	atomic_inc(&(kioctx)->users); \
	228	} while (0)
	229	#define put_ioctx(kioctx) do { \
3a271111	230	BUG_ON(atomic_read(&(kioctx)->users) <= 0); \
5ef1c49f ZB	231	if (unlikely(atomic_dec_and_test(&(kioctx)->users))) \
	232	__put_ioctx(kioctx); \
	233	} while (0)
1da177e4	234
b8522ead AM	235	#define in_aio() (unlikely(!is_sync_wait(current->io_wait)))
b8522ead AM	236
1da177e4 LT	237	/* may be used for debugging */
	238	#define warn_if_async() \
	239	do { \
	240	if (in_aio()) { \
	241	printk(KERN_ERR "%s(%s:%d) called in async context!\n", \
	242	__FUNCTION__, __FILE__, __LINE__); \
	243	dump_stack(); \
	244	} \
	245	} while (0)
	246
	247	#define io_wait_to_kiocb(wait) container_of(wait, struct kiocb, ki_wait)
1da177e4 LT	248
	249	#include <linux/aio_abi.h>
	250
	251	static inline struct kiocb list_kiocb(struct list_head h)
	252	{
	253	return list_entry(h, struct kiocb, ki_list);
	254	}
	255
	256	/* for sysctl: */
d55b5fda ZB	257	extern unsigned long aio_nr;
d55b5fda ZB	258	extern unsigned long aio_max_nr;
1da177e4 LT	259
1da177e4 LT	260	#endif /* __LINUX__AIO_H */