~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/fuse/fuse_i.h

Version: ~ [ linux-5.15-rc6 ] ~ [ linux-5.14.14 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.75 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.155 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.213 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.252 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.287 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.289 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2   FUSE: Filesystem in Userspace
  3   Copyright (C) 2001-2008  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 #ifndef _FS_FUSE_I_H
 10 #define _FS_FUSE_I_H
 11 
 12 #include <linux/fuse.h>
 13 #include <linux/fs.h>
 14 #include <linux/mount.h>
 15 #include <linux/wait.h>
 16 #include <linux/list.h>
 17 #include <linux/spinlock.h>
 18 #include <linux/mm.h>
 19 #include <linux/backing-dev.h>
 20 #include <linux/mutex.h>
 21 #include <linux/rwsem.h>
 22 #include <linux/rbtree.h>
 23 #include <linux/poll.h>
 24 #include <linux/workqueue.h>
 25 
 26 /** Max number of pages that can be used in a single read request */
 27 #define FUSE_MAX_PAGES_PER_REQ 32
 28 
 29 /** Bias for fi->writectr, meaning new writepages must not be sent */
 30 #define FUSE_NOWRITE INT_MIN
 31 
 32 /** It could be as large as PATH_MAX, but would that have any uses? */
 33 #define FUSE_NAME_MAX 1024
 34 
 35 /** Number of dentries for each connection in the control filesystem */
 36 #define FUSE_CTL_NUM_DENTRIES 5
 37 
 38 /** If the FUSE_DEFAULT_PERMISSIONS flag is given, the filesystem
 39     module will check permissions based on the file mode.  Otherwise no
 40     permission checking is done in the kernel */
 41 #define FUSE_DEFAULT_PERMISSIONS (1 << 0)
 42 
 43 /** If the FUSE_ALLOW_OTHER flag is given, then not only the user
 44     doing the mount will be allowed to access the filesystem */
 45 #define FUSE_ALLOW_OTHER         (1 << 1)
 46 
 47 /** Number of page pointers embedded in fuse_req */
 48 #define FUSE_REQ_INLINE_PAGES 1
 49 
 50 /** List of active connections */
 51 extern struct list_head fuse_conn_list;
 52 
 53 /** Global mutex protecting fuse_conn_list and the control filesystem */
 54 extern struct mutex fuse_mutex;
 55 
 56 /** Module parameters */
 57 extern unsigned max_user_bgreq;
 58 extern unsigned max_user_congthresh;
 59 
 60 /* One forget request */
 61 struct fuse_forget_link {
 62         struct fuse_forget_one forget_one;
 63         struct fuse_forget_link *next;
 64 };
 65 
 66 /** FUSE inode */
 67 struct fuse_inode {
 68         /** Inode data */
 69         struct inode inode;
 70 
 71         /** Unique ID, which identifies the inode between userspace
 72          * and kernel */
 73         u64 nodeid;
 74 
 75         /** Number of lookups on this inode */
 76         u64 nlookup;
 77 
 78         /** The request used for sending the FORGET message */
 79         struct fuse_forget_link *forget;
 80 
 81         /** Time in jiffies until the file attributes are valid */
 82         u64 i_time;
 83 
 84         /** The sticky bit in inode->i_mode may have been removed, so
 85             preserve the original mode */
 86         umode_t orig_i_mode;
 87 
 88         /** 64 bit inode number */
 89         u64 orig_ino;
 90 
 91         /** Version of last attribute change */
 92         u64 attr_version;
 93 
 94         /** Files usable in writepage.  Protected by fc->lock */
 95         struct list_head write_files;
 96 
 97         /** Writepages pending on truncate or fsync */
 98         struct list_head queued_writes;
 99 
100         /** Number of sent writes, a negative bias (FUSE_NOWRITE)
101          * means more writes are blocked */
102         int writectr;
103 
104         /** Waitq for writepage completion */
105         wait_queue_head_t page_waitq;
106 
107         /** List of writepage requestst (pending or sent) */
108         struct list_head writepages;
109 
110         /** Miscellaneous bits describing inode state */
111         unsigned long state;
112 };
113 
114 /** FUSE inode state bits */
115 enum {
116         /** Advise readdirplus  */
117         FUSE_I_ADVISE_RDPLUS,
118         /** Initialized with readdirplus */
119         FUSE_I_INIT_RDPLUS,
120         /** An operation changing file size is in progress  */
121         FUSE_I_SIZE_UNSTABLE,
122 };
123 
124 struct fuse_conn;
125 
126 /** FUSE specific file data */
127 struct fuse_file {
128         /** Fuse connection for this file */
129         struct fuse_conn *fc;
130 
131         /** Request reserved for flush and release */
132         struct fuse_req *reserved_req;
133 
134         /** Kernel file handle guaranteed to be unique */
135         u64 kh;
136 
137         /** File handle used by userspace */
138         u64 fh;
139 
140         /** Node id of this file */
141         u64 nodeid;
142 
143         /** Refcount */
144         atomic_t count;
145 
146         /** FOPEN_* flags returned by open */
147         u32 open_flags;
148 
149         /** Entry on inode's write_files list */
150         struct list_head write_entry;
151 
152         /** RB node to be linked on fuse_conn->polled_files */
153         struct rb_node polled_node;
154 
155         /** Wait queue head for poll */
156         wait_queue_head_t poll_wait;
157 
158         /** Has flock been performed on this file? */
159         bool flock:1;
160 };
161 
162 /** One input argument of a request */
163 struct fuse_in_arg {
164         unsigned size;
165         const void *value;
166 };
167 
168 /** The request input */
169 struct fuse_in {
170         /** The request header */
171         struct fuse_in_header h;
172 
173         /** True if the data for the last argument is in req->pages */
174         unsigned argpages:1;
175 
176         /** Number of arguments */
177         unsigned numargs;
178 
179         /** Array of arguments */
180         struct fuse_in_arg args[3];
181 };
182 
183 /** One output argument of a request */
184 struct fuse_arg {
185         unsigned size;
186         void *value;
187 };
188 
189 /** The request output */
190 struct fuse_out {
191         /** Header returned from userspace */
192         struct fuse_out_header h;
193 
194         /*
195          * The following bitfields are not changed during the request
196          * processing
197          */
198 
199         /** Last argument is variable length (can be shorter than
200             arg->size) */
201         unsigned argvar:1;
202 
203         /** Last argument is a list of pages to copy data to */
204         unsigned argpages:1;
205 
206         /** Zero partially or not copied pages */
207         unsigned page_zeroing:1;
208 
209         /** Pages may be replaced with new ones */
210         unsigned page_replace:1;
211 
212         /** Number or arguments */
213         unsigned numargs;
214 
215         /** Array of arguments */
216         struct fuse_arg args[3];
217 };
218 
219 /** FUSE page descriptor */
220 struct fuse_page_desc {
221         unsigned int length;
222         unsigned int offset;
223 };
224 
225 /** The request state */
226 enum fuse_req_state {
227         FUSE_REQ_INIT = 0,
228         FUSE_REQ_PENDING,
229         FUSE_REQ_READING,
230         FUSE_REQ_SENT,
231         FUSE_REQ_WRITING,
232         FUSE_REQ_FINISHED
233 };
234 
235 /** The request IO state (for asynchronous processing) */
236 struct fuse_io_priv {
237         int async;
238         spinlock_t lock;
239         unsigned reqs;
240         ssize_t bytes;
241         size_t size;
242         __u64 offset;
243         bool write;
244         int err;
245         struct kiocb *iocb;
246         struct file *file;
247 };
248 
249 /**
250  * A request to the client
251  */
252 struct fuse_req {
253         /** This can be on either pending processing or io lists in
254             fuse_conn */
255         struct list_head list;
256 
257         /** Entry on the interrupts list  */
258         struct list_head intr_entry;
259 
260         /** refcount */
261         atomic_t count;
262 
263         /** Unique ID for the interrupt request */
264         u64 intr_unique;
265 
266         /*
267          * The following bitfields are either set once before the
268          * request is queued or setting/clearing them is protected by
269          * fuse_conn->lock
270          */
271 
272         /** True if the request has reply */
273         unsigned isreply:1;
274 
275         /** Force sending of the request even if interrupted */
276         unsigned force:1;
277 
278         /** The request was aborted */
279         unsigned aborted:1;
280 
281         /** Request is sent in the background */
282         unsigned background:1;
283 
284         /** The request has been interrupted */
285         unsigned interrupted:1;
286 
287         /** Data is being copied to/from the request */
288         unsigned locked:1;
289 
290         /** Request is counted as "waiting" */
291         unsigned waiting:1;
292 
293         /** State of the request */
294         enum fuse_req_state state;
295 
296         /** The request input */
297         struct fuse_in in;
298 
299         /** The request output */
300         struct fuse_out out;
301 
302         /** Used to wake up the task waiting for completion of request*/
303         wait_queue_head_t waitq;
304 
305         /** Data for asynchronous requests */
306         union {
307                 struct {
308                         union {
309                                 struct fuse_release_in in;
310                                 struct work_struct work;
311                         };
312                         struct path path;
313                 } release;
314                 struct fuse_init_in init_in;
315                 struct fuse_init_out init_out;
316                 struct cuse_init_in cuse_init_in;
317                 struct {
318                         struct fuse_read_in in;
319                         u64 attr_ver;
320                 } read;
321                 struct {
322                         struct fuse_write_in in;
323                         struct fuse_write_out out;
324                         struct fuse_req *next;
325                 } write;
326                 struct fuse_notify_retrieve_in retrieve_in;
327                 struct fuse_lk_in lk_in;
328         } misc;
329 
330         /** page vector */
331         struct page **pages;
332 
333         /** page-descriptor vector */
334         struct fuse_page_desc *page_descs;
335 
336         /** size of the 'pages' array */
337         unsigned max_pages;
338 
339         /** inline page vector */
340         struct page *inline_pages[FUSE_REQ_INLINE_PAGES];
341 
342         /** inline page-descriptor vector */
343         struct fuse_page_desc inline_page_descs[FUSE_REQ_INLINE_PAGES];
344 
345         /** number of pages in vector */
346         unsigned num_pages;
347 
348         /** File used in the request (or NULL) */
349         struct fuse_file *ff;
350 
351         /** Inode used in the request or NULL */
352         struct inode *inode;
353 
354         /** AIO control block */
355         struct fuse_io_priv *io;
356 
357         /** Link on fi->writepages */
358         struct list_head writepages_entry;
359 
360         /** Request completion callback */
361         void (*end)(struct fuse_conn *, struct fuse_req *);
362 
363         /** Request is stolen from fuse_file->reserved_req */
364         struct file *stolen_file;
365 };
366 
367 /**
368  * A Fuse connection.
369  *
370  * This structure is created, when the filesystem is mounted, and is
371  * destroyed, when the client device is closed and the filesystem is
372  * unmounted.
373  */
374 struct fuse_conn {
375         /** Lock protecting accessess to  members of this structure */
376         spinlock_t lock;
377 
378         /** Refcount */
379         atomic_t count;
380 
381         struct rcu_head rcu;
382 
383         /** The user id for this mount */
384         kuid_t user_id;
385 
386         /** The group id for this mount */
387         kgid_t group_id;
388 
389         /** The fuse mount flags for this mount */
390         unsigned flags;
391 
392         /** Maximum read size */
393         unsigned max_read;
394 
395         /** Maximum write size */
396         unsigned max_write;
397 
398         /** Readers of the connection are waiting on this */
399         wait_queue_head_t waitq;
400 
401         /** The list of pending requests */
402         struct list_head pending;
403 
404         /** The list of requests being processed */
405         struct list_head processing;
406 
407         /** The list of requests under I/O */
408         struct list_head io;
409 
410         /** The next unique kernel file handle */
411         u64 khctr;
412 
413         /** rbtree of fuse_files waiting for poll events indexed by ph */
414         struct rb_root polled_files;
415 
416         /** Maximum number of outstanding background requests */
417         unsigned max_background;
418 
419         /** Number of background requests at which congestion starts */
420         unsigned congestion_threshold;
421 
422         /** Number of requests currently in the background */
423         unsigned num_background;
424 
425         /** Number of background requests currently queued for userspace */
426         unsigned active_background;
427 
428         /** The list of background requests set aside for later queuing */
429         struct list_head bg_queue;
430 
431         /** Pending interrupts */
432         struct list_head interrupts;
433 
434         /** Queue of pending forgets */
435         struct fuse_forget_link forget_list_head;
436         struct fuse_forget_link *forget_list_tail;
437 
438         /** Batching of FORGET requests (positive indicates FORGET batch) */
439         int forget_batch;
440 
441         /** Flag indicating that INIT reply has been received. Allocating
442          * any fuse request will be suspended until the flag is set */
443         int initialized;
444 
445         /** Flag indicating if connection is blocked.  This will be
446             the case before the INIT reply is received, and if there
447             are too many outstading backgrounds requests */
448         int blocked;
449 
450         /** waitq for blocked connection */
451         wait_queue_head_t blocked_waitq;
452 
453         /** waitq for reserved requests */
454         wait_queue_head_t reserved_req_waitq;
455 
456         /** The next unique request id */
457         u64 reqctr;
458 
459         /** Connection established, cleared on umount, connection
460             abort and device release */
461         unsigned connected;
462 
463         /** Connection failed (version mismatch).  Cannot race with
464             setting other bitfields since it is only set once in INIT
465             reply, before any other request, and never cleared */
466         unsigned conn_error:1;
467 
468         /** Connection successful.  Only set in INIT */
469         unsigned conn_init:1;
470 
471         /** Do readpages asynchronously?  Only set in INIT */
472         unsigned async_read:1;
473 
474         /** Do not send separate SETATTR request before open(O_TRUNC)  */
475         unsigned atomic_o_trunc:1;
476 
477         /** Filesystem supports NFS exporting.  Only set in INIT */
478         unsigned export_support:1;
479 
480         /** Set if bdi is valid */
481         unsigned bdi_initialized:1;
482 
483         /** write-back cache policy (default is write-through) */
484         unsigned writeback_cache:1;
485 
486         /*
487          * The following bitfields are only for optimization purposes
488          * and hence races in setting them will not cause malfunction
489          */
490 
491         /** Is open/release not implemented by fs? */
492         unsigned no_open:1;
493 
494         /** Is fsync not implemented by fs? */
495         unsigned no_fsync:1;
496 
497         /** Is fsyncdir not implemented by fs? */
498         unsigned no_fsyncdir:1;
499 
500         /** Is flush not implemented by fs? */
501         unsigned no_flush:1;
502 
503         /** Is setxattr not implemented by fs? */
504         unsigned no_setxattr:1;
505 
506         /** Is getxattr not implemented by fs? */
507         unsigned no_getxattr:1;
508 
509         /** Is listxattr not implemented by fs? */
510         unsigned no_listxattr:1;
511 
512         /** Is removexattr not implemented by fs? */
513         unsigned no_removexattr:1;
514 
515         /** Are posix file locking primitives not implemented by fs? */
516         unsigned no_lock:1;
517 
518         /** Is access not implemented by fs? */
519         unsigned no_access:1;
520 
521         /** Is create not implemented by fs? */
522         unsigned no_create:1;
523 
524         /** Is interrupt not implemented by fs? */
525         unsigned no_interrupt:1;
526 
527         /** Is bmap not implemented by fs? */
528         unsigned no_bmap:1;
529 
530         /** Is poll not implemented by fs? */
531         unsigned no_poll:1;
532 
533         /** Do multi-page cached writes */
534         unsigned big_writes:1;
535 
536         /** Don't apply umask to creation modes */
537         unsigned dont_mask:1;
538 
539         /** Are BSD file locking primitives not implemented by fs? */
540         unsigned no_flock:1;
541 
542         /** Is fallocate not implemented by fs? */
543         unsigned no_fallocate:1;
544 
545         /** Is rename with flags implemented by fs? */
546         unsigned no_rename2:1;
547 
548         /** Use enhanced/automatic page cache invalidation. */
549         unsigned auto_inval_data:1;
550 
551         /** Does the filesystem support readdirplus? */
552         unsigned do_readdirplus:1;
553 
554         /** Does the filesystem want adaptive readdirplus? */
555         unsigned readdirplus_auto:1;
556 
557         /** Does the filesystem support asynchronous direct-IO submission? */
558         unsigned async_dio:1;
559 
560         /** The number of requests waiting for completion */
561         atomic_t num_waiting;
562 
563         /** Negotiated minor version */
564         unsigned minor;
565 
566         /** Backing dev info */
567         struct backing_dev_info bdi;
568 
569         /** Entry on the fuse_conn_list */
570         struct list_head entry;
571 
572         /** Device ID from super block */
573         dev_t dev;
574 
575         /** Dentries in the control filesystem */
576         struct dentry *ctl_dentry[FUSE_CTL_NUM_DENTRIES];
577 
578         /** number of dentries used in the above array */
579         int ctl_ndents;
580 
581         /** O_ASYNC requests */
582         struct fasync_struct *fasync;
583 
584         /** Key for lock owner ID scrambling */
585         u32 scramble_key[4];
586 
587         /** Reserved request for the DESTROY message */
588         struct fuse_req *destroy_req;
589 
590         /** Version counter for attribute changes */
591         u64 attr_version;
592 
593         /** Called on final put */
594         void (*release)(struct fuse_conn *);
595 
596         /** Super block for this connection. */
597         struct super_block *sb;
598 
599         /** Read/write semaphore to hold when accessing sb. */
600         struct rw_semaphore killsb;
601 };
602 
603 static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb)
604 {
605         return sb->s_fs_info;
606 }
607 
608 static inline struct fuse_conn *get_fuse_conn(struct inode *inode)
609 {
610         return get_fuse_conn_super(inode->i_sb);
611 }
612 
613 static inline struct fuse_inode *get_fuse_inode(struct inode *inode)
614 {
615         return container_of(inode, struct fuse_inode, inode);
616 }
617 
618 static inline u64 get_node_id(struct inode *inode)
619 {
620         return get_fuse_inode(inode)->nodeid;
621 }
622 
623 /** Device operations */
624 extern const struct file_operations fuse_dev_operations;
625 
626 extern const struct dentry_operations fuse_dentry_operations;
627 
628 /**
629  * Inode to nodeid comparison.
630  */
631 int fuse_inode_eq(struct inode *inode, void *_nodeidp);
632 
633 /**
634  * Get a filled in inode
635  */
636 struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
637                         int generation, struct fuse_attr *attr,
638                         u64 attr_valid, u64 attr_version);
639 
640 int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
641                      struct fuse_entry_out *outarg, struct inode **inode);
642 
643 /**
644  * Send FORGET command
645  */
646 void fuse_queue_forget(struct fuse_conn *fc, struct fuse_forget_link *forget,
647                        u64 nodeid, u64 nlookup);
648 
649 struct fuse_forget_link *fuse_alloc_forget(void);
650 
651 /* Used by READDIRPLUS */
652 void fuse_force_forget(struct file *file, u64 nodeid);
653 
654 /**
655  * Initialize READ or READDIR request
656  */
657 void fuse_read_fill(struct fuse_req *req, struct file *file,
658                     loff_t pos, size_t count, int opcode);
659 
660 /**
661  * Send OPEN or OPENDIR request
662  */
663 int fuse_open_common(struct inode *inode, struct file *file, bool isdir);
664 
665 struct fuse_file *fuse_file_alloc(struct fuse_conn *fc);
666 void fuse_file_free(struct fuse_file *ff);
667 void fuse_finish_open(struct inode *inode, struct file *file);
668 
669 void fuse_sync_release(struct fuse_file *ff, int flags);
670 
671 /**
672  * Send RELEASE or RELEASEDIR request
673  */
674 void fuse_release_common(struct file *file, bool isdir);
675 
676 /**
677  * Send FSYNC or FSYNCDIR request
678  */
679 int fuse_fsync_common(struct file *file, loff_t start, loff_t end,
680                       int datasync, int isdir);
681 
682 /**
683  * Notify poll wakeup
684  */
685 int fuse_notify_poll_wakeup(struct fuse_conn *fc,
686                             struct fuse_notify_poll_wakeup_out *outarg);
687 
688 /**
689  * Initialize file operations on a regular file
690  */
691 void fuse_init_file_inode(struct inode *inode);
692 
693 /**
694  * Initialize inode operations on regular files and special files
695  */
696 void fuse_init_common(struct inode *inode);
697 
698 /**
699  * Initialize inode and file operations on a directory
700  */
701 void fuse_init_dir(struct inode *inode);
702 
703 /**
704  * Initialize inode operations on a symlink
705  */
706 void fuse_init_symlink(struct inode *inode);
707 
708 /**
709  * Change attributes of an inode
710  */
711 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr,
712                             u64 attr_valid, u64 attr_version);
713 
714 void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr,
715                                    u64 attr_valid);
716 
717 /**
718  * Initialize the client device
719  */
720 int fuse_dev_init(void);
721 
722 /**
723  * Cleanup the client device
724  */
725 void fuse_dev_cleanup(void);
726 
727 int fuse_ctl_init(void);
728 void __exit fuse_ctl_cleanup(void);
729 
730 /**
731  * Allocate a request
732  */
733 struct fuse_req *fuse_request_alloc(unsigned npages);
734 
735 struct fuse_req *fuse_request_alloc_nofs(unsigned npages);
736 
737 /**
738  * Free a request
739  */
740 void fuse_request_free(struct fuse_req *req);
741 
742 /**
743  * Get a request, may fail with -ENOMEM,
744  * caller should specify # elements in req->pages[] explicitly
745  */
746 struct fuse_req *fuse_get_req(struct fuse_conn *fc, unsigned npages);
747 struct fuse_req *fuse_get_req_for_background(struct fuse_conn *fc,
748                                              unsigned npages);
749 
750 /*
751  * Increment reference count on request
752  */
753 void __fuse_get_request(struct fuse_req *req);
754 
755 /**
756  * Get a request, may fail with -ENOMEM,
757  * useful for callers who doesn't use req->pages[]
758  */
759 static inline struct fuse_req *fuse_get_req_nopages(struct fuse_conn *fc)
760 {
761         return fuse_get_req(fc, 0);
762 }
763 
764 /**
765  * Gets a requests for a file operation, always succeeds
766  */
767 struct fuse_req *fuse_get_req_nofail_nopages(struct fuse_conn *fc,
768                                              struct file *file);
769 
770 /**
771  * Decrement reference count of a request.  If count goes to zero free
772  * the request.
773  */
774 void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req);
775 
776 /**
777  * Send a request (synchronous)
778  */
779 void fuse_request_send(struct fuse_conn *fc, struct fuse_req *req);
780 
781 /**
782  * Send a request in the background
783  */
784 void fuse_request_send_background(struct fuse_conn *fc, struct fuse_req *req);
785 
786 void fuse_request_send_background_locked(struct fuse_conn *fc,
787                                          struct fuse_req *req);
788 
789 /* Abort all requests */
790 void fuse_abort_conn(struct fuse_conn *fc);
791 
792 /**
793  * Invalidate inode attributes
794  */
795 void fuse_invalidate_attr(struct inode *inode);
796 
797 void fuse_invalidate_entry_cache(struct dentry *entry);
798 
799 void fuse_invalidate_atime(struct inode *inode);
800 
801 /**
802  * Acquire reference to fuse_conn
803  */
804 struct fuse_conn *fuse_conn_get(struct fuse_conn *fc);
805 
806 /**
807  * Initialize fuse_conn
808  */
809 void fuse_conn_init(struct fuse_conn *fc);
810 
811 /**
812  * Release reference to fuse_conn
813  */
814 void fuse_conn_put(struct fuse_conn *fc);
815 
816 /**
817  * Add connection to control filesystem
818  */
819 int fuse_ctl_add_conn(struct fuse_conn *fc);
820 
821 /**
822  * Remove connection from control filesystem
823  */
824 void fuse_ctl_remove_conn(struct fuse_conn *fc);
825 
826 /**
827  * Is file type valid?
828  */
829 int fuse_valid_type(int m);
830 
831 bool fuse_invalid_attr(struct fuse_attr *attr);
832 
833 /**
834  * Is current process allowed to perform filesystem operation?
835  */
836 int fuse_allow_current_process(struct fuse_conn *fc);
837 
838 u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id);
839 
840 int fuse_update_attributes(struct inode *inode, struct kstat *stat,
841                            struct file *file, bool *refreshed);
842 
843 void fuse_flush_writepages(struct inode *inode);
844 
845 void fuse_set_nowrite(struct inode *inode);
846 void fuse_release_nowrite(struct inode *inode);
847 
848 u64 fuse_get_attr_version(struct fuse_conn *fc);
849 
850 /**
851  * File-system tells the kernel to invalidate cache for the given node id.
852  */
853 int fuse_reverse_inval_inode(struct super_block *sb, u64 nodeid,
854                              loff_t offset, loff_t len);
855 
856 /**
857  * File-system tells the kernel to invalidate parent attributes and
858  * the dentry matching parent/name.
859  *
860  * If the child_nodeid is non-zero and:
861  *    - matches the inode number for the dentry matching parent/name,
862  *    - is not a mount point
863  *    - is a file or oan empty directory
864  * then the dentry is unhashed (d_delete()).
865  */
866 int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
867                              u64 child_nodeid, struct qstr *name);
868 
869 int fuse_do_open(struct fuse_conn *fc, u64 nodeid, struct file *file,
870                  bool isdir);
871 
872 /**
873  * fuse_direct_io() flags
874  */
875 
876 /** If set, it is WRITE; otherwise - READ */
877 #define FUSE_DIO_WRITE (1 << 0)
878 
879 /** CUSE pass fuse_direct_io() a file which f_mapping->host is not from FUSE */
880 #define FUSE_DIO_CUSE  (1 << 1)
881 
882 ssize_t fuse_direct_io(struct fuse_io_priv *io, struct iov_iter *iter,
883                        loff_t *ppos, int flags);
884 long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
885                    unsigned int flags);
886 long fuse_ioctl_common(struct file *file, unsigned int cmd,
887                        unsigned long arg, unsigned int flags);
888 unsigned fuse_file_poll(struct file *file, poll_table *wait);
889 int fuse_dev_release(struct inode *inode, struct file *file);
890 
891 bool fuse_write_update_size(struct inode *inode, loff_t pos);
892 
893 int fuse_flush_times(struct inode *inode, struct fuse_file *ff);
894 int fuse_write_inode(struct inode *inode, struct writeback_control *wbc);
895 
896 int fuse_do_setattr(struct dentry *dentry, struct iattr *attr,
897                     struct file *file);
898 
899 #endif /* _FS_FUSE_I_H */
900 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp