Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
pipe_fs_i.h
Go to the documentation of this file.
1 #ifndef _LINUX_PIPE_FS_I_H
2 #define _LINUX_PIPE_FS_I_H
3 
4 #define PIPE_DEF_BUFFERS 16
5 
6 #define PIPE_BUF_FLAG_LRU 0x01 /* page is on the LRU */
7 #define PIPE_BUF_FLAG_ATOMIC 0x02 /* was atomically mapped */
8 #define PIPE_BUF_FLAG_GIFT 0x04 /* page is a gift */
9 #define PIPE_BUF_FLAG_PACKET 0x08 /* read() as a packet */
10 
20 struct pipe_buffer {
21  struct page *page;
22  unsigned int offset, len;
23  const struct pipe_buf_operations *ops;
24  unsigned int flags;
25  unsigned long private;
26 };
27 
45 struct pipe_inode_info {
46  wait_queue_head_t wait;
47  unsigned int nrbufs, curbuf, buffers;
48  unsigned int readers;
49  unsigned int writers;
50  unsigned int waiting_writers;
51  unsigned int r_counter;
52  unsigned int w_counter;
53  struct page *tmp_page;
54  struct fasync_struct *fasync_readers;
55  struct fasync_struct *fasync_writers;
56  struct inode *inode;
57  struct pipe_buffer *bufs;
58 };
59 
60 /*
61  * Note on the nesting of these functions:
62  *
63  * ->confirm()
64  * ->steal()
65  * ...
66  * ->map()
67  * ...
68  * ->unmap()
69  *
70  * That is, ->map() must be called on a confirmed buffer,
71  * same goes for ->steal(). See below for the meaning of each
72  * operation. Also see kerneldoc in fs/pipe.c for the pipe
73  * and generic variants of these hooks.
74  */
75 struct pipe_buf_operations {
76  /*
77  * This is set to 1, if the generic pipe read/write may coalesce
78  * data into an existing buffer. If this is set to 0, a new pipe
79  * page segment is always used for new data.
80  */
81  int can_merge;
82 
83  /*
84  * ->map() returns a virtual address mapping of the pipe buffer.
85  * The last integer flag reflects whether this should be an atomic
86  * mapping or not. The atomic map is faster, however you can't take
87  * page faults before calling ->unmap() again. So if you need to eg
88  * access user data through copy_to/from_user(), then you must get
89  * a non-atomic map. ->map() uses the kmap_atomic slot for
90  * atomic maps, you have to be careful if mapping another page as
91  * source or destination for a copy.
92  */
93  void * (*map)(struct pipe_inode_info *, struct pipe_buffer *, int);
94 
95  /*
96  * Undoes ->map(), finishes the virtual mapping of the pipe buffer.
97  */
98  void (*unmap)(struct pipe_inode_info *, struct pipe_buffer *, void *);
99 
100  /*
101  * ->confirm() verifies that the data in the pipe buffer is there
102  * and that the contents are good. If the pages in the pipe belong
103  * to a file system, we may need to wait for IO completion in this
104  * hook. Returns 0 for good, or a negative error value in case of
105  * error.
106  */
107  int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *);
108 
109  /*
110  * When the contents of this pipe buffer has been completely
111  * consumed by a reader, ->release() is called.
112  */
113  void (*release)(struct pipe_inode_info *, struct pipe_buffer *);
114 
115  /*
116  * Attempt to take ownership of the pipe buffer and its contents.
117  * ->steal() returns 0 for success, in which case the contents
118  * of the pipe (the buf->page) is locked and now completely owned
119  * by the caller. The page may then be transferred to a different
120  * mapping, the most often used case is insertion into different
121  * file address space cache.
122  */
123  int (*steal)(struct pipe_inode_info *, struct pipe_buffer *);
124 
125  /*
126  * Get a reference to the pipe buffer.
127  */
128  void (*get)(struct pipe_inode_info *, struct pipe_buffer *);
129 };
130 
131 /* Differs from PIPE_BUF in that PIPE_SIZE is the length of the actual
132  memory allocation, whereas PIPE_BUF makes atomicity guarantees. */
133 #define PIPE_SIZE PAGE_SIZE
134 
135 /* Pipe lock and unlock operations */
136 void pipe_lock(struct pipe_inode_info *);
137 void pipe_unlock(struct pipe_inode_info *);
138 void pipe_double_lock(struct pipe_inode_info *, struct pipe_inode_info *);
139 
140 extern unsigned int pipe_max_size, pipe_min_size;
141 int pipe_proc_fn(struct ctl_table *, int, void __user *, size_t *, loff_t *);
142 
143 
144 /* Drop the inode semaphore and wait for a pipe event, atomically */
145 void pipe_wait(struct pipe_inode_info *pipe);
146 
147 struct pipe_inode_info * alloc_pipe_info(struct inode * inode);
148 void free_pipe_info(struct inode * inode);
149 void __free_pipe_info(struct pipe_inode_info *);
150 
151 /* Generic pipe buffer ops functions */
152 void *generic_pipe_buf_map(struct pipe_inode_info *, struct pipe_buffer *, int);
153 void generic_pipe_buf_unmap(struct pipe_inode_info *, struct pipe_buffer *, void *);
154 void generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
155 int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *);
156 int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *);
157 void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *);
158 
159 /* for F_SETPIPE_SZ and F_GETPIPE_SZ */
160 long pipe_fcntl(struct file *, unsigned int, unsigned long arg);
161 struct pipe_inode_info *get_pipe_info(struct file *file);
162 
163 int create_pipe_files(struct file **, int);
164 
165 #endif
Generated on Thu Jan 10 2013 14:52:18 for Linux Kernel by   doxygen 1.8.2