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             : #define PIPE_BUF_FLAG_CAN_MERGE 0x10    /* can merge buffers */
      12             : #define PIPE_BUF_FLAG_WHOLE     0x20    /* read() must return entire buffer or error */
      13             : #ifdef CONFIG_WATCH_QUEUE
      14             : #define PIPE_BUF_FLAG_LOSS      0x40    /* Message loss happened after this buffer */
      15             : #endif
      16             : 
      17             : /**
      18             :  *      struct pipe_buffer - a linux kernel pipe buffer
      19             :  *      @page: the page containing the data for the pipe buffer
      20             :  *      @offset: offset of data inside the @page
      21             :  *      @len: length of data inside the @page
      22             :  *      @ops: operations associated with this buffer. See @pipe_buf_operations.
      23             :  *      @flags: pipe buffer flags. See above.
      24             :  *      @private: private data owned by the ops.
      25             :  **/
      26             : struct pipe_buffer {
      27             :         struct page *page;
      28             :         unsigned int offset, len;
      29             :         const struct pipe_buf_operations *ops;
      30             :         unsigned int flags;
      31             :         unsigned long private;
      32             : };
      33             : 
      34             : /**
      35             :  *      struct pipe_inode_info - a linux kernel pipe
      36             :  *      @mutex: mutex protecting the whole thing
      37             :  *      @rd_wait: reader wait point in case of empty pipe
      38             :  *      @wr_wait: writer wait point in case of full pipe
      39             :  *      @head: The point of buffer production
      40             :  *      @tail: The point of buffer consumption
      41             :  *      @note_loss: The next read() should insert a data-lost message
      42             :  *      @max_usage: The maximum number of slots that may be used in the ring
      43             :  *      @ring_size: total number of buffers (should be a power of 2)
      44             :  *      @nr_accounted: The amount this pipe accounts for in user->pipe_bufs
      45             :  *      @tmp_page: cached released page
      46             :  *      @readers: number of current readers of this pipe
      47             :  *      @writers: number of current writers of this pipe
      48             :  *      @files: number of struct file referring this pipe (protected by ->i_lock)
      49             :  *      @r_counter: reader counter
      50             :  *      @w_counter: writer counter
      51             :  *      @fasync_readers: reader side fasync
      52             :  *      @fasync_writers: writer side fasync
      53             :  *      @bufs: the circular array of pipe buffers
      54             :  *      @user: the user who created this pipe
      55             :  *      @watch_queue: If this pipe is a watch_queue, this is the stuff for that
      56             :  **/
      57             : struct pipe_inode_info {
      58             :         struct mutex mutex;
      59             :         wait_queue_head_t rd_wait, wr_wait;
      60             :         unsigned int head;
      61             :         unsigned int tail;
      62             :         unsigned int max_usage;
      63             :         unsigned int ring_size;
      64             : #ifdef CONFIG_WATCH_QUEUE
      65             :         bool note_loss;
      66             : #endif
      67             :         unsigned int nr_accounted;
      68             :         unsigned int readers;
      69             :         unsigned int writers;
      70             :         unsigned int files;
      71             :         unsigned int r_counter;
      72             :         unsigned int w_counter;
      73             :         struct page *tmp_page;
      74             :         struct fasync_struct *fasync_readers;
      75             :         struct fasync_struct *fasync_writers;
      76             :         struct pipe_buffer *bufs;
      77             :         struct user_struct *user;
      78             : #ifdef CONFIG_WATCH_QUEUE
      79             :         struct watch_queue *watch_queue;
      80             : #endif
      81             : };
      82             : 
      83             : /*
      84             :  * Note on the nesting of these functions:
      85             :  *
      86             :  * ->confirm()
      87             :  *      ->try_steal()
      88             :  *
      89             :  * That is, ->try_steal() must be called on a confirmed buffer.  See below for
      90             :  * the meaning of each operation.  Also see the kerneldoc in fs/pipe.c for the
      91             :  * pipe and generic variants of these hooks.
      92             :  */
      93             : struct pipe_buf_operations {
      94             :         /*
      95             :          * ->confirm() verifies that the data in the pipe buffer is there
      96             :          * and that the contents are good. If the pages in the pipe belong
      97             :          * to a file system, we may need to wait for IO completion in this
      98             :          * hook. Returns 0 for good, or a negative error value in case of
      99             :          * error.  If not present all pages are considered good.
     100             :          */
     101             :         int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *);
     102             : 
     103             :         /*
     104             :          * When the contents of this pipe buffer has been completely
     105             :          * consumed by a reader, ->release() is called.
     106             :          */
     107             :         void (*release)(struct pipe_inode_info *, struct pipe_buffer *);
     108             : 
     109             :         /*
     110             :          * Attempt to take ownership of the pipe buffer and its contents.
     111             :          * ->try_steal() returns %true for success, in which case the contents
     112             :          * of the pipe (the buf->page) is locked and now completely owned by the
     113             :          * caller. The page may then be transferred to a different mapping, the
     114             :          * most often used case is insertion into different file address space
     115             :          * cache.
     116             :          */
     117             :         bool (*try_steal)(struct pipe_inode_info *, struct pipe_buffer *);
     118             : 
     119             :         /*
     120             :          * Get a reference to the pipe buffer.
     121             :          */
     122             :         bool (*get)(struct pipe_inode_info *, struct pipe_buffer *);
     123             : };
     124             : 
     125             : /**
     126             :  * pipe_empty - Return true if the pipe is empty
     127             :  * @head: The pipe ring head pointer
     128             :  * @tail: The pipe ring tail pointer
     129             :  */
     130       32856 : static inline bool pipe_empty(unsigned int head, unsigned int tail)
     131             : {
     132       32856 :         return head == tail;
     133             : }
     134             : 
     135             : /**
     136             :  * pipe_occupancy - Return number of slots used in the pipe
     137             :  * @head: The pipe ring head pointer
     138             :  * @tail: The pipe ring tail pointer
     139             :  */
     140       22516 : static inline unsigned int pipe_occupancy(unsigned int head, unsigned int tail)
     141             : {
     142         612 :         return head - tail;
     143             : }
     144             : 
     145             : /**
     146             :  * pipe_full - Return true if the pipe is full
     147             :  * @head: The pipe ring head pointer
     148             :  * @tail: The pipe ring tail pointer
     149             :  * @limit: The maximum amount of slots available.
     150             :  */
     151       21904 : static inline bool pipe_full(unsigned int head, unsigned int tail,
     152             :                              unsigned int limit)
     153             : {
     154       21824 :         return pipe_occupancy(head, tail) >= limit;
     155             : }
     156             : 
     157             : /**
     158             :  * pipe_space_for_user - Return number of slots available to userspace
     159             :  * @head: The pipe ring head pointer
     160             :  * @tail: The pipe ring tail pointer
     161             :  * @pipe: The pipe info structure
     162             :  */
     163           0 : static inline unsigned int pipe_space_for_user(unsigned int head, unsigned int tail,
     164             :                                                struct pipe_inode_info *pipe)
     165             : {
     166           0 :         unsigned int p_occupancy, p_space;
     167             : 
     168           0 :         p_occupancy = pipe_occupancy(head, tail);
     169           0 :         if (p_occupancy >= pipe->max_usage)
     170             :                 return 0;
     171           0 :         p_space = pipe->ring_size - p_occupancy;
     172           0 :         if (p_space > pipe->max_usage)
     173             :                 p_space = pipe->max_usage;
     174             :         return p_space;
     175             : }
     176             : 
     177             : /**
     178             :  * pipe_buf_get - get a reference to a pipe_buffer
     179             :  * @pipe:       the pipe that the buffer belongs to
     180             :  * @buf:        the buffer to get a reference to
     181             :  *
     182             :  * Return: %true if the reference was successfully obtained.
     183             :  */
     184           0 : static inline __must_check bool pipe_buf_get(struct pipe_inode_info *pipe,
     185             :                                 struct pipe_buffer *buf)
     186             : {
     187           0 :         return buf->ops->get(pipe, buf);
     188             : }
     189             : 
     190             : /**
     191             :  * pipe_buf_release - put a reference to a pipe_buffer
     192             :  * @pipe:       the pipe that the buffer belongs to
     193             :  * @buf:        the buffer to put a reference to
     194             :  */
     195        1652 : static inline void pipe_buf_release(struct pipe_inode_info *pipe,
     196             :                                     struct pipe_buffer *buf)
     197             : {
     198        1652 :         const struct pipe_buf_operations *ops = buf->ops;
     199             : 
     200        1652 :         buf->ops = NULL;
     201        1652 :         ops->release(pipe, buf);
     202           1 : }
     203             : 
     204             : /**
     205             :  * pipe_buf_confirm - verify contents of the pipe buffer
     206             :  * @pipe:       the pipe that the buffer belongs to
     207             :  * @buf:        the buffer to confirm
     208             :  */
     209       17750 : static inline int pipe_buf_confirm(struct pipe_inode_info *pipe,
     210             :                                    struct pipe_buffer *buf)
     211             : {
     212       17750 :         if (!buf->ops->confirm)
     213             :                 return 0;
     214         576 :         return buf->ops->confirm(pipe, buf);
     215             : }
     216             : 
     217             : /**
     218             :  * pipe_buf_try_steal - attempt to take ownership of a pipe_buffer
     219             :  * @pipe:       the pipe that the buffer belongs to
     220             :  * @buf:        the buffer to attempt to steal
     221             :  */
     222           0 : static inline bool pipe_buf_try_steal(struct pipe_inode_info *pipe,
     223             :                 struct pipe_buffer *buf)
     224             : {
     225           0 :         if (!buf->ops->try_steal)
     226             :                 return false;
     227           0 :         return buf->ops->try_steal(pipe, buf);
     228             : }
     229             : 
     230             : /* Differs from PIPE_BUF in that PIPE_SIZE is the length of the actual
     231             :    memory allocation, whereas PIPE_BUF makes atomicity guarantees.  */
     232             : #define PIPE_SIZE               PAGE_SIZE
     233             : 
     234             : /* Pipe lock and unlock operations */
     235             : void pipe_lock(struct pipe_inode_info *);
     236             : void pipe_unlock(struct pipe_inode_info *);
     237             : void pipe_double_lock(struct pipe_inode_info *, struct pipe_inode_info *);
     238             : 
     239             : extern unsigned int pipe_max_size;
     240             : extern unsigned long pipe_user_pages_hard;
     241             : extern unsigned long pipe_user_pages_soft;
     242             : 
     243             : /* Wait for a pipe to be readable/writable while dropping the pipe lock */
     244             : void pipe_wait_readable(struct pipe_inode_info *);
     245             : void pipe_wait_writable(struct pipe_inode_info *);
     246             : 
     247             : struct pipe_inode_info *alloc_pipe_info(void);
     248             : void free_pipe_info(struct pipe_inode_info *);
     249             : 
     250             : /* Generic pipe buffer ops functions */
     251             : bool generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
     252             : bool generic_pipe_buf_try_steal(struct pipe_inode_info *, struct pipe_buffer *);
     253             : void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *);
     254             : 
     255             : extern const struct pipe_buf_operations nosteal_pipe_buf_ops;
     256             : 
     257             : #ifdef CONFIG_WATCH_QUEUE
     258             : unsigned long account_pipe_buffers(struct user_struct *user,
     259             :                                    unsigned long old, unsigned long new);
     260             : bool too_many_pipe_buffers_soft(unsigned long user_bufs);
     261             : bool too_many_pipe_buffers_hard(unsigned long user_bufs);
     262             : bool pipe_is_unprivileged_user(void);
     263             : #endif
     264             : 
     265             : /* for F_SETPIPE_SZ and F_GETPIPE_SZ */
     266             : #ifdef CONFIG_WATCH_QUEUE
     267             : int pipe_resize_ring(struct pipe_inode_info *pipe, unsigned int nr_slots);
     268             : #endif
     269             : long pipe_fcntl(struct file *, unsigned int, unsigned long arg);
     270             : struct pipe_inode_info *get_pipe_info(struct file *file, bool for_splice);
     271             : 
     272             : int create_pipe_files(struct file **, int);
     273             : unsigned int round_pipe_size(unsigned long size);
     274             : 
     275             : #endif