xref: /openbmc/linux/fs/fuse/fuse_i.h (revision e868d61272caa648214046a096e5a6bfc068dc8c)
1 /*
2   FUSE: Filesystem in Userspace
3   Copyright (C) 2001-2006  Miklos Szeredi <miklos@szeredi.hu>
4 
5   This program can be distributed under the terms of the GNU GPL.
6   See the file COPYING.
7 */
8 
9 #include <linux/fuse.h>
10 #include <linux/fs.h>
11 #include <linux/mount.h>
12 #include <linux/wait.h>
13 #include <linux/list.h>
14 #include <linux/spinlock.h>
15 #include <linux/mm.h>
16 #include <linux/backing-dev.h>
17 #include <linux/mutex.h>
18 
19 /** Max number of pages that can be used in a single read request */
20 #define FUSE_MAX_PAGES_PER_REQ 32
21 
22 /** Maximum number of outstanding background requests */
23 #define FUSE_MAX_BACKGROUND 10
24 
25 /** It could be as large as PATH_MAX, but would that have any uses? */
26 #define FUSE_NAME_MAX 1024
27 
28 /** Number of dentries for each connection in the control filesystem */
29 #define FUSE_CTL_NUM_DENTRIES 3
30 
31 /** If the FUSE_DEFAULT_PERMISSIONS flag is given, the filesystem
32     module will check permissions based on the file mode.  Otherwise no
33     permission checking is done in the kernel */
34 #define FUSE_DEFAULT_PERMISSIONS (1 << 0)
35 
36 /** If the FUSE_ALLOW_OTHER flag is given, then not only the user
37     doing the mount will be allowed to access the filesystem */
38 #define FUSE_ALLOW_OTHER         (1 << 1)
39 
40 /** List of active connections */
41 extern struct list_head fuse_conn_list;
42 
43 /** Global mutex protecting fuse_conn_list and the control filesystem */
44 extern struct mutex fuse_mutex;
45 
46 /** FUSE inode */
47 struct fuse_inode {
48 	/** Inode data */
49 	struct inode inode;
50 
51 	/** Unique ID, which identifies the inode between userspace
52 	 * and kernel */
53 	u64 nodeid;
54 
55 	/** Number of lookups on this inode */
56 	u64 nlookup;
57 
58 	/** The request used for sending the FORGET message */
59 	struct fuse_req *forget_req;
60 
61 	/** Time in jiffies until the file attributes are valid */
62 	u64 i_time;
63 };
64 
65 /** FUSE specific file data */
66 struct fuse_file {
67 	/** Request reserved for flush and release */
68 	struct fuse_req *reserved_req;
69 
70 	/** File handle used by userspace */
71 	u64 fh;
72 };
73 
74 /** One input argument of a request */
75 struct fuse_in_arg {
76 	unsigned size;
77 	const void *value;
78 };
79 
80 /** The request input */
81 struct fuse_in {
82 	/** The request header */
83 	struct fuse_in_header h;
84 
85 	/** True if the data for the last argument is in req->pages */
86 	unsigned argpages:1;
87 
88 	/** Number of arguments */
89 	unsigned numargs;
90 
91 	/** Array of arguments */
92 	struct fuse_in_arg args[3];
93 };
94 
95 /** One output argument of a request */
96 struct fuse_arg {
97 	unsigned size;
98 	void *value;
99 };
100 
101 /** The request output */
102 struct fuse_out {
103 	/** Header returned from userspace */
104 	struct fuse_out_header h;
105 
106 	/*
107 	 * The following bitfields are not changed during the request
108 	 * processing
109 	 */
110 
111 	/** Last argument is variable length (can be shorter than
112 	    arg->size) */
113 	unsigned argvar:1;
114 
115 	/** Last argument is a list of pages to copy data to */
116 	unsigned argpages:1;
117 
118 	/** Zero partially or not copied pages */
119 	unsigned page_zeroing:1;
120 
121 	/** Number or arguments */
122 	unsigned numargs;
123 
124 	/** Array of arguments */
125 	struct fuse_arg args[3];
126 };
127 
128 /** The request state */
129 enum fuse_req_state {
130 	FUSE_REQ_INIT = 0,
131 	FUSE_REQ_PENDING,
132 	FUSE_REQ_READING,
133 	FUSE_REQ_SENT,
134 	FUSE_REQ_WRITING,
135 	FUSE_REQ_FINISHED
136 };
137 
138 struct fuse_conn;
139 
140 /**
141  * A request to the client
142  */
143 struct fuse_req {
144 	/** This can be on either pending processing or io lists in
145 	    fuse_conn */
146 	struct list_head list;
147 
148 	/** Entry on the interrupts list  */
149 	struct list_head intr_entry;
150 
151 	/** refcount */
152 	atomic_t count;
153 
154 	/** Unique ID for the interrupt request */
155 	u64 intr_unique;
156 
157 	/*
158 	 * The following bitfields are either set once before the
159 	 * request is queued or setting/clearing them is protected by
160 	 * fuse_conn->lock
161 	 */
162 
163 	/** True if the request has reply */
164 	unsigned isreply:1;
165 
166 	/** Force sending of the request even if interrupted */
167 	unsigned force:1;
168 
169 	/** The request was aborted */
170 	unsigned aborted:1;
171 
172 	/** Request is sent in the background */
173 	unsigned background:1;
174 
175 	/** The request has been interrupted */
176 	unsigned interrupted:1;
177 
178 	/** Data is being copied to/from the request */
179 	unsigned locked:1;
180 
181 	/** Request is counted as "waiting" */
182 	unsigned waiting:1;
183 
184 	/** State of the request */
185 	enum fuse_req_state state;
186 
187 	/** The request input */
188 	struct fuse_in in;
189 
190 	/** The request output */
191 	struct fuse_out out;
192 
193 	/** Used to wake up the task waiting for completion of request*/
194 	wait_queue_head_t waitq;
195 
196 	/** Data for asynchronous requests */
197 	union {
198 		struct fuse_forget_in forget_in;
199 		struct fuse_release_in release_in;
200 		struct fuse_init_in init_in;
201 		struct fuse_init_out init_out;
202 		struct fuse_read_in read_in;
203 		struct fuse_lk_in lk_in;
204 	} misc;
205 
206 	/** page vector */
207 	struct page *pages[FUSE_MAX_PAGES_PER_REQ];
208 
209 	/** number of pages in vector */
210 	unsigned num_pages;
211 
212 	/** offset of data on first page */
213 	unsigned page_offset;
214 
215 	/** File used in the request (or NULL) */
216 	struct file *file;
217 
218 	/** vfsmount used in release */
219 	struct vfsmount *vfsmount;
220 
221 	/** dentry used in release */
222 	struct dentry *dentry;
223 
224 	/** Request completion callback */
225 	void (*end)(struct fuse_conn *, struct fuse_req *);
226 
227 	/** Request is stolen from fuse_file->reserved_req */
228 	struct file *stolen_file;
229 };
230 
231 /**
232  * A Fuse connection.
233  *
234  * This structure is created, when the filesystem is mounted, and is
235  * destroyed, when the client device is closed and the filesystem is
236  * unmounted.
237  */
238 struct fuse_conn {
239 	/** Lock protecting accessess to  members of this structure */
240 	spinlock_t lock;
241 
242 	/** Mutex protecting against directory alias creation */
243 	struct mutex inst_mutex;
244 
245 	/** Refcount */
246 	atomic_t count;
247 
248 	/** The user id for this mount */
249 	uid_t user_id;
250 
251 	/** The group id for this mount */
252 	gid_t group_id;
253 
254 	/** The fuse mount flags for this mount */
255 	unsigned flags;
256 
257 	/** Maximum read size */
258 	unsigned max_read;
259 
260 	/** Maximum write size */
261 	unsigned max_write;
262 
263 	/** Readers of the connection are waiting on this */
264 	wait_queue_head_t waitq;
265 
266 	/** The list of pending requests */
267 	struct list_head pending;
268 
269 	/** The list of requests being processed */
270 	struct list_head processing;
271 
272 	/** The list of requests under I/O */
273 	struct list_head io;
274 
275 	/** Number of requests currently in the background */
276 	unsigned num_background;
277 
278 	/** Pending interrupts */
279 	struct list_head interrupts;
280 
281 	/** Flag indicating if connection is blocked.  This will be
282 	    the case before the INIT reply is received, and if there
283 	    are too many outstading backgrounds requests */
284 	int blocked;
285 
286 	/** waitq for blocked connection */
287 	wait_queue_head_t blocked_waitq;
288 
289 	/** The next unique request id */
290 	u64 reqctr;
291 
292 	/** Connection established, cleared on umount, connection
293 	    abort and device release */
294 	unsigned connected;
295 
296 	/** Connection failed (version mismatch).  Cannot race with
297 	    setting other bitfields since it is only set once in INIT
298 	    reply, before any other request, and never cleared */
299 	unsigned conn_error : 1;
300 
301 	/** Connection successful.  Only set in INIT */
302 	unsigned conn_init : 1;
303 
304 	/** Do readpages asynchronously?  Only set in INIT */
305 	unsigned async_read : 1;
306 
307 	/*
308 	 * The following bitfields are only for optimization purposes
309 	 * and hence races in setting them will not cause malfunction
310 	 */
311 
312 	/** Is fsync not implemented by fs? */
313 	unsigned no_fsync : 1;
314 
315 	/** Is fsyncdir not implemented by fs? */
316 	unsigned no_fsyncdir : 1;
317 
318 	/** Is flush not implemented by fs? */
319 	unsigned no_flush : 1;
320 
321 	/** Is setxattr not implemented by fs? */
322 	unsigned no_setxattr : 1;
323 
324 	/** Is getxattr not implemented by fs? */
325 	unsigned no_getxattr : 1;
326 
327 	/** Is listxattr not implemented by fs? */
328 	unsigned no_listxattr : 1;
329 
330 	/** Is removexattr not implemented by fs? */
331 	unsigned no_removexattr : 1;
332 
333 	/** Are file locking primitives not implemented by fs? */
334 	unsigned no_lock : 1;
335 
336 	/** Is access not implemented by fs? */
337 	unsigned no_access : 1;
338 
339 	/** Is create not implemented by fs? */
340 	unsigned no_create : 1;
341 
342 	/** Is interrupt not implemented by fs? */
343 	unsigned no_interrupt : 1;
344 
345 	/** Is bmap not implemented by fs? */
346 	unsigned no_bmap : 1;
347 
348 	/** The number of requests waiting for completion */
349 	atomic_t num_waiting;
350 
351 	/** Negotiated minor version */
352 	unsigned minor;
353 
354 	/** Backing dev info */
355 	struct backing_dev_info bdi;
356 
357 	/** Entry on the fuse_conn_list */
358 	struct list_head entry;
359 
360 	/** Unique ID */
361 	u64 id;
362 
363 	/** Dentries in the control filesystem */
364 	struct dentry *ctl_dentry[FUSE_CTL_NUM_DENTRIES];
365 
366 	/** number of dentries used in the above array */
367 	int ctl_ndents;
368 
369 	/** O_ASYNC requests */
370 	struct fasync_struct *fasync;
371 
372 	/** Key for lock owner ID scrambling */
373 	u32 scramble_key[4];
374 
375 	/** Reserved request for the DESTROY message */
376 	struct fuse_req *destroy_req;
377 };
378 
379 static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb)
380 {
381 	return sb->s_fs_info;
382 }
383 
384 static inline struct fuse_conn *get_fuse_conn(struct inode *inode)
385 {
386 	return get_fuse_conn_super(inode->i_sb);
387 }
388 
389 static inline struct fuse_inode *get_fuse_inode(struct inode *inode)
390 {
391 	return container_of(inode, struct fuse_inode, inode);
392 }
393 
394 static inline u64 get_node_id(struct inode *inode)
395 {
396 	return get_fuse_inode(inode)->nodeid;
397 }
398 
399 /** Device operations */
400 extern const struct file_operations fuse_dev_operations;
401 
402 /**
403  * Get a filled in inode
404  */
405 struct inode *fuse_iget(struct super_block *sb, unsigned long nodeid,
406 			int generation, struct fuse_attr *attr);
407 
408 /**
409  * Send FORGET command
410  */
411 void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req,
412 		      unsigned long nodeid, u64 nlookup);
413 
414 /**
415  * Initialize READ or READDIR request
416  */
417 void fuse_read_fill(struct fuse_req *req, struct file *file,
418 		    struct inode *inode, loff_t pos, size_t count, int opcode);
419 
420 /**
421  * Send OPEN or OPENDIR request
422  */
423 int fuse_open_common(struct inode *inode, struct file *file, int isdir);
424 
425 struct fuse_file *fuse_file_alloc(void);
426 void fuse_file_free(struct fuse_file *ff);
427 void fuse_finish_open(struct inode *inode, struct file *file,
428 		      struct fuse_file *ff, struct fuse_open_out *outarg);
429 
430 /** */
431 struct fuse_req *fuse_release_fill(struct fuse_file *ff, u64 nodeid, int flags,
432 				   int opcode);
433 /**
434  * Send RELEASE or RELEASEDIR request
435  */
436 int fuse_release_common(struct inode *inode, struct file *file, int isdir);
437 
438 /**
439  * Send FSYNC or FSYNCDIR request
440  */
441 int fuse_fsync_common(struct file *file, struct dentry *de, int datasync,
442 		      int isdir);
443 
444 /**
445  * Initialize file operations on a regular file
446  */
447 void fuse_init_file_inode(struct inode *inode);
448 
449 /**
450  * Initialize inode operations on regular files and special files
451  */
452 void fuse_init_common(struct inode *inode);
453 
454 /**
455  * Initialize inode and file operations on a directory
456  */
457 void fuse_init_dir(struct inode *inode);
458 
459 /**
460  * Initialize inode operations on a symlink
461  */
462 void fuse_init_symlink(struct inode *inode);
463 
464 /**
465  * Change attributes of an inode
466  */
467 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr);
468 
469 /**
470  * Initialize the client device
471  */
472 int fuse_dev_init(void);
473 
474 /**
475  * Cleanup the client device
476  */
477 void fuse_dev_cleanup(void);
478 
479 int fuse_ctl_init(void);
480 void fuse_ctl_cleanup(void);
481 
482 /**
483  * Allocate a request
484  */
485 struct fuse_req *fuse_request_alloc(void);
486 
487 /**
488  * Free a request
489  */
490 void fuse_request_free(struct fuse_req *req);
491 
492 /**
493  * Get a request, may fail with -ENOMEM
494  */
495 struct fuse_req *fuse_get_req(struct fuse_conn *fc);
496 
497 /**
498  * Gets a requests for a file operation, always succeeds
499  */
500 struct fuse_req *fuse_get_req_nofail(struct fuse_conn *fc, struct file *file);
501 
502 /**
503  * Decrement reference count of a request.  If count goes to zero free
504  * the request.
505  */
506 void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req);
507 
508 /**
509  * Send a request (synchronous)
510  */
511 void request_send(struct fuse_conn *fc, struct fuse_req *req);
512 
513 /**
514  * Send a request with no reply
515  */
516 void request_send_noreply(struct fuse_conn *fc, struct fuse_req *req);
517 
518 /**
519  * Send a request in the background
520  */
521 void request_send_background(struct fuse_conn *fc, struct fuse_req *req);
522 
523 /* Abort all requests */
524 void fuse_abort_conn(struct fuse_conn *fc);
525 
526 /**
527  * Get the attributes of a file
528  */
529 int fuse_do_getattr(struct inode *inode);
530 
531 /**
532  * Invalidate inode attributes
533  */
534 void fuse_invalidate_attr(struct inode *inode);
535 
536 /**
537  * Acquire reference to fuse_conn
538  */
539 struct fuse_conn *fuse_conn_get(struct fuse_conn *fc);
540 
541 /**
542  * Release reference to fuse_conn
543  */
544 void fuse_conn_put(struct fuse_conn *fc);
545 
546 /**
547  * Add connection to control filesystem
548  */
549 int fuse_ctl_add_conn(struct fuse_conn *fc);
550 
551 /**
552  * Remove connection from control filesystem
553  */
554 void fuse_ctl_remove_conn(struct fuse_conn *fc);
555 
556 /**
557  * Is file type valid?
558  */
559 int fuse_valid_type(int m);
560