WebSVN - shark - Blame - Rev 422 - /shark/trunk/drivers/linuxc26/include/linux/aio.h

Rev	Author	Line No.	Line
422	giacomo	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	#define KIOCB_PRIVATE_SIZE (24 * sizeof(long))
		27
		28	/* ki_flags bits */
		29	#define KIF_LOCKED 0
		30	#define KIF_KICKED 1
		31	#define KIF_CANCELLED 2
		32
		33	#define kiocbTryLock(iocb) test_and_set_bit(KIF_LOCKED, &(iocb)->ki_flags)
		34	#define kiocbTryKick(iocb) test_and_set_bit(KIF_KICKED, &(iocb)->ki_flags)
		35
		36	#define kiocbSetLocked(iocb) set_bit(KIF_LOCKED, &(iocb)->ki_flags)
		37	#define kiocbSetKicked(iocb) set_bit(KIF_KICKED, &(iocb)->ki_flags)
		38	#define kiocbSetCancelled(iocb) set_bit(KIF_CANCELLED, &(iocb)->ki_flags)
		39
		40	#define kiocbClearLocked(iocb) clear_bit(KIF_LOCKED, &(iocb)->ki_flags)
		41	#define kiocbClearKicked(iocb) clear_bit(KIF_KICKED, &(iocb)->ki_flags)
		42	#define kiocbClearCancelled(iocb) clear_bit(KIF_CANCELLED, &(iocb)->ki_flags)
		43
		44	#define kiocbIsLocked(iocb) test_bit(KIF_LOCKED, &(iocb)->ki_flags)
		45	#define kiocbIsKicked(iocb) test_bit(KIF_KICKED, &(iocb)->ki_flags)
		46	#define kiocbIsCancelled(iocb) test_bit(KIF_CANCELLED, &(iocb)->ki_flags)
		47
		48	struct kiocb {
		49	struct list_head ki_run_list;
		50	long ki_flags;
		51	int ki_users;
		52	unsigned ki_key; /* id of this request */
		53
		54	struct file *ki_filp;
		55	struct kioctx ki_ctx; / may be NULL for sync ops */
		56	int (ki_cancel)(struct kiocb , struct io_event *);
		57	long (ki_retry)(struct kiocb );
		58
		59	struct list_head ki_list; /* the aio core uses this
		60	* for cancellation */
		61
		62	void ki_user_obj; / pointer to userland's iocb */
		63	__u64 ki_user_data; /* user's data for completion */
		64	loff_t ki_pos;
		65
		66	char private[KIOCB_PRIVATE_SIZE];
		67	};
		68
		69	#define is_sync_kiocb(iocb) ((iocb)->ki_key == KIOCB_SYNC_KEY)
		70	#define init_sync_kiocb(x, filp) \
		71	do { \
		72	struct task_struct *tsk = current; \
		73	(x)->ki_flags = 0; \
		74	(x)->ki_users = 1; \
		75	(x)->ki_key = KIOCB_SYNC_KEY; \
		76	(x)->ki_filp = (filp); \
		77	(x)->ki_ctx = &tsk->active_mm->default_kioctx; \
		78	(x)->ki_cancel = NULL; \
		79	(x)->ki_user_obj = tsk; \
		80	} while (0)
		81
		82	#define AIO_RING_MAGIC 0xa10a10a1
		83	#define AIO_RING_COMPAT_FEATURES 1
		84	#define AIO_RING_INCOMPAT_FEATURES 0
		85	struct aio_ring {
		86	unsigned id; /* kernel internal index number */
		87	unsigned nr; /* number of io_events */
		88	unsigned head;
		89	unsigned tail;
		90
		91	unsigned magic;
		92	unsigned compat_features;
		93	unsigned incompat_features;
		94	unsigned header_length; /* size of aio_ring */
		95
		96
		97	struct io_event io_events[0];
		98	}; /* 128 bytes + ring size */
		99
		100	#define aio_ring_avail(info, ring) (((ring)->head + (info)->nr - 1 - (ring)->tail) % (info)->nr)
		101
		102	#define AIO_RING_PAGES 8
		103	struct aio_ring_info {
		104	unsigned long mmap_base;
		105	unsigned long mmap_size;
		106
		107	struct page **ring_pages;
		108	spinlock_t ring_lock;
		109	long nr_pages;
		110
		111	unsigned nr, tail;
		112
		113	struct page *internal_pages[AIO_RING_PAGES];
		114	};
		115
		116	struct kioctx {
		117	atomic_t users;
		118	int dead;
		119	struct mm_struct *mm;
		120
		121	/* This needs improving */
		122	unsigned long user_id;
		123	struct kioctx *next;
		124
		125	wait_queue_head_t wait;
		126
		127	spinlock_t ctx_lock;
		128
		129	int reqs_active;
		130	struct list_head active_reqs; /* used for cancellation */
		131	struct list_head run_list; /* used for kicked reqs */
		132
		133	unsigned max_reqs;
		134
		135	struct aio_ring_info ring_info;
		136
		137	struct work_struct wq;
		138	};
		139
		140	/* prototypes */
		141	extern unsigned aio_max_size;
		142
		143	extern ssize_t FASTCALL(wait_on_sync_kiocb(struct kiocb *iocb));
		144	extern int FASTCALL(aio_put_req(struct kiocb *iocb));
		145	extern void FASTCALL(kick_iocb(struct kiocb *iocb));
		146	extern int FASTCALL(aio_complete(struct kiocb *iocb, long res, long res2));
		147	extern void FASTCALL(__put_ioctx(struct kioctx *ctx));
		148	struct mm_struct;
		149	extern void FASTCALL(exit_aio(struct mm_struct *mm));
		150	extern struct kioctx *lookup_ioctx(unsigned long ctx_id);
		151	extern int FASTCALL(io_submit_one(struct kioctx *ctx,
		152	struct iocb user_iocb, struct iocb iocb));
		153
		154	/* semi private, but used by the 32bit emulations: */
		155	struct kioctx *lookup_ioctx(unsigned long ctx_id);
		156	int FASTCALL(io_submit_one(struct kioctx ctx, struct iocb user_iocb,
		157	struct iocb *iocb));
		158
		159	#define get_ioctx(kioctx) do { if (unlikely(atomic_read(&(kioctx)->users) <= 0)) BUG(); atomic_inc(&(kioctx)->users); } while (0)
		160	#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)
		161
		162	#include <linux/aio_abi.h>
		163
		164	static inline struct kiocb list_kiocb(struct list_head h)
		165	{
		166	return list_entry(h, struct kiocb, ki_list);
		167	}
		168
		169	/* for sysctl: */
		170	extern unsigned aio_max_nr, aio_max_size, aio_max_pinned;
		171
		172	#endif /* __LINUX__AIO_H */

Subversion Repositories shark

(root)/shark/trunk/drivers/linuxc26/include/linux/aio.h @ 423 - Rev 422