aio.h

Go to the documentation of this file.

#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? */
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;
};

static inline bool is_sync_kiocb(struct kiocb *kiocb)
{
    return kiocb->ki_key == KIOCB_SYNC_KEY;
}

static inline void init_sync_kiocb(struct kiocb *kiocb, struct file *filp)
{
    *kiocb = (struct kiocb) {
            .ki_users = 1,
            .ki_key = KIOCB_SYNC_KEY,
            .ki_filp = filp,
            .ki_obj.tsk = current,
        };
}

#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_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];
};

static inline unsigned aio_ring_avail(struct aio_ring_info *info,
                    struct aio_ring *ring)
{
    return (ring->head + info->nr - 1 - ring->tail) % info->nr;
}

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_AIO
extern 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);
#else
static 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 */