Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef _LINUX_PIPE_FS_I_H
       3                 :            : #define _LINUX_PIPE_FS_I_H
       4                 :            : 
       5                 :            : #define PIPE_DEF_BUFFERS        16
       6                 :            : 
       7                 :            : #define PIPE_BUF_FLAG_LRU       0x01    /* page is on the LRU */
       8                 :            : #define PIPE_BUF_FLAG_ATOMIC    0x02    /* was atomically mapped */
       9                 :            : #define PIPE_BUF_FLAG_GIFT      0x04    /* page is a gift */
      10                 :            : #define PIPE_BUF_FLAG_PACKET    0x08    /* read() as a packet */
      11                 :            : 
      12                 :            : /**
      13                 :            :  *      struct pipe_buffer - a linux kernel pipe buffer
      14                 :            :  *      @page: the page containing the data for the pipe buffer
      15                 :            :  *      @offset: offset of data inside the @page
      16                 :            :  *      @len: length of data inside the @page
      17                 :            :  *      @ops: operations associated with this buffer. See @pipe_buf_operations.
      18                 :            :  *      @flags: pipe buffer flags. See above.
      19                 :            :  *      @private: private data owned by the ops.
      20                 :            :  **/
      21                 :            : struct pipe_buffer {
      22                 :            :         struct page *page;
      23                 :            :         unsigned int offset, len;
      24                 :            :         const struct pipe_buf_operations *ops;
      25                 :            :         unsigned int flags;
      26                 :            :         unsigned long private;
      27                 :            : };
      28                 :            : 
      29                 :            : /**
      30                 :            :  *      struct pipe_inode_info - a linux kernel pipe
      31                 :            :  *      @mutex: mutex protecting the whole thing
      32                 :            :  *      @wait: reader/writer wait point in case of empty/full pipe
      33                 :            :  *      @nrbufs: the number of non-empty pipe buffers in this pipe
      34                 :            :  *      @buffers: total number of buffers (should be a power of 2)
      35                 :            :  *      @curbuf: the current pipe buffer entry
      36                 :            :  *      @tmp_page: cached released page
      37                 :            :  *      @readers: number of current readers of this pipe
      38                 :            :  *      @writers: number of current writers of this pipe
      39                 :            :  *      @files: number of struct file referring this pipe (protected by ->i_lock)
      40                 :            :  *      @waiting_writers: number of writers blocked waiting for room
      41                 :            :  *      @r_counter: reader counter
      42                 :            :  *      @w_counter: writer counter
      43                 :            :  *      @fasync_readers: reader side fasync
      44                 :            :  *      @fasync_writers: writer side fasync
      45                 :            :  *      @bufs: the circular array of pipe buffers
      46                 :            :  *      @user: the user who created this pipe
      47                 :            :  **/
      48                 :            : struct pipe_inode_info {
      49                 :            :         struct mutex mutex;
      50                 :            :         wait_queue_head_t wait;
      51                 :            :         unsigned int nrbufs, curbuf, buffers;
      52                 :            :         unsigned int readers;
      53                 :            :         unsigned int writers;
      54                 :            :         unsigned int files;
      55                 :            :         unsigned int waiting_writers;
      56                 :            :         unsigned int r_counter;
      57                 :            :         unsigned int w_counter;
      58                 :            :         struct page *tmp_page;
      59                 :            :         struct fasync_struct *fasync_readers;
      60                 :            :         struct fasync_struct *fasync_writers;
      61                 :            :         struct pipe_buffer *bufs;
      62                 :            :         struct user_struct *user;
      63                 :            : };
      64                 :            : 
      65                 :            : /*
      66                 :            :  * Note on the nesting of these functions:
      67                 :            :  *
      68                 :            :  * ->confirm()
      69                 :            :  *      ->steal()
      70                 :            :  *
      71                 :            :  * That is, ->steal() must be called on a confirmed buffer.
      72                 :            :  * See below for the meaning of each operation. Also see kerneldoc
      73                 :            :  * in fs/pipe.c for the pipe and generic variants of these hooks.
      74                 :            :  */
      75                 :            : struct pipe_buf_operations {
      76                 :            :         /*
      77                 :            :          * ->confirm() verifies that the data in the pipe buffer is there
      78                 :            :          * and that the contents are good. If the pages in the pipe belong
      79                 :            :          * to a file system, we may need to wait for IO completion in this
      80                 :            :          * hook. Returns 0 for good, or a negative error value in case of
      81                 :            :          * error.
      82                 :            :          */
      83                 :            :         int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *);
      84                 :            : 
      85                 :            :         /*
      86                 :            :          * When the contents of this pipe buffer has been completely
      87                 :            :          * consumed by a reader, ->release() is called.
      88                 :            :          */
      89                 :            :         void (*release)(struct pipe_inode_info *, struct pipe_buffer *);
      90                 :            : 
      91                 :            :         /*
      92                 :            :          * Attempt to take ownership of the pipe buffer and its contents.
      93                 :            :          * ->steal() returns 0 for success, in which case the contents
      94                 :            :          * of the pipe (the buf->page) is locked and now completely owned
      95                 :            :          * by the caller. The page may then be transferred to a different
      96                 :            :          * mapping, the most often used case is insertion into different
      97                 :            :          * file address space cache.
      98                 :            :          */
      99                 :            :         int (*steal)(struct pipe_inode_info *, struct pipe_buffer *);
     100                 :            : 
     101                 :            :         /*
     102                 :            :          * Get a reference to the pipe buffer.
     103                 :            :          */
     104                 :            :         bool (*get)(struct pipe_inode_info *, struct pipe_buffer *);
     105                 :            : };
     106                 :            : 
     107                 :            : /**
     108                 :            :  * pipe_buf_get - get a reference to a pipe_buffer
     109                 :            :  * @pipe:       the pipe that the buffer belongs to
     110                 :            :  * @buf:        the buffer to get a reference to
     111                 :            :  *
     112                 :            :  * Return: %true if the reference was successfully obtained.
     113                 :            :  */
     114                 :            : static inline __must_check bool pipe_buf_get(struct pipe_inode_info *pipe,
     115                 :            :                                 struct pipe_buffer *buf)
     116                 :            : {
     117                 :          0 :         return buf->ops->get(pipe, buf);
     118                 :            : }
     119                 :            : 
     120                 :            : /**
     121                 :            :  * pipe_buf_release - put a reference to a pipe_buffer
     122                 :            :  * @pipe:       the pipe that the buffer belongs to
     123                 :            :  * @buf:        the buffer to put a reference to
     124                 :            :  */
     125                 :            : static inline void pipe_buf_release(struct pipe_inode_info *pipe,
     126                 :            :                                     struct pipe_buffer *buf)
     127                 :            : {
     128                 :          3 :         const struct pipe_buf_operations *ops = buf->ops;
     129                 :            : 
     130                 :          3 :         buf->ops = NULL;
     131                 :          3 :         ops->release(pipe, buf);
     132                 :            : }
     133                 :            : 
     134                 :            : /**
     135                 :            :  * pipe_buf_confirm - verify contents of the pipe buffer
     136                 :            :  * @pipe:       the pipe that the buffer belongs to
     137                 :            :  * @buf:        the buffer to confirm
     138                 :            :  */
     139                 :            : static inline int pipe_buf_confirm(struct pipe_inode_info *pipe,
     140                 :            :                                    struct pipe_buffer *buf)
     141                 :            : {
     142                 :          3 :         return buf->ops->confirm(pipe, buf);
     143                 :            : }
     144                 :            : 
     145                 :            : /**
     146                 :            :  * pipe_buf_steal - attempt to take ownership of a pipe_buffer
     147                 :            :  * @pipe:       the pipe that the buffer belongs to
     148                 :            :  * @buf:        the buffer to attempt to steal
     149                 :            :  */
     150                 :            : static inline int pipe_buf_steal(struct pipe_inode_info *pipe,
     151                 :            :                                  struct pipe_buffer *buf)
     152                 :            : {
     153                 :          0 :         return buf->ops->steal(pipe, buf);
     154                 :            : }
     155                 :            : 
     156                 :            : /* Differs from PIPE_BUF in that PIPE_SIZE is the length of the actual
     157                 :            :    memory allocation, whereas PIPE_BUF makes atomicity guarantees.  */
     158                 :            : #define PIPE_SIZE               PAGE_SIZE
     159                 :            : 
     160                 :            : /* Pipe lock and unlock operations */
     161                 :            : void pipe_lock(struct pipe_inode_info *);
     162                 :            : void pipe_unlock(struct pipe_inode_info *);
     163                 :            : void pipe_double_lock(struct pipe_inode_info *, struct pipe_inode_info *);
     164                 :            : 
     165                 :            : extern unsigned int pipe_max_size;
     166                 :            : extern unsigned long pipe_user_pages_hard;
     167                 :            : extern unsigned long pipe_user_pages_soft;
     168                 :            : 
     169                 :            : /* Drop the inode semaphore and wait for a pipe event, atomically */
     170                 :            : void pipe_wait(struct pipe_inode_info *pipe);
     171                 :            : 
     172                 :            : struct pipe_inode_info *alloc_pipe_info(void);
     173                 :            : void free_pipe_info(struct pipe_inode_info *);
     174                 :            : 
     175                 :            : /* Generic pipe buffer ops functions */
     176                 :            : bool generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
     177                 :            : int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *);
     178                 :            : int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *);
     179                 :            : int generic_pipe_buf_nosteal(struct pipe_inode_info *, struct pipe_buffer *);
     180                 :            : void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *);
     181                 :            : void pipe_buf_mark_unmergeable(struct pipe_buffer *buf);
     182                 :            : 
     183                 :            : extern const struct pipe_buf_operations nosteal_pipe_buf_ops;
     184                 :            : 
     185                 :            : /* for F_SETPIPE_SZ and F_GETPIPE_SZ */
     186                 :            : long pipe_fcntl(struct file *, unsigned int, unsigned long arg);
     187                 :            : struct pipe_inode_info *get_pipe_info(struct file *file);
     188                 :            : 
     189                 :            : int create_pipe_files(struct file **, int);
     190                 :            : unsigned int round_pipe_size(unsigned long size);
     191                 :            : 
     192                 :            : #endif