Blame view
include/linux/pipe_fs_i.h
5.74 KB
1da177e4c
|
1 2 3 4 |
#ifndef _LINUX_PIPE_FS_I_H #define _LINUX_PIPE_FS_I_H #define PIPEFS_MAGIC 0x50495045 |
35f3d14db
|
5 |
#define PIPE_DEF_BUFFERS 16 |
1da177e4c
|
6 |
|
1432873af
|
7 8 9 |
#define PIPE_BUF_FLAG_LRU 0x01 /* page is on the LRU */ #define PIPE_BUF_FLAG_ATOMIC 0x02 /* was atomically mapped */ #define PIPE_BUF_FLAG_GIFT 0x04 /* page is a gift */ |
3e7ee3e7b
|
10 |
|
0845718da
|
11 12 13 14 15 16 17 18 19 |
/** * struct pipe_buffer - a linux kernel pipe buffer * @page: the page containing the data for the pipe buffer * @offset: offset of data inside the @page * @len: length of data inside the @page * @ops: operations associated with this buffer. See @pipe_buf_operations. * @flags: pipe buffer flags. See above. * @private: private data owned by the ops. **/ |
1da177e4c
|
20 21 22 |
struct pipe_buffer { struct page *page; unsigned int offset, len; |
d4c3cca94
|
23 |
const struct pipe_buf_operations *ops; |
3e7ee3e7b
|
24 |
unsigned int flags; |
497f9625c
|
25 |
unsigned long private; |
1da177e4c
|
26 |
}; |
0845718da
|
27 28 29 30 |
/** * struct pipe_inode_info - a linux kernel pipe * @wait: reader/writer wait point in case of empty/full pipe * @nrbufs: the number of non-empty pipe buffers in this pipe |
0dc148852
|
31 |
* @buffers: total number of buffers (should be a power of 2) |
0845718da
|
32 33 34 35 36 37 38 39 40 41 42 43 |
* @curbuf: the current pipe buffer entry * @tmp_page: cached released page * @readers: number of current readers of this pipe * @writers: number of current writers of this pipe * @waiting_writers: number of writers blocked waiting for room * @r_counter: reader counter * @w_counter: writer counter * @fasync_readers: reader side fasync * @fasync_writers: writer side fasync * @inode: inode this pipe is attached to * @bufs: the circular array of pipe buffers **/ |
17374ff1a
|
44 45 |
struct pipe_inode_info { wait_queue_head_t wait; |
35f3d14db
|
46 |
unsigned int nrbufs, curbuf, buffers; |
17374ff1a
|
47 48 49 50 51 |
unsigned int readers; unsigned int writers; unsigned int waiting_writers; unsigned int r_counter; unsigned int w_counter; |
35f3d14db
|
52 |
struct page *tmp_page; |
17374ff1a
|
53 54 55 |
struct fasync_struct *fasync_readers; struct fasync_struct *fasync_writers; struct inode *inode; |
35f3d14db
|
56 |
struct pipe_buffer *bufs; |
17374ff1a
|
57 |
}; |
f84d75199
|
58 59 60 |
/* * Note on the nesting of these functions: * |
cac36bb06
|
61 |
* ->confirm() |
f84d75199
|
62 63 64 65 66 67 |
* ->steal() * ... * ->map() * ... * ->unmap() * |
cac36bb06
|
68 |
* That is, ->map() must be called on a confirmed buffer, |
0845718da
|
69 70 71 |
* same goes for ->steal(). See below for the meaning of each * operation. Also see kerneldoc in fs/pipe.c for the pipe * and generic variants of these hooks. |
f84d75199
|
72 |
*/ |
1da177e4c
|
73 |
struct pipe_buf_operations { |
0845718da
|
74 75 76 77 78 |
/* * This is set to 1, if the generic pipe read/write may coalesce * data into an existing buffer. If this is set to 0, a new pipe * page segment is always used for new data. */ |
1da177e4c
|
79 |
int can_merge; |
0845718da
|
80 81 82 83 84 85 86 87 88 89 90 91 92 |
/* * ->map() returns a virtual address mapping of the pipe buffer. * The last integer flag reflects whether this should be an atomic * mapping or not. The atomic map is faster, however you can't take * page faults before calling ->unmap() again. So if you need to eg * access user data through copy_to/from_user(), then you must get * a non-atomic map. ->map() uses the KM_USER0 atomic slot for * atomic maps, so you can't map more than one pipe_buffer at once * and you have to be careful if mapping another page as source * or destination for a copy (IOW, it has to use something else * than KM_USER0). */ |
f6762b7ad
|
93 |
void * (*map)(struct pipe_inode_info *, struct pipe_buffer *, int); |
0845718da
|
94 95 96 97 |
/* * Undoes ->map(), finishes the virtual mapping of the pipe buffer. */ |
f6762b7ad
|
98 |
void (*unmap)(struct pipe_inode_info *, struct pipe_buffer *, void *); |
0845718da
|
99 100 101 102 103 104 105 106 |
/* * ->confirm() verifies that the data in the pipe buffer is there * and that the contents are good. If the pages in the pipe belong * to a file system, we may need to wait for IO completion in this * hook. Returns 0 for good, or a negative error value in case of * error. */ |
cac36bb06
|
107 |
int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *); |
0845718da
|
108 109 110 111 112 |
/* * When the contents of this pipe buffer has been completely * consumed by a reader, ->release() is called. */ |
1da177e4c
|
113 |
void (*release)(struct pipe_inode_info *, struct pipe_buffer *); |
0845718da
|
114 115 116 117 118 119 120 121 122 |
/* * Attempt to take ownership of the pipe buffer and its contents. * ->steal() returns 0 for success, in which case the contents * of the pipe (the buf->page) is locked and now completely owned * by the caller. The page may then be transferred to a different * mapping, the most often used case is insertion into different * file address space cache. */ |
5abc97aa2
|
123 |
int (*steal)(struct pipe_inode_info *, struct pipe_buffer *); |
0845718da
|
124 125 126 127 |
/* * Get a reference to the pipe buffer. */ |
70524490e
|
128 |
void (*get)(struct pipe_inode_info *, struct pipe_buffer *); |
1da177e4c
|
129 |
}; |
1da177e4c
|
130 131 132 |
/* Differs from PIPE_BUF in that PIPE_SIZE is the length of the actual memory allocation, whereas PIPE_BUF makes atomicity guarantees. */ #define PIPE_SIZE PAGE_SIZE |
61e0d47c3
|
133 134 135 136 |
/* Pipe lock and unlock operations */ void pipe_lock(struct pipe_inode_info *); void pipe_unlock(struct pipe_inode_info *); void pipe_double_lock(struct pipe_inode_info *, struct pipe_inode_info *); |
ff9da691c
|
137 138 |
extern unsigned int pipe_max_size, pipe_min_size; int pipe_proc_fn(struct ctl_table *, int, void __user *, size_t *, loff_t *); |
b492e95be
|
139 |
|
1da177e4c
|
140 |
/* Drop the inode semaphore and wait for a pipe event, atomically */ |
3a326a2ce
|
141 |
void pipe_wait(struct pipe_inode_info *pipe); |
1da177e4c
|
142 |
|
3a326a2ce
|
143 144 |
struct pipe_inode_info * alloc_pipe_info(struct inode * inode); void free_pipe_info(struct inode * inode); |
b92ce5589
|
145 |
void __free_pipe_info(struct pipe_inode_info *); |
1da177e4c
|
146 |
|
f84d75199
|
147 |
/* Generic pipe buffer ops functions */ |
f6762b7ad
|
148 149 |
void *generic_pipe_buf_map(struct pipe_inode_info *, struct pipe_buffer *, int); void generic_pipe_buf_unmap(struct pipe_inode_info *, struct pipe_buffer *, void *); |
f84d75199
|
150 |
void generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *); |
cac36bb06
|
151 |
int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *); |
330ab7161
|
152 |
int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *); |
6818173bd
|
153 |
void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *); |
f84d75199
|
154 |
|
35f3d14db
|
155 156 |
/* for F_SETPIPE_SZ and F_GETPIPE_SZ */ long pipe_fcntl(struct file *, unsigned int, unsigned long arg); |
720836465
|
157 |
struct pipe_inode_info *get_pipe_info(struct file *file); |
c66fb3479
|
158 |
|
1da177e4c
|
159 |
#endif |