LCOV - code coverage report
Current view: top level - include/linux - pipe_fs_i.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 12 23 52.2 %
Date: 2022-04-01 14:35:51 Functions: 0 0 -
Branches: 20 38 52.6 %

           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                 :            :  *      @rd_wait: reader wait point in case of empty pipe
      33                 :            :  *      @wr_wait: writer wait point in case of full pipe
      34                 :            :  *      @head: The point of buffer production
      35                 :            :  *      @tail: The point of buffer consumption
      36                 :            :  *      @max_usage: The maximum number of slots that may be used in the ring
      37                 :            :  *      @ring_size: total number of buffers (should be a power of 2)
      38                 :            :  *      @tmp_page: cached released page
      39                 :            :  *      @readers: number of current readers of this pipe
      40                 :            :  *      @writers: number of current writers of this pipe
      41                 :            :  *      @files: number of struct file referring this pipe (protected by ->i_lock)
      42                 :            :  *      @r_counter: reader counter
      43                 :            :  *      @w_counter: writer counter
      44                 :            :  *      @fasync_readers: reader side fasync
      45                 :            :  *      @fasync_writers: writer side fasync
      46                 :            :  *      @bufs: the circular array of pipe buffers
      47                 :            :  *      @user: the user who created this pipe
      48                 :            :  **/
      49                 :            : struct pipe_inode_info {
      50                 :            :         struct mutex mutex;
      51                 :            :         wait_queue_head_t rd_wait, wr_wait;
      52                 :            :         unsigned int head;
      53                 :            :         unsigned int tail;
      54                 :            :         unsigned int max_usage;
      55                 :            :         unsigned int ring_size;
      56                 :            :         unsigned int readers;
      57                 :            :         unsigned int writers;
      58                 :            :         unsigned int files;
      59                 :            :         unsigned int r_counter;
      60                 :            :         unsigned int w_counter;
      61                 :            :         struct page *tmp_page;
      62                 :            :         struct fasync_struct *fasync_readers;
      63                 :            :         struct fasync_struct *fasync_writers;
      64                 :            :         struct pipe_buffer *bufs;
      65                 :            :         struct user_struct *user;
      66                 :            : };
      67                 :            : 
      68                 :            : /*
      69                 :            :  * Note on the nesting of these functions:
      70                 :            :  *
      71                 :            :  * ->confirm()
      72                 :            :  *      ->steal()
      73                 :            :  *
      74                 :            :  * That is, ->steal() must be called on a confirmed buffer.
      75                 :            :  * See below for the meaning of each operation. Also see kerneldoc
      76                 :            :  * in fs/pipe.c for the pipe and generic variants of these hooks.
      77                 :            :  */
      78                 :            : struct pipe_buf_operations {
      79                 :            :         /*
      80                 :            :          * ->confirm() verifies that the data in the pipe buffer is there
      81                 :            :          * and that the contents are good. If the pages in the pipe belong
      82                 :            :          * to a file system, we may need to wait for IO completion in this
      83                 :            :          * hook. Returns 0 for good, or a negative error value in case of
      84                 :            :          * error.
      85                 :            :          */
      86                 :            :         int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *);
      87                 :            : 
      88                 :            :         /*
      89                 :            :          * When the contents of this pipe buffer has been completely
      90                 :            :          * consumed by a reader, ->release() is called.
      91                 :            :          */
      92                 :            :         void (*release)(struct pipe_inode_info *, struct pipe_buffer *);
      93                 :            : 
      94                 :            :         /*
      95                 :            :          * Attempt to take ownership of the pipe buffer and its contents.
      96                 :            :          * ->steal() returns 0 for success, in which case the contents
      97                 :            :          * of the pipe (the buf->page) is locked and now completely owned
      98                 :            :          * by the caller. The page may then be transferred to a different
      99                 :            :          * mapping, the most often used case is insertion into different
     100                 :            :          * file address space cache.
     101                 :            :          */
     102                 :            :         int (*steal)(struct pipe_inode_info *, struct pipe_buffer *);
     103                 :            : 
     104                 :            :         /*
     105                 :            :          * Get a reference to the pipe buffer.
     106                 :            :          */
     107                 :            :         bool (*get)(struct pipe_inode_info *, struct pipe_buffer *);
     108                 :            : };
     109                 :            : 
     110                 :            : /**
     111                 :            :  * pipe_empty - Return true if the pipe is empty
     112                 :            :  * @head: The pipe ring head pointer
     113                 :            :  * @tail: The pipe ring tail pointer
     114                 :            :  */
     115                 :     438483 : static inline bool pipe_empty(unsigned int head, unsigned int tail)
     116                 :            : {
     117   [ +  +  +  +  :     438483 :         return head == tail;
          +  +  -  +  +  
          +  +  +  +  +  
                   -  - ]
     118                 :            : }
     119                 :            : 
     120                 :            : /**
     121                 :            :  * pipe_occupancy - Return number of slots used in the pipe
     122                 :            :  * @head: The pipe ring head pointer
     123                 :            :  * @tail: The pipe ring tail pointer
     124                 :            :  */
     125                 :     146428 : static inline unsigned int pipe_occupancy(unsigned int head, unsigned int tail)
     126                 :            : {
     127         [ -  + ]:        168 :         return head - tail;
     128                 :            : }
     129                 :            : 
     130                 :            : /**
     131                 :            :  * pipe_full - Return true if the pipe is full
     132                 :            :  * @head: The pipe ring head pointer
     133                 :            :  * @tail: The pipe ring tail pointer
     134                 :            :  * @limit: The maximum amount of slots available.
     135                 :            :  */
     136                 :     146260 : static inline bool pipe_full(unsigned int head, unsigned int tail,
     137                 :            :                              unsigned int limit)
     138                 :            : {
     139   [ +  +  +  -  :     146260 :         return pipe_occupancy(head, tail) >= limit;
          +  +  -  -  -  
             -  -  -  -  
                      + ]
     140                 :            : }
     141                 :            : 
     142                 :            : /**
     143                 :            :  * pipe_space_for_user - Return number of slots available to userspace
     144                 :            :  * @head: The pipe ring head pointer
     145                 :            :  * @tail: The pipe ring tail pointer
     146                 :            :  * @pipe: The pipe info structure
     147                 :            :  */
     148                 :          0 : static inline unsigned int pipe_space_for_user(unsigned int head, unsigned int tail,
     149                 :            :                                                struct pipe_inode_info *pipe)
     150                 :            : {
     151                 :          0 :         unsigned int p_occupancy, p_space;
     152                 :            : 
     153                 :          0 :         p_occupancy = pipe_occupancy(head, tail);
     154   [ #  #  #  #  :          0 :         if (p_occupancy >= pipe->max_usage)
                   #  # ]
     155                 :            :                 return 0;
     156                 :          0 :         p_space = pipe->ring_size - p_occupancy;
     157                 :          0 :         if (p_space > pipe->max_usage)
     158                 :            :                 p_space = pipe->max_usage;
     159                 :            :         return p_space;
     160                 :            : }
     161                 :            : 
     162                 :            : /**
     163                 :            :  * pipe_buf_get - get a reference to a pipe_buffer
     164                 :            :  * @pipe:       the pipe that the buffer belongs to
     165                 :            :  * @buf:        the buffer to get a reference to
     166                 :            :  *
     167                 :            :  * Return: %true if the reference was successfully obtained.
     168                 :            :  */
     169                 :          0 : static inline __must_check bool pipe_buf_get(struct pipe_inode_info *pipe,
     170                 :            :                                 struct pipe_buffer *buf)
     171                 :            : {
     172                 :          0 :         return buf->ops->get(pipe, buf);
     173                 :            : }
     174                 :            : 
     175                 :            : /**
     176                 :            :  * pipe_buf_release - put a reference to a pipe_buffer
     177                 :            :  * @pipe:       the pipe that the buffer belongs to
     178                 :            :  * @buf:        the buffer to put a reference to
     179                 :            :  */
     180                 :        269 : static inline void pipe_buf_release(struct pipe_inode_info *pipe,
     181                 :            :                                     struct pipe_buffer *buf)
     182                 :            : {
     183                 :        269 :         const struct pipe_buf_operations *ops = buf->ops;
     184                 :            : 
     185                 :        269 :         buf->ops = NULL;
     186                 :        269 :         ops->release(pipe, buf);
     187                 :          0 : }
     188                 :            : 
     189                 :            : /**
     190                 :            :  * pipe_buf_confirm - verify contents of the pipe buffer
     191                 :            :  * @pipe:       the pipe that the buffer belongs to
     192                 :            :  * @buf:        the buffer to confirm
     193                 :            :  */
     194                 :        294 : static inline int pipe_buf_confirm(struct pipe_inode_info *pipe,
     195                 :            :                                    struct pipe_buffer *buf)
     196                 :            : {
     197                 :        294 :         return buf->ops->confirm(pipe, buf);
     198                 :            : }
     199                 :            : 
     200                 :            : /**
     201                 :            :  * pipe_buf_steal - attempt to take ownership of a pipe_buffer
     202                 :            :  * @pipe:       the pipe that the buffer belongs to
     203                 :            :  * @buf:        the buffer to attempt to steal
     204                 :            :  */
     205                 :          0 : static inline int pipe_buf_steal(struct pipe_inode_info *pipe,
     206                 :            :                                  struct pipe_buffer *buf)
     207                 :            : {
     208                 :          0 :         return buf->ops->steal(pipe, buf);
     209                 :            : }
     210                 :            : 
     211                 :            : /* Differs from PIPE_BUF in that PIPE_SIZE is the length of the actual
     212                 :            :    memory allocation, whereas PIPE_BUF makes atomicity guarantees.  */
     213                 :            : #define PIPE_SIZE               PAGE_SIZE
     214                 :            : 
     215                 :            : /* Pipe lock and unlock operations */
     216                 :            : void pipe_lock(struct pipe_inode_info *);
     217                 :            : void pipe_unlock(struct pipe_inode_info *);
     218                 :            : void pipe_double_lock(struct pipe_inode_info *, struct pipe_inode_info *);
     219                 :            : 
     220                 :            : extern unsigned int pipe_max_size;
     221                 :            : extern unsigned long pipe_user_pages_hard;
     222                 :            : extern unsigned long pipe_user_pages_soft;
     223                 :            : 
     224                 :            : /* Drop the inode semaphore and wait for a pipe event, atomically */
     225                 :            : void pipe_wait(struct pipe_inode_info *pipe);
     226                 :            : 
     227                 :            : struct pipe_inode_info *alloc_pipe_info(void);
     228                 :            : void free_pipe_info(struct pipe_inode_info *);
     229                 :            : 
     230                 :            : /* Generic pipe buffer ops functions */
     231                 :            : bool generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
     232                 :            : int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *);
     233                 :            : int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *);
     234                 :            : int generic_pipe_buf_nosteal(struct pipe_inode_info *, struct pipe_buffer *);
     235                 :            : void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *);
     236                 :            : void pipe_buf_mark_unmergeable(struct pipe_buffer *buf);
     237                 :            : 
     238                 :            : extern const struct pipe_buf_operations nosteal_pipe_buf_ops;
     239                 :            : 
     240                 :            : /* for F_SETPIPE_SZ and F_GETPIPE_SZ */
     241                 :            : long pipe_fcntl(struct file *, unsigned int, unsigned long arg);
     242                 :            : struct pipe_inode_info *get_pipe_info(struct file *file);
     243                 :            : 
     244                 :            : int create_pipe_files(struct file **, int);
     245                 :            : unsigned int round_pipe_size(unsigned long size);
     246                 :            : 
     247                 :            : #endif

Generated by: LCOV version 1.14