[deliverable/linux.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 <asm/atomic.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 */
#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)

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 *);

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

	union {
		void __user		*user;
		struct task_struct	*tsk;
	} ki_obj;
	__u64			ki_user_data;	/* user's data for completion */
	loff_t			ki_pos;
	/* 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 */
	wait_queue_t		ki_wait;
	long			ki_retried; 	/* just for testing */
	long			ki_kicked; 	/* just for testing */
	long			ki_queued; 	/* just for testing */

	void			*private;
};

#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 = &tsk->active_mm->default_kioctx;	\
		(x)->ki_cancel = 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 */

	unsigned		max_reqs;

	struct aio_ring_info	ring_info;

	struct work_struct	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 { if (unlikely(atomic_read(&(kioctx)->users) <= 0)) BUG(); atomic_inc(&(kioctx)->users); } while (0)
#define put_ioctx(kioctx)	do { if (unlikely(atomic_dec_and_test(&(kioctx)->users))) __put_ioctx(kioctx); else if (unlikely(atomic_read(&(kioctx)->users) < 0)) BUG(); } while (0)

#define in_aio() !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)
#define is_retried_kiocb(iocb) ((iocb)->ki_retried > 1)

#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 atomic_t aio_nr;
extern unsigned 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>
	7
	8	#include <asm/atomic.h>
	9
	10	#define AIO_MAXSEGS 4
	11	#define AIO_KIOGRP_NR_ATOMIC 8
	12
	13	struct kioctx;
	14
	15	/* Notes on cancelling a kiocb:
	16	* If a kiocb is cancelled, aio_complete may return 0 to indicate
	17	* that cancel has not yet disposed of the kiocb. All cancel
	18	* operations must call aio_put_req to dispose of the kiocb
	19	* to guard against races with the completion code.
	20	*/
	21	#define KIOCB_C_CANCELLED 0x01
	22	#define KIOCB_C_COMPLETE 0x02
	23
	24	#define KIOCB_SYNC_KEY (~0U)
	25
	26	/* ki_flags bits */
	27	#define KIF_LOCKED 0
	28	#define KIF_KICKED 1
	29	#define KIF_CANCELLED 2
	30
	31	#define kiocbTryLock(iocb) test_and_set_bit(KIF_LOCKED, &(iocb)->ki_flags)
	32	#define kiocbTryKick(iocb) test_and_set_bit(KIF_KICKED, &(iocb)->ki_flags)
	33
	34	#define kiocbSetLocked(iocb) set_bit(KIF_LOCKED, &(iocb)->ki_flags)
	35	#define kiocbSetKicked(iocb) set_bit(KIF_KICKED, &(iocb)->ki_flags)
	36	#define kiocbSetCancelled(iocb) set_bit(KIF_CANCELLED, &(iocb)->ki_flags)
	37
	38	#define kiocbClearLocked(iocb) clear_bit(KIF_LOCKED, &(iocb)->ki_flags)
	39	#define kiocbClearKicked(iocb) clear_bit(KIF_KICKED, &(iocb)->ki_flags)
	40	#define kiocbClearCancelled(iocb) clear_bit(KIF_CANCELLED, &(iocb)->ki_flags)
	41
	42	#define kiocbIsLocked(iocb) test_bit(KIF_LOCKED, &(iocb)->ki_flags)
	43	#define kiocbIsKicked(iocb) test_bit(KIF_KICKED, &(iocb)->ki_flags)
	44	#define kiocbIsCancelled(iocb) test_bit(KIF_CANCELLED, &(iocb)->ki_flags)
	45
	46	struct kiocb {
	47	struct list_head ki_run_list;
	48	long ki_flags;
	49	int ki_users;
	50	unsigned ki_key; /* id of this request */
	51
	52	struct file *ki_filp;
	53	struct kioctx ki_ctx; / may be NULL for sync ops */
	54	int (ki_cancel)(struct kiocb , struct io_event *);
	55	ssize_t (ki_retry)(struct kiocb );
	56	void (ki_dtor)(struct kiocb );
	57
	58	struct list_head ki_list; /* the aio core uses this
	59	* for cancellation */
	60
	61	union {
	62	void __user *user;
	63	struct task_struct *tsk;
	64	} ki_obj;
65	__u64 ki_user_data; /* user's data for completion */
66	loff_t ki_pos;
67	/* State that we remember to be able to restart/retry */
68	unsigned short ki_opcode;
69	size_t ki_nbytes; /* copy of iocb->aio_nbytes */
70	char __user ki_buf; / remaining iocb->aio_buf */
71	size_t ki_left; /* remaining bytes */
72	wait_queue_t ki_wait;
73	long ki_retried; /* just for testing */
74	long ki_kicked; /* just for testing */
75	long ki_queued; /* just for testing */
76
77	void *private;
78	};
79
80	#define is_sync_kiocb(iocb) ((iocb)->ki_key == KIOCB_SYNC_KEY)
81	#define init_sync_kiocb(x, filp) \
82	do { \
83	struct task_struct *tsk = current; \
84	(x)->ki_flags = 0; \
85	(x)->ki_users = 1; \
86	(x)->ki_key = KIOCB_SYNC_KEY; \
87	(x)->ki_filp = (filp); \
88	(x)->ki_ctx = &tsk->active_mm->default_kioctx; \
89	(x)->ki_cancel = NULL; \
90	(x)->ki_dtor = NULL; \
91	(x)->ki_obj.tsk = tsk; \
92	(x)->ki_user_data = 0; \
93	init_wait((&(x)->ki_wait)); \
94	} while (0)
95
96	#define AIO_RING_MAGIC 0xa10a10a1
97	#define AIO_RING_COMPAT_FEATURES 1
98	#define AIO_RING_INCOMPAT_FEATURES 0
99	struct aio_ring {
100	unsigned id; /* kernel internal index number */
101	unsigned nr; /* number of io_events */
102	unsigned head;
103	unsigned tail;
104
105	unsigned magic;
106	unsigned compat_features;
107	unsigned incompat_features;
108	unsigned header_length; /* size of aio_ring */
109
110
111	struct io_event io_events[0];
112	}; /* 128 bytes + ring size */
113
114	#define aio_ring_avail(info, ring) (((ring)->head + (info)->nr - 1 - (ring)->tail) % (info)->nr)
115
116	#define AIO_RING_PAGES 8
117	struct aio_ring_info {
118	unsigned long mmap_base;
119	unsigned long mmap_size;
120
121	struct page **ring_pages;
122	spinlock_t ring_lock;
123	long nr_pages;
124
125	unsigned nr, tail;
126
127	struct page *internal_pages[AIO_RING_PAGES];
128	};
129
130	struct kioctx {
131	atomic_t users;
132	int dead;
133	struct mm_struct *mm;
134
135	/* This needs improving */
136	unsigned long user_id;
137	struct kioctx *next;
138
139	wait_queue_head_t wait;
140
141	spinlock_t ctx_lock;
142
143	int reqs_active;
144	struct list_head active_reqs; /* used for cancellation */
145	struct list_head run_list; /* used for kicked reqs */
146
147	unsigned max_reqs;
148
149	struct aio_ring_info ring_info;
150
151	struct work_struct wq;
152	};
153
154	/* prototypes */
155	extern unsigned aio_max_size;
156
157	extern ssize_t FASTCALL(wait_on_sync_kiocb(struct kiocb *iocb));
158	extern int FASTCALL(aio_put_req(struct kiocb *iocb));
159	extern void FASTCALL(kick_iocb(struct kiocb *iocb));
160	extern int FASTCALL(aio_complete(struct kiocb *iocb, long res, long res2));
161	extern void FASTCALL(__put_ioctx(struct kioctx *ctx));
162	struct mm_struct;
163	extern void FASTCALL(exit_aio(struct mm_struct *mm));
164	extern struct kioctx *lookup_ioctx(unsigned long ctx_id);
165	extern int FASTCALL(io_submit_one(struct kioctx *ctx,
166	struct iocb __user user_iocb, struct iocb iocb));
167
168	/* semi private, but used by the 32bit emulations: */
169	struct kioctx *lookup_ioctx(unsigned long ctx_id);
170	int FASTCALL(io_submit_one(struct kioctx ctx, struct iocb __user user_iocb,
171	struct iocb *iocb));
172
173	#define get_ioctx(kioctx) do { if (unlikely(atomic_read(&(kioctx)->users) <= 0)) BUG(); atomic_inc(&(kioctx)->users); } while (0)
174	#define put_ioctx(kioctx) do { if (unlikely(atomic_dec_and_test(&(kioctx)->users))) __put_ioctx(kioctx); else if (unlikely(atomic_read(&(kioctx)->users) < 0)) BUG(); } while (0)
175
176	#define in_aio() !is_sync_wait(current->io_wait)
177	/* may be used for debugging */
178	#define warn_if_async() \
179	do { \
180	if (in_aio()) { \
181	printk(KERN_ERR "%s(%s:%d) called in async context!\n", \
182	__FUNCTION__, __FILE__, __LINE__); \
183	dump_stack(); \
184	} \
185	} while (0)
186
187	#define io_wait_to_kiocb(wait) container_of(wait, struct kiocb, ki_wait)
188	#define is_retried_kiocb(iocb) ((iocb)->ki_retried > 1)
189
190	#include <linux/aio_abi.h>
191
192	static inline struct kiocb list_kiocb(struct list_head h)
193	{
194	return list_entry(h, struct kiocb, ki_list);
195	}
196
197	/* for sysctl: */
198	extern atomic_t aio_nr;
199	extern unsigned aio_max_nr;
200
201	#endif /* __LINUX__AIO_H */