239 lines · 7.5 KB · C
RawDownload
#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 <linux/rcupdate.h> #include <linux/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 *//* * 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;	unsigned 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 */	loff_t			ki_pos; 	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 */	struct list_head	ki_batch;	/* batch allocation */ 	/*	 * If the aio_resfd field of the userspace iocb is not zero,	 * this is the underlying eventfd context to deliver events to.	 */	struct eventfd_ctx	*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;                  \	} while (0) #define AIO_RING_MAGIC			0xa10a10a1#define AIO_RING_COMPAT_FEATURES	1#define AIO_RING_INCOMPAT_FEATURES	0struct 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	8struct 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 hlist_node	list; 	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; 	struct rcu_head		rcu_head;}; /* prototypes */extern unsigned aio_max_size; #ifdef CONFIG_AIOextern ssize_t wait_on_sync_kiocb(struct kiocb *iocb);extern int aio_put_req(struct kiocb *iocb);extern void kick_iocb(struct kiocb *iocb);extern int aio_complete(struct kiocb *iocb, long res, long res2);struct mm_struct;extern void exit_aio(struct mm_struct *mm);extern long do_io_submit(aio_context_t ctx_id, long nr,			 struct iocb __user *__user *iocbpp, bool compat);#elsestatic inline ssize_t wait_on_sync_kiocb(struct kiocb *iocb) { return 0; }static inline int aio_put_req(struct kiocb *iocb) { return 0; }static inline void kick_iocb(struct kiocb *iocb) { }static inline int aio_complete(struct kiocb *iocb, long res, long res2) { return 0; }struct mm_struct;static inline void exit_aio(struct mm_struct *mm) { }static inline long do_io_submit(aio_context_t ctx_id, long nr,				struct iocb __user * __user *iocbpp,				bool compat) { return 0; }#endif /* CONFIG_AIO */ 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 */

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t