fuse_i.h 20 KB

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