LCOV - code coverage report
Current view: top level - include/linux - aio.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 2 2 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       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             : #include <linux/uio.h>
       8             : #include <linux/rcupdate.h>
       9             : 
      10             : #include <asm/atomic.h>
      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 */
      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 */
      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             : 
      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             :  */
      87             : struct kiocb {
      88             :         struct list_head        ki_run_list;
      89             :         unsigned 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             : 
      99             :         union {
     100             :                 void __user             *user;
     101             :                 struct task_struct      *tsk;
     102             :         } ki_obj;
     103             : 
     104             :         __u64                   ki_user_data;   /* user's data for completion */
     105             :         loff_t                  ki_pos;
     106             : 
     107             :         void                    *private;
     108             :         /* State that we remember to be able to restart/retry  */
     109             :         unsigned short          ki_opcode;
     110             :         size_t                  ki_nbytes;      /* copy of iocb->aio_nbytes */
     111             :         char                    __user *ki_buf; /* remaining iocb->aio_buf */
     112             :         size_t                  ki_left;        /* remaining bytes */
     113             :         struct iovec            ki_inline_vec;  /* inline vector */
     114             :         struct iovec            *ki_iovec;
     115             :         unsigned long           ki_nr_segs;
     116             :         unsigned long           ki_cur_seg;
     117             : 
     118             :         struct list_head        ki_list;        /* the aio core uses this
     119             :                                                  * for cancellation */
     120             : 
     121             :         /*
     122             :          * If the aio_resfd field of the userspace iocb is not zero,
     123             :          * this is the underlying eventfd context to deliver events to.
     124             :          */
     125             :         struct eventfd_ctx      *ki_eventfd;
     126             : };
     127             : 
     128             : #define is_sync_kiocb(iocb)     ((iocb)->ki_key == KIOCB_SYNC_KEY)
     129             : #define init_sync_kiocb(x, filp)                        \
     130             :         do {                                            \
     131             :                 struct task_struct *tsk = current;      \
     132             :                 (x)->ki_flags = 0;                   \
     133             :                 (x)->ki_users = 1;                   \
     134             :                 (x)->ki_key = KIOCB_SYNC_KEY;                \
     135             :                 (x)->ki_filp = (filp);                       \
     136             :                 (x)->ki_ctx = NULL;                  \
     137             :                 (x)->ki_cancel = NULL;                       \
     138             :                 (x)->ki_retry = NULL;                        \
     139             :                 (x)->ki_dtor = NULL;                 \
     140             :                 (x)->ki_obj.tsk = tsk;                       \
     141             :                 (x)->ki_user_data = 0;                  \
     142             :         } while (0)
     143             : 
     144             : #define AIO_RING_MAGIC                  0xa10a10a1
     145             : #define AIO_RING_COMPAT_FEATURES        1
     146             : #define AIO_RING_INCOMPAT_FEATURES      0
     147             : struct aio_ring {
     148             :         unsigned        id;     /* kernel internal index number */
     149             :         unsigned        nr;     /* number of io_events */
     150             :         unsigned        head;
     151             :         unsigned        tail;
     152             : 
     153             :         unsigned        magic;
     154             :         unsigned        compat_features;
     155             :         unsigned        incompat_features;
     156             :         unsigned        header_length;  /* size of aio_ring */
     157             : 
     158             : 
     159             :         struct io_event         io_events[0];
     160             : }; /* 128 bytes + ring size */
     161           1 : 
     162             : #define aio_ring_avail(info, ring)      (((ring)->head + (info)->nr - 1 - (ring)->tail) % (info)->nr)
     163             : 
     164             : #define AIO_RING_PAGES  8
     165             : struct aio_ring_info {
     166             :         unsigned long           mmap_base;
     167             :         unsigned long           mmap_size;
     168             : 
     169             :         struct page             **ring_pages;
     170             :         spinlock_t              ring_lock;
     171             :         long                    nr_pages;
     172             : 
     173             :         unsigned                nr, tail;
     174             : 
     175             :         struct page             *internal_pages[AIO_RING_PAGES];
     176             : };
     177           1 : 
     178             : struct kioctx {
     179             :         atomic_t                users;
     180             :         int                     dead;
     181             :         struct mm_struct        *mm;
     182             : 
     183             :         /* This needs improving */
     184             :         unsigned long           user_id;
     185             :         struct hlist_node       list;
     186             : 
     187             :         wait_queue_head_t       wait;
     188             : 
     189             :         spinlock_t              ctx_lock;
     190             : 
     191             :         int                     reqs_active;
     192             :         struct list_head        active_reqs;    /* used for cancellation */
     193             :         struct list_head        run_list;       /* used for kicked reqs */
     194             : 
     195             :         /* sys_io_setup currently limits this to an unsigned int */
     196             :         unsigned                max_reqs;
     197             : 
     198             :         struct aio_ring_info    ring_info;
     199             : 
     200             :         struct delayed_work     wq;
     201             : 
     202             :         struct rcu_head         rcu_head;
     203             : };
     204             : 
     205             : /* prototypes */
     206             : extern unsigned aio_max_size;
     207             : 
     208             : #ifdef CONFIG_AIO
     209             : extern ssize_t wait_on_sync_kiocb(struct kiocb *iocb);
     210             : extern int aio_put_req(struct kiocb *iocb);
     211             : extern void kick_iocb(struct kiocb *iocb);
     212             : extern int aio_complete(struct kiocb *iocb, long res, long res2);
     213             : struct mm_struct;
     214             : extern void exit_aio(struct mm_struct *mm);
     215             : #else
     216             : static inline ssize_t wait_on_sync_kiocb(struct kiocb *iocb) { return 0; }
     217             : static inline int aio_put_req(struct kiocb *iocb) { return 0; }
     218             : static inline void kick_iocb(struct kiocb *iocb) { }
     219             : static inline int aio_complete(struct kiocb *iocb, long res, long res2) { return 0; }
     220             : struct mm_struct;
     221             : static inline void exit_aio(struct mm_struct *mm) { }
     222             : #endif /* CONFIG_AIO */
     223             : 
     224             : static inline struct kiocb *list_kiocb(struct list_head *h)
     225             : {
     226             :         return list_entry(h, struct kiocb, ki_list);
     227             : }
     228             : 
     229             : /* for sysctl: */
     230             : extern unsigned long aio_nr;
     231             : extern unsigned long aio_max_nr;
     232             : 
     233             : #endif /* __LINUX__AIO_H */

Generated by: LCOV version 1.10