vfs.rst 56 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443
  1. .. SPDX-License-Identifier: GPL-2.0
  2. =========================================
  3. Overview of the Linux Virtual File System
  4. =========================================
  5. Original author: Richard Gooch <rgooch@atnf.csiro.au>
  6. - Copyright (C) 1999 Richard Gooch
  7. - Copyright (C) 2005 Pekka Enberg
  8. Introduction
  9. ============
  10. The Virtual File System (also known as the Virtual Filesystem Switch) is
  11. the software layer in the kernel that provides the filesystem interface
  12. to userspace programs. It also provides an abstraction within the
  13. kernel which allows different filesystem implementations to coexist.
  14. VFS system calls open(2), stat(2), read(2), write(2), chmod(2) and so on
  15. are called from a process context. Filesystem locking is described in
  16. the document Documentation/filesystems/locking.rst.
  17. Directory Entry Cache (dcache)
  18. ------------------------------
  19. The VFS implements the open(2), stat(2), chmod(2), and similar system
  20. calls. The pathname argument that is passed to them is used by the VFS
  21. to search through the directory entry cache (also known as the dentry
  22. cache or dcache). This provides a very fast look-up mechanism to
  23. translate a pathname (filename) into a specific dentry. Dentries live
  24. in RAM and are never saved to disc: they exist only for performance.
  25. The dentry cache is meant to be a view into your entire filespace. As
  26. most computers cannot fit all dentries in the RAM at the same time, some
  27. bits of the cache are missing. In order to resolve your pathname into a
  28. dentry, the VFS may have to resort to creating dentries along the way,
  29. and then loading the inode. This is done by looking up the inode.
  30. The Inode Object
  31. ----------------
  32. An individual dentry usually has a pointer to an inode. Inodes are
  33. filesystem objects such as regular files, directories, FIFOs and other
  34. beasts. They live either on the disc (for block device filesystems) or
  35. in the memory (for pseudo filesystems). Inodes that live on the disc
  36. are copied into the memory when required and changes to the inode are
  37. written back to disc. A single inode can be pointed to by multiple
  38. dentries (hard links, for example, do this).
  39. To look up an inode requires that the VFS calls the lookup() method of
  40. the parent directory inode. This method is installed by the specific
  41. filesystem implementation that the inode lives in. Once the VFS has the
  42. required dentry (and hence the inode), we can do all those boring things
  43. like open(2) the file, or stat(2) it to peek at the inode data. The
  44. stat(2) operation is fairly simple: once the VFS has the dentry, it
  45. peeks at the inode data and passes some of it back to userspace.
  46. The File Object
  47. ---------------
  48. Opening a file requires another operation: allocation of a file
  49. structure (this is the kernel-side implementation of file descriptors).
  50. The freshly allocated file structure is initialized with a pointer to
  51. the dentry and a set of file operation member functions. These are
  52. taken from the inode data. The open() file method is then called so the
  53. specific filesystem implementation can do its work. You can see that
  54. this is another switch performed by the VFS. The file structure is
  55. placed into the file descriptor table for the process.
  56. Reading, writing and closing files (and other assorted VFS operations)
  57. is done by using the userspace file descriptor to grab the appropriate
  58. file structure, and then calling the required file structure method to
  59. do whatever is required. For as long as the file is open, it keeps the
  60. dentry in use, which in turn means that the VFS inode is still in use.
  61. Registering and Mounting a Filesystem
  62. =====================================
  63. To register and unregister a filesystem, use the following API
  64. functions:
  65. .. code-block:: c
  66. #include <linux/fs.h>
  67. extern int register_filesystem(struct file_system_type *);
  68. extern int unregister_filesystem(struct file_system_type *);
  69. The passed struct file_system_type describes your filesystem. When a
  70. request is made to mount a filesystem onto a directory in your
  71. namespace, the VFS will call the appropriate mount() method for the
  72. specific filesystem. New vfsmount referring to the tree returned by
  73. ->mount() will be attached to the mountpoint, so that when pathname
  74. resolution reaches the mountpoint it will jump into the root of that
  75. vfsmount.
  76. You can see all filesystems that are registered to the kernel in the
  77. file /proc/filesystems.
  78. struct file_system_type
  79. -----------------------
  80. This describes the filesystem. As of kernel 2.6.39, the following
  81. members are defined:
  82. .. code-block:: c
  83. struct file_system_operations {
  84. const char *name;
  85. int fs_flags;
  86. struct dentry *(*mount) (struct file_system_type *, int,
  87. const char *, void *);
  88. void (*kill_sb) (struct super_block *);
  89. struct module *owner;
  90. struct file_system_type * next;
  91. struct list_head fs_supers;
  92. struct lock_class_key s_lock_key;
  93. struct lock_class_key s_umount_key;
  94. };
  95. ``name``
  96. the name of the filesystem type, such as "ext2", "iso9660",
  97. "msdos" and so on
  98. ``fs_flags``
  99. various flags (i.e. FS_REQUIRES_DEV, FS_NO_DCACHE, etc.)
  100. ``mount``
  101. the method to call when a new instance of this filesystem should
  102. be mounted
  103. ``kill_sb``
  104. the method to call when an instance of this filesystem should be
  105. shut down
  106. ``owner``
  107. for internal VFS use: you should initialize this to THIS_MODULE
  108. in most cases.
  109. ``next``
  110. for internal VFS use: you should initialize this to NULL
  111. s_lock_key, s_umount_key: lockdep-specific
  112. The mount() method has the following arguments:
  113. ``struct file_system_type *fs_type``
  114. describes the filesystem, partly initialized by the specific
  115. filesystem code
  116. ``int flags``
  117. mount flags
  118. ``const char *dev_name``
  119. the device name we are mounting.
  120. ``void *data``
  121. arbitrary mount options, usually comes as an ASCII string (see
  122. "Mount Options" section)
  123. The mount() method must return the root dentry of the tree requested by
  124. caller. An active reference to its superblock must be grabbed and the
  125. superblock must be locked. On failure it should return ERR_PTR(error).
  126. The arguments match those of mount(2) and their interpretation depends
  127. on filesystem type. E.g. for block filesystems, dev_name is interpreted
  128. as block device name, that device is opened and if it contains a
  129. suitable filesystem image the method creates and initializes struct
  130. super_block accordingly, returning its root dentry to caller.
  131. ->mount() may choose to return a subtree of existing filesystem - it
  132. doesn't have to create a new one. The main result from the caller's
  133. point of view is a reference to dentry at the root of (sub)tree to be
  134. attached; creation of new superblock is a common side effect.
  135. The most interesting member of the superblock structure that the mount()
  136. method fills in is the "s_op" field. This is a pointer to a "struct
  137. super_operations" which describes the next level of the filesystem
  138. implementation.
  139. Usually, a filesystem uses one of the generic mount() implementations
  140. and provides a fill_super() callback instead. The generic variants are:
  141. ``mount_bdev``
  142. mount a filesystem residing on a block device
  143. ``mount_nodev``
  144. mount a filesystem that is not backed by a device
  145. ``mount_single``
  146. mount a filesystem which shares the instance between all mounts
  147. A fill_super() callback implementation has the following arguments:
  148. ``struct super_block *sb``
  149. the superblock structure. The callback must initialize this
  150. properly.
  151. ``void *data``
  152. arbitrary mount options, usually comes as an ASCII string (see
  153. "Mount Options" section)
  154. ``int silent``
  155. whether or not to be silent on error
  156. The Superblock Object
  157. =====================
  158. A superblock object represents a mounted filesystem.
  159. struct super_operations
  160. -----------------------
  161. This describes how the VFS can manipulate the superblock of your
  162. filesystem. As of kernel 2.6.22, the following members are defined:
  163. .. code-block:: c
  164. struct super_operations {
  165. struct inode *(*alloc_inode)(struct super_block *sb);
  166. void (*destroy_inode)(struct inode *);
  167. void (*dirty_inode) (struct inode *, int flags);
  168. int (*write_inode) (struct inode *, int);
  169. void (*drop_inode) (struct inode *);
  170. void (*delete_inode) (struct inode *);
  171. void (*put_super) (struct super_block *);
  172. int (*sync_fs)(struct super_block *sb, int wait);
  173. int (*freeze_fs) (struct super_block *);
  174. int (*unfreeze_fs) (struct super_block *);
  175. int (*statfs) (struct dentry *, struct kstatfs *);
  176. int (*remount_fs) (struct super_block *, int *, char *);
  177. void (*clear_inode) (struct inode *);
  178. void (*umount_begin) (struct super_block *);
  179. int (*show_options)(struct seq_file *, struct dentry *);
  180. ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
  181. ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
  182. int (*nr_cached_objects)(struct super_block *);
  183. void (*free_cached_objects)(struct super_block *, int);
  184. };
  185. All methods are called without any locks being held, unless otherwise
  186. noted. This means that most methods can block safely. All methods are
  187. only called from a process context (i.e. not from an interrupt handler
  188. or bottom half).
  189. ``alloc_inode``
  190. this method is called by alloc_inode() to allocate memory for
  191. struct inode and initialize it. If this function is not
  192. defined, a simple 'struct inode' is allocated. Normally
  193. alloc_inode will be used to allocate a larger structure which
  194. contains a 'struct inode' embedded within it.
  195. ``destroy_inode``
  196. this method is called by destroy_inode() to release resources
  197. allocated for struct inode. It is only required if
  198. ->alloc_inode was defined and simply undoes anything done by
  199. ->alloc_inode.
  200. ``dirty_inode``
  201. this method is called by the VFS to mark an inode dirty.
  202. ``write_inode``
  203. this method is called when the VFS needs to write an inode to
  204. disc. The second parameter indicates whether the write should
  205. be synchronous or not, not all filesystems check this flag.
  206. ``drop_inode``
  207. called when the last access to the inode is dropped, with the
  208. inode->i_lock spinlock held.
  209. This method should be either NULL (normal UNIX filesystem
  210. semantics) or "generic_delete_inode" (for filesystems that do
  211. not want to cache inodes - causing "delete_inode" to always be
  212. called regardless of the value of i_nlink)
  213. The "generic_delete_inode()" behavior is equivalent to the old
  214. practice of using "force_delete" in the put_inode() case, but
  215. does not have the races that the "force_delete()" approach had.
  216. ``delete_inode``
  217. called when the VFS wants to delete an inode
  218. ``put_super``
  219. called when the VFS wishes to free the superblock
  220. (i.e. unmount). This is called with the superblock lock held
  221. ``sync_fs``
  222. called when VFS is writing out all dirty data associated with a
  223. superblock. The second parameter indicates whether the method
  224. should wait until the write out has been completed. Optional.
  225. ``freeze_fs``
  226. called when VFS is locking a filesystem and forcing it into a
  227. consistent state. This method is currently used by the Logical
  228. Volume Manager (LVM).
  229. ``unfreeze_fs``
  230. called when VFS is unlocking a filesystem and making it writable
  231. again.
  232. ``statfs``
  233. called when the VFS needs to get filesystem statistics.
  234. ``remount_fs``
  235. called when the filesystem is remounted. This is called with
  236. the kernel lock held
  237. ``clear_inode``
  238. called then the VFS clears the inode. Optional
  239. ``umount_begin``
  240. called when the VFS is unmounting a filesystem.
  241. ``show_options``
  242. called by the VFS to show mount options for /proc/<pid>/mounts.
  243. (see "Mount Options" section)
  244. ``quota_read``
  245. called by the VFS to read from filesystem quota file.
  246. ``quota_write``
  247. called by the VFS to write to filesystem quota file.
  248. ``nr_cached_objects``
  249. called by the sb cache shrinking function for the filesystem to
  250. return the number of freeable cached objects it contains.
  251. Optional.
  252. ``free_cache_objects``
  253. called by the sb cache shrinking function for the filesystem to
  254. scan the number of objects indicated to try to free them.
  255. Optional, but any filesystem implementing this method needs to
  256. also implement ->nr_cached_objects for it to be called
  257. correctly.
  258. We can't do anything with any errors that the filesystem might
  259. encountered, hence the void return type. This will never be
  260. called if the VM is trying to reclaim under GFP_NOFS conditions,
  261. hence this method does not need to handle that situation itself.
  262. Implementations must include conditional reschedule calls inside
  263. any scanning loop that is done. This allows the VFS to
  264. determine appropriate scan batch sizes without having to worry
  265. about whether implementations will cause holdoff problems due to
  266. large scan batch sizes.
  267. Whoever sets up the inode is responsible for filling in the "i_op"
  268. field. This is a pointer to a "struct inode_operations" which describes
  269. the methods that can be performed on individual inodes.
  270. struct xattr_handlers
  271. ---------------------
  272. On filesystems that support extended attributes (xattrs), the s_xattr
  273. superblock field points to a NULL-terminated array of xattr handlers.
  274. Extended attributes are name:value pairs.
  275. ``name``
  276. Indicates that the handler matches attributes with the specified
  277. name (such as "system.posix_acl_access"); the prefix field must
  278. be NULL.
  279. ``prefix``
  280. Indicates that the handler matches all attributes with the
  281. specified name prefix (such as "user."); the name field must be
  282. NULL.
  283. ``list``
  284. Determine if attributes matching this xattr handler should be
  285. listed for a particular dentry. Used by some listxattr
  286. implementations like generic_listxattr.
  287. ``get``
  288. Called by the VFS to get the value of a particular extended
  289. attribute. This method is called by the getxattr(2) system
  290. call.
  291. ``set``
  292. Called by the VFS to set the value of a particular extended
  293. attribute. When the new value is NULL, called to remove a
  294. particular extended attribute. This method is called by the
  295. setxattr(2) and removexattr(2) system calls.
  296. When none of the xattr handlers of a filesystem match the specified
  297. attribute name or when a filesystem doesn't support extended attributes,
  298. the various ``*xattr(2)`` system calls return -EOPNOTSUPP.
  299. The Inode Object
  300. ================
  301. An inode object represents an object within the filesystem.
  302. struct inode_operations
  303. -----------------------
  304. This describes how the VFS can manipulate an inode in your filesystem.
  305. As of kernel 2.6.22, the following members are defined:
  306. .. code-block:: c
  307. struct inode_operations {
  308. int (*create) (struct inode *,struct dentry *, umode_t, bool);
  309. struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
  310. int (*link) (struct dentry *,struct inode *,struct dentry *);
  311. int (*unlink) (struct inode *,struct dentry *);
  312. int (*symlink) (struct inode *,struct dentry *,const char *);
  313. int (*mkdir) (struct inode *,struct dentry *,umode_t);
  314. int (*rmdir) (struct inode *,struct dentry *);
  315. int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t);
  316. int (*rename) (struct inode *, struct dentry *,
  317. struct inode *, struct dentry *, unsigned int);
  318. int (*readlink) (struct dentry *, char __user *,int);
  319. const char *(*get_link) (struct dentry *, struct inode *,
  320. struct delayed_call *);
  321. int (*permission) (struct inode *, int);
  322. int (*get_acl)(struct inode *, int);
  323. int (*setattr) (struct dentry *, struct iattr *);
  324. int (*getattr) (const struct path *, struct kstat *, u32, unsigned int);
  325. ssize_t (*listxattr) (struct dentry *, char *, size_t);
  326. void (*update_time)(struct inode *, struct timespec *, int);
  327. int (*atomic_open)(struct inode *, struct dentry *, struct file *,
  328. unsigned open_flag, umode_t create_mode);
  329. int (*tmpfile) (struct inode *, struct dentry *, umode_t);
  330. };
  331. Again, all methods are called without any locks being held, unless
  332. otherwise noted.
  333. ``create``
  334. called by the open(2) and creat(2) system calls. Only required
  335. if you want to support regular files. The dentry you get should
  336. not have an inode (i.e. it should be a negative dentry). Here
  337. you will probably call d_instantiate() with the dentry and the
  338. newly created inode
  339. ``lookup``
  340. called when the VFS needs to look up an inode in a parent
  341. directory. The name to look for is found in the dentry. This
  342. method must call d_add() to insert the found inode into the
  343. dentry. The "i_count" field in the inode structure should be
  344. incremented. If the named inode does not exist a NULL inode
  345. should be inserted into the dentry (this is called a negative
  346. dentry). Returning an error code from this routine must only be
  347. done on a real error, otherwise creating inodes with system
  348. calls like create(2), mknod(2), mkdir(2) and so on will fail.
  349. If you wish to overload the dentry methods then you should
  350. initialise the "d_dop" field in the dentry; this is a pointer to
  351. a struct "dentry_operations". This method is called with the
  352. directory inode semaphore held
  353. ``link``
  354. called by the link(2) system call. Only required if you want to
  355. support hard links. You will probably need to call
  356. d_instantiate() just as you would in the create() method
  357. ``unlink``
  358. called by the unlink(2) system call. Only required if you want
  359. to support deleting inodes
  360. ``symlink``
  361. called by the symlink(2) system call. Only required if you want
  362. to support symlinks. You will probably need to call
  363. d_instantiate() just as you would in the create() method
  364. ``mkdir``
  365. called by the mkdir(2) system call. Only required if you want
  366. to support creating subdirectories. You will probably need to
  367. call d_instantiate() just as you would in the create() method
  368. ``rmdir``
  369. called by the rmdir(2) system call. Only required if you want
  370. to support deleting subdirectories
  371. ``mknod``
  372. called by the mknod(2) system call to create a device (char,
  373. block) inode or a named pipe (FIFO) or socket. Only required if
  374. you want to support creating these types of inodes. You will
  375. probably need to call d_instantiate() just as you would in the
  376. create() method
  377. ``rename``
  378. called by the rename(2) system call to rename the object to have
  379. the parent and name given by the second inode and dentry.
  380. The filesystem must return -EINVAL for any unsupported or
  381. unknown flags. Currently the following flags are implemented:
  382. (1) RENAME_NOREPLACE: this flag indicates that if the target of
  383. the rename exists the rename should fail with -EEXIST instead of
  384. replacing the target. The VFS already checks for existence, so
  385. for local filesystems the RENAME_NOREPLACE implementation is
  386. equivalent to plain rename.
  387. (2) RENAME_EXCHANGE: exchange source and target. Both must
  388. exist; this is checked by the VFS. Unlike plain rename, source
  389. and target may be of different type.
  390. ``get_link``
  391. called by the VFS to follow a symbolic link to the inode it
  392. points to. Only required if you want to support symbolic links.
  393. This method returns the symlink body to traverse (and possibly
  394. resets the current position with nd_jump_link()). If the body
  395. won't go away until the inode is gone, nothing else is needed;
  396. if it needs to be otherwise pinned, arrange for its release by
  397. having get_link(..., ..., done) do set_delayed_call(done,
  398. destructor, argument). In that case destructor(argument) will
  399. be called once VFS is done with the body you've returned. May
  400. be called in RCU mode; that is indicated by NULL dentry
  401. argument. If request can't be handled without leaving RCU mode,
  402. have it return ERR_PTR(-ECHILD).
  403. If the filesystem stores the symlink target in ->i_link, the
  404. VFS may use it directly without calling ->get_link(); however,
  405. ->get_link() must still be provided. ->i_link must not be
  406. freed until after an RCU grace period. Writing to ->i_link
  407. post-iget() time requires a 'release' memory barrier.
  408. ``readlink``
  409. this is now just an override for use by readlink(2) for the
  410. cases when ->get_link uses nd_jump_link() or object is not in
  411. fact a symlink. Normally filesystems should only implement
  412. ->get_link for symlinks and readlink(2) will automatically use
  413. that.
  414. ``permission``
  415. called by the VFS to check for access rights on a POSIX-like
  416. filesystem.
  417. May be called in rcu-walk mode (mask & MAY_NOT_BLOCK). If in
  418. rcu-walk mode, the filesystem must check the permission without
  419. blocking or storing to the inode.
  420. If a situation is encountered that rcu-walk cannot handle,
  421. return
  422. -ECHILD and it will be called again in ref-walk mode.
  423. ``setattr``
  424. called by the VFS to set attributes for a file. This method is
  425. called by chmod(2) and related system calls.
  426. ``getattr``
  427. called by the VFS to get attributes of a file. This method is
  428. called by stat(2) and related system calls.
  429. ``listxattr``
  430. called by the VFS to list all extended attributes for a given
  431. file. This method is called by the listxattr(2) system call.
  432. ``update_time``
  433. called by the VFS to update a specific time or the i_version of
  434. an inode. If this is not defined the VFS will update the inode
  435. itself and call mark_inode_dirty_sync.
  436. ``atomic_open``
  437. called on the last component of an open. Using this optional
  438. method the filesystem can look up, possibly create and open the
  439. file in one atomic operation. If it wants to leave actual
  440. opening to the caller (e.g. if the file turned out to be a
  441. symlink, device, or just something filesystem won't do atomic
  442. open for), it may signal this by returning finish_no_open(file,
  443. dentry). This method is only called if the last component is
  444. negative or needs lookup. Cached positive dentries are still
  445. handled by f_op->open(). If the file was created, FMODE_CREATED
  446. flag should be set in file->f_mode. In case of O_EXCL the
  447. method must only succeed if the file didn't exist and hence
  448. FMODE_CREATED shall always be set on success.
  449. ``tmpfile``
  450. called in the end of O_TMPFILE open(). Optional, equivalent to
  451. atomically creating, opening and unlinking a file in given
  452. directory.
  453. The Address Space Object
  454. ========================
  455. The address space object is used to group and manage pages in the page
  456. cache. It can be used to keep track of the pages in a file (or anything
  457. else) and also track the mapping of sections of the file into process
  458. address spaces.
  459. There are a number of distinct yet related services that an
  460. address-space can provide. These include communicating memory pressure,
  461. page lookup by address, and keeping track of pages tagged as Dirty or
  462. Writeback.
  463. The first can be used independently to the others. The VM can try to
  464. either write dirty pages in order to clean them, or release clean pages
  465. in order to reuse them. To do this it can call the ->writepage method
  466. on dirty pages, and ->releasepage on clean pages with PagePrivate set.
  467. Clean pages without PagePrivate and with no external references will be
  468. released without notice being given to the address_space.
  469. To achieve this functionality, pages need to be placed on an LRU with
  470. lru_cache_add and mark_page_active needs to be called whenever the page
  471. is used.
  472. Pages are normally kept in a radix tree index by ->index. This tree
  473. maintains information about the PG_Dirty and PG_Writeback status of each
  474. page, so that pages with either of these flags can be found quickly.
  475. The Dirty tag is primarily used by mpage_writepages - the default
  476. ->writepages method. It uses the tag to find dirty pages to call
  477. ->writepage on. If mpage_writepages is not used (i.e. the address
  478. provides its own ->writepages) , the PAGECACHE_TAG_DIRTY tag is almost
  479. unused. write_inode_now and sync_inode do use it (through
  480. __sync_single_inode) to check if ->writepages has been successful in
  481. writing out the whole address_space.
  482. The Writeback tag is used by filemap*wait* and sync_page* functions, via
  483. filemap_fdatawait_range, to wait for all writeback to complete.
  484. An address_space handler may attach extra information to a page,
  485. typically using the 'private' field in the 'struct page'. If such
  486. information is attached, the PG_Private flag should be set. This will
  487. cause various VM routines to make extra calls into the address_space
  488. handler to deal with that data.
  489. An address space acts as an intermediate between storage and
  490. application. Data is read into the address space a whole page at a
  491. time, and provided to the application either by copying of the page, or
  492. by memory-mapping the page. Data is written into the address space by
  493. the application, and then written-back to storage typically in whole
  494. pages, however the address_space has finer control of write sizes.
  495. The read process essentially only requires 'readpage'. The write
  496. process is more complicated and uses write_begin/write_end or
  497. set_page_dirty to write data into the address_space, and writepage and
  498. writepages to writeback data to storage.
  499. Adding and removing pages to/from an address_space is protected by the
  500. inode's i_mutex.
  501. When data is written to a page, the PG_Dirty flag should be set. It
  502. typically remains set until writepage asks for it to be written. This
  503. should clear PG_Dirty and set PG_Writeback. It can be actually written
  504. at any point after PG_Dirty is clear. Once it is known to be safe,
  505. PG_Writeback is cleared.
  506. Writeback makes use of a writeback_control structure to direct the
  507. operations. This gives the writepage and writepages operations some
  508. information about the nature of and reason for the writeback request,
  509. and the constraints under which it is being done. It is also used to
  510. return information back to the caller about the result of a writepage or
  511. writepages request.
  512. Handling errors during writeback
  513. --------------------------------
  514. Most applications that do buffered I/O will periodically call a file
  515. synchronization call (fsync, fdatasync, msync or sync_file_range) to
  516. ensure that data written has made it to the backing store. When there
  517. is an error during writeback, they expect that error to be reported when
  518. a file sync request is made. After an error has been reported on one
  519. request, subsequent requests on the same file descriptor should return
  520. 0, unless further writeback errors have occurred since the previous file
  521. syncronization.
  522. Ideally, the kernel would report errors only on file descriptions on
  523. which writes were done that subsequently failed to be written back. The
  524. generic pagecache infrastructure does not track the file descriptions
  525. that have dirtied each individual page however, so determining which
  526. file descriptors should get back an error is not possible.
  527. Instead, the generic writeback error tracking infrastructure in the
  528. kernel settles for reporting errors to fsync on all file descriptions
  529. that were open at the time that the error occurred. In a situation with
  530. multiple writers, all of them will get back an error on a subsequent
  531. fsync, even if all of the writes done through that particular file
  532. descriptor succeeded (or even if there were no writes on that file
  533. descriptor at all).
  534. Filesystems that wish to use this infrastructure should call
  535. mapping_set_error to record the error in the address_space when it
  536. occurs. Then, after writing back data from the pagecache in their
  537. file->fsync operation, they should call file_check_and_advance_wb_err to
  538. ensure that the struct file's error cursor has advanced to the correct
  539. point in the stream of errors emitted by the backing device(s).
  540. struct address_space_operations
  541. -------------------------------
  542. This describes how the VFS can manipulate mapping of a file to page
  543. cache in your filesystem. The following members are defined:
  544. .. code-block:: c
  545. struct address_space_operations {
  546. int (*writepage)(struct page *page, struct writeback_control *wbc);
  547. int (*readpage)(struct file *, struct page *);
  548. int (*writepages)(struct address_space *, struct writeback_control *);
  549. int (*set_page_dirty)(struct page *page);
  550. void (*readahead)(struct readahead_control *);
  551. int (*readpages)(struct file *filp, struct address_space *mapping,
  552. struct list_head *pages, unsigned nr_pages);
  553. int (*write_begin)(struct file *, struct address_space *mapping,
  554. loff_t pos, unsigned len, unsigned flags,
  555. struct page **pagep, void **fsdata);
  556. int (*write_end)(struct file *, struct address_space *mapping,
  557. loff_t pos, unsigned len, unsigned copied,
  558. struct page *page, void *fsdata);
  559. sector_t (*bmap)(struct address_space *, sector_t);
  560. void (*invalidatepage) (struct page *, unsigned int, unsigned int);
  561. int (*releasepage) (struct page *, int);
  562. void (*freepage)(struct page *);
  563. ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *iter);
  564. /* isolate a page for migration */
  565. bool (*isolate_page) (struct page *, isolate_mode_t);
  566. /* migrate the contents of a page to the specified target */
  567. int (*migratepage) (struct page *, struct page *);
  568. /* put migration-failed page back to right list */
  569. void (*putback_page) (struct page *);
  570. int (*launder_page) (struct page *);
  571. int (*is_partially_uptodate) (struct page *, unsigned long,
  572. unsigned long);
  573. void (*is_dirty_writeback) (struct page *, bool *, bool *);
  574. int (*error_remove_page) (struct mapping *mapping, struct page *page);
  575. int (*swap_activate)(struct file *);
  576. int (*swap_deactivate)(struct file *);
  577. };
  578. ``writepage``
  579. called by the VM to write a dirty page to backing store. This
  580. may happen for data integrity reasons (i.e. 'sync'), or to free
  581. up memory (flush). The difference can be seen in
  582. wbc->sync_mode. The PG_Dirty flag has been cleared and
  583. PageLocked is true. writepage should start writeout, should set
  584. PG_Writeback, and should make sure the page is unlocked, either
  585. synchronously or asynchronously when the write operation
  586. completes.
  587. If wbc->sync_mode is WB_SYNC_NONE, ->writepage doesn't have to
  588. try too hard if there are problems, and may choose to write out
  589. other pages from the mapping if that is easier (e.g. due to
  590. internal dependencies). If it chooses not to start writeout, it
  591. should return AOP_WRITEPAGE_ACTIVATE so that the VM will not
  592. keep calling ->writepage on that page.
  593. See the file "Locking" for more details.
  594. ``readpage``
  595. called by the VM to read a page from backing store. The page
  596. will be Locked when readpage is called, and should be unlocked
  597. and marked uptodate once the read completes. If ->readpage
  598. discovers that it needs to unlock the page for some reason, it
  599. can do so, and then return AOP_TRUNCATED_PAGE. In this case,
  600. the page will be relocated, relocked and if that all succeeds,
  601. ->readpage will be called again.
  602. ``writepages``
  603. called by the VM to write out pages associated with the
  604. address_space object. If wbc->sync_mode is WB_SYNC_ALL, then
  605. the writeback_control will specify a range of pages that must be
  606. written out. If it is WB_SYNC_NONE, then a nr_to_write is
  607. given and that many pages should be written if possible. If no
  608. ->writepages is given, then mpage_writepages is used instead.
  609. This will choose pages from the address space that are tagged as
  610. DIRTY and will pass them to ->writepage.
  611. ``set_page_dirty``
  612. called by the VM to set a page dirty. This is particularly
  613. needed if an address space attaches private data to a page, and
  614. that data needs to be updated when a page is dirtied. This is
  615. called, for example, when a memory mapped page gets modified.
  616. If defined, it should set the PageDirty flag, and the
  617. PAGECACHE_TAG_DIRTY tag in the radix tree.
  618. ``readahead``
  619. Called by the VM to read pages associated with the address_space
  620. object. The pages are consecutive in the page cache and are
  621. locked. The implementation should decrement the page refcount
  622. after starting I/O on each page. Usually the page will be
  623. unlocked by the I/O completion handler. If the filesystem decides
  624. to stop attempting I/O before reaching the end of the readahead
  625. window, it can simply return. The caller will decrement the page
  626. refcount and unlock the remaining pages for you. Set PageUptodate
  627. if the I/O completes successfully. Setting PageError on any page
  628. will be ignored; simply unlock the page if an I/O error occurs.
  629. ``readpages``
  630. called by the VM to read pages associated with the address_space
  631. object. This is essentially just a vector version of readpage.
  632. Instead of just one page, several pages are requested.
  633. readpages is only used for read-ahead, so read errors are
  634. ignored. If anything goes wrong, feel free to give up.
  635. This interface is deprecated and will be removed by the end of
  636. 2020; implement readahead instead.
  637. ``write_begin``
  638. Called by the generic buffered write code to ask the filesystem
  639. to prepare to write len bytes at the given offset in the file.
  640. The address_space should check that the write will be able to
  641. complete, by allocating space if necessary and doing any other
  642. internal housekeeping. If the write will update parts of any
  643. basic-blocks on storage, then those blocks should be pre-read
  644. (if they haven't been read already) so that the updated blocks
  645. can be written out properly.
  646. The filesystem must return the locked pagecache page for the
  647. specified offset, in ``*pagep``, for the caller to write into.
  648. It must be able to cope with short writes (where the length
  649. passed to write_begin is greater than the number of bytes copied
  650. into the page).
  651. flags is a field for AOP_FLAG_xxx flags, described in
  652. include/linux/fs.h.
  653. A void * may be returned in fsdata, which then gets passed into
  654. write_end.
  655. Returns 0 on success; < 0 on failure (which is the error code),
  656. in which case write_end is not called.
  657. ``write_end``
  658. After a successful write_begin, and data copy, write_end must be
  659. called. len is the original len passed to write_begin, and
  660. copied is the amount that was able to be copied.
  661. The filesystem must take care of unlocking the page and
  662. releasing it refcount, and updating i_size.
  663. Returns < 0 on failure, otherwise the number of bytes (<=
  664. 'copied') that were able to be copied into pagecache.
  665. ``bmap``
  666. called by the VFS to map a logical block offset within object to
  667. physical block number. This method is used by the FIBMAP ioctl
  668. and for working with swap-files. To be able to swap to a file,
  669. the file must have a stable mapping to a block device. The swap
  670. system does not go through the filesystem but instead uses bmap
  671. to find out where the blocks in the file are and uses those
  672. addresses directly.
  673. ``invalidatepage``
  674. If a page has PagePrivate set, then invalidatepage will be
  675. called when part or all of the page is to be removed from the
  676. address space. This generally corresponds to either a
  677. truncation, punch hole or a complete invalidation of the address
  678. space (in the latter case 'offset' will always be 0 and 'length'
  679. will be PAGE_SIZE). Any private data associated with the page
  680. should be updated to reflect this truncation. If offset is 0
  681. and length is PAGE_SIZE, then the private data should be
  682. released, because the page must be able to be completely
  683. discarded. This may be done by calling the ->releasepage
  684. function, but in this case the release MUST succeed.
  685. ``releasepage``
  686. releasepage is called on PagePrivate pages to indicate that the
  687. page should be freed if possible. ->releasepage should remove
  688. any private data from the page and clear the PagePrivate flag.
  689. If releasepage() fails for some reason, it must indicate failure
  690. with a 0 return value. releasepage() is used in two distinct
  691. though related cases. The first is when the VM finds a clean
  692. page with no active users and wants to make it a free page. If
  693. ->releasepage succeeds, the page will be removed from the
  694. address_space and become free.
  695. The second case is when a request has been made to invalidate
  696. some or all pages in an address_space. This can happen through
  697. the fadvise(POSIX_FADV_DONTNEED) system call or by the
  698. filesystem explicitly requesting it as nfs and 9fs do (when they
  699. believe the cache may be out of date with storage) by calling
  700. invalidate_inode_pages2(). If the filesystem makes such a call,
  701. and needs to be certain that all pages are invalidated, then its
  702. releasepage will need to ensure this. Possibly it can clear the
  703. PageUptodate bit if it cannot free private data yet.
  704. ``freepage``
  705. freepage is called once the page is no longer visible in the
  706. page cache in order to allow the cleanup of any private data.
  707. Since it may be called by the memory reclaimer, it should not
  708. assume that the original address_space mapping still exists, and
  709. it should not block.
  710. ``direct_IO``
  711. called by the generic read/write routines to perform direct_IO -
  712. that is IO requests which bypass the page cache and transfer
  713. data directly between the storage and the application's address
  714. space.
  715. ``isolate_page``
  716. Called by the VM when isolating a movable non-lru page. If page
  717. is successfully isolated, VM marks the page as PG_isolated via
  718. __SetPageIsolated.
  719. ``migrate_page``
  720. This is used to compact the physical memory usage. If the VM
  721. wants to relocate a page (maybe off a memory card that is
  722. signalling imminent failure) it will pass a new page and an old
  723. page to this function. migrate_page should transfer any private
  724. data across and update any references that it has to the page.
  725. ``putback_page``
  726. Called by the VM when isolated page's migration fails.
  727. ``launder_page``
  728. Called before freeing a page - it writes back the dirty page.
  729. To prevent redirtying the page, it is kept locked during the
  730. whole operation.
  731. ``is_partially_uptodate``
  732. Called by the VM when reading a file through the pagecache when
  733. the underlying blocksize != pagesize. If the required block is
  734. up to date then the read can complete without needing the IO to
  735. bring the whole page up to date.
  736. ``is_dirty_writeback``
  737. Called by the VM when attempting to reclaim a page. The VM uses
  738. dirty and writeback information to determine if it needs to
  739. stall to allow flushers a chance to complete some IO.
  740. Ordinarily it can use PageDirty and PageWriteback but some
  741. filesystems have more complex state (unstable pages in NFS
  742. prevent reclaim) or do not set those flags due to locking
  743. problems. This callback allows a filesystem to indicate to the
  744. VM if a page should be treated as dirty or writeback for the
  745. purposes of stalling.
  746. ``error_remove_page``
  747. normally set to generic_error_remove_page if truncation is ok
  748. for this address space. Used for memory failure handling.
  749. Setting this implies you deal with pages going away under you,
  750. unless you have them locked or reference counts increased.
  751. ``swap_activate``
  752. Called when swapon is used on a file to allocate space if
  753. necessary and pin the block lookup information in memory. A
  754. return value of zero indicates success, in which case this file
  755. can be used to back swapspace.
  756. ``swap_deactivate``
  757. Called during swapoff on files where swap_activate was
  758. successful.
  759. The File Object
  760. ===============
  761. A file object represents a file opened by a process. This is also known
  762. as an "open file description" in POSIX parlance.
  763. struct file_operations
  764. ----------------------
  765. This describes how the VFS can manipulate an open file. As of kernel
  766. 4.18, the following members are defined:
  767. .. code-block:: c
  768. struct file_operations {
  769. struct module *owner;
  770. loff_t (*llseek) (struct file *, loff_t, int);
  771. ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
  772. ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
  773. ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
  774. ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
  775. int (*iopoll)(struct kiocb *kiocb, bool spin);
  776. int (*iterate) (struct file *, struct dir_context *);
  777. int (*iterate_shared) (struct file *, struct dir_context *);
  778. __poll_t (*poll) (struct file *, struct poll_table_struct *);
  779. long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
  780. long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
  781. int (*mmap) (struct file *, struct vm_area_struct *);
  782. int (*open) (struct inode *, struct file *);
  783. int (*flush) (struct file *, fl_owner_t id);
  784. int (*release) (struct inode *, struct file *);
  785. int (*fsync) (struct file *, loff_t, loff_t, int datasync);
  786. int (*fasync) (int, struct file *, int);
  787. int (*lock) (struct file *, int, struct file_lock *);
  788. ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
  789. unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
  790. int (*check_flags)(int);
  791. int (*flock) (struct file *, int, struct file_lock *);
  792. ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
  793. ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
  794. int (*setlease)(struct file *, long, struct file_lock **, void **);
  795. long (*fallocate)(struct file *file, int mode, loff_t offset,
  796. loff_t len);
  797. void (*show_fdinfo)(struct seq_file *m, struct file *f);
  798. #ifndef CONFIG_MMU
  799. unsigned (*mmap_capabilities)(struct file *);
  800. #endif
  801. ssize_t (*copy_file_range)(struct file *, loff_t, struct file *, loff_t, size_t, unsigned int);
  802. loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
  803. struct file *file_out, loff_t pos_out,
  804. loff_t len, unsigned int remap_flags);
  805. int (*fadvise)(struct file *, loff_t, loff_t, int);
  806. };
  807. Again, all methods are called without any locks being held, unless
  808. otherwise noted.
  809. ``llseek``
  810. called when the VFS needs to move the file position index
  811. ``read``
  812. called by read(2) and related system calls
  813. ``read_iter``
  814. possibly asynchronous read with iov_iter as destination
  815. ``write``
  816. called by write(2) and related system calls
  817. ``write_iter``
  818. possibly asynchronous write with iov_iter as source
  819. ``iopoll``
  820. called when aio wants to poll for completions on HIPRI iocbs
  821. ``iterate``
  822. called when the VFS needs to read the directory contents
  823. ``iterate_shared``
  824. called when the VFS needs to read the directory contents when
  825. filesystem supports concurrent dir iterators
  826. ``poll``
  827. called by the VFS when a process wants to check if there is
  828. activity on this file and (optionally) go to sleep until there
  829. is activity. Called by the select(2) and poll(2) system calls
  830. ``unlocked_ioctl``
  831. called by the ioctl(2) system call.
  832. ``compat_ioctl``
  833. called by the ioctl(2) system call when 32 bit system calls are
  834. used on 64 bit kernels.
  835. ``mmap``
  836. called by the mmap(2) system call
  837. ``open``
  838. called by the VFS when an inode should be opened. When the VFS
  839. opens a file, it creates a new "struct file". It then calls the
  840. open method for the newly allocated file structure. You might
  841. think that the open method really belongs in "struct
  842. inode_operations", and you may be right. I think it's done the
  843. way it is because it makes filesystems simpler to implement.
  844. The open() method is a good place to initialize the
  845. "private_data" member in the file structure if you want to point
  846. to a device structure
  847. ``flush``
  848. called by the close(2) system call to flush a file
  849. ``release``
  850. called when the last reference to an open file is closed
  851. ``fsync``
  852. called by the fsync(2) system call. Also see the section above
  853. entitled "Handling errors during writeback".
  854. ``fasync``
  855. called by the fcntl(2) system call when asynchronous
  856. (non-blocking) mode is enabled for a file
  857. ``lock``
  858. called by the fcntl(2) system call for F_GETLK, F_SETLK, and
  859. F_SETLKW commands
  860. ``get_unmapped_area``
  861. called by the mmap(2) system call
  862. ``check_flags``
  863. called by the fcntl(2) system call for F_SETFL command
  864. ``flock``
  865. called by the flock(2) system call
  866. ``splice_write``
  867. called by the VFS to splice data from a pipe to a file. This
  868. method is used by the splice(2) system call
  869. ``splice_read``
  870. called by the VFS to splice data from file to a pipe. This
  871. method is used by the splice(2) system call
  872. ``setlease``
  873. called by the VFS to set or release a file lock lease. setlease
  874. implementations should call generic_setlease to record or remove
  875. the lease in the inode after setting it.
  876. ``fallocate``
  877. called by the VFS to preallocate blocks or punch a hole.
  878. ``copy_file_range``
  879. called by the copy_file_range(2) system call.
  880. ``remap_file_range``
  881. called by the ioctl(2) system call for FICLONERANGE and FICLONE
  882. and FIDEDUPERANGE commands to remap file ranges. An
  883. implementation should remap len bytes at pos_in of the source
  884. file into the dest file at pos_out. Implementations must handle
  885. callers passing in len == 0; this means "remap to the end of the
  886. source file". The return value should the number of bytes
  887. remapped, or the usual negative error code if errors occurred
  888. before any bytes were remapped. The remap_flags parameter
  889. accepts REMAP_FILE_* flags. If REMAP_FILE_DEDUP is set then the
  890. implementation must only remap if the requested file ranges have
  891. identical contents. If REMAP_FILE_CAN_SHORTEN is set, the caller is
  892. ok with the implementation shortening the request length to
  893. satisfy alignment or EOF requirements (or any other reason).
  894. ``fadvise``
  895. possibly called by the fadvise64() system call.
  896. Note that the file operations are implemented by the specific
  897. filesystem in which the inode resides. When opening a device node
  898. (character or block special) most filesystems will call special
  899. support routines in the VFS which will locate the required device
  900. driver information. These support routines replace the filesystem file
  901. operations with those for the device driver, and then proceed to call
  902. the new open() method for the file. This is how opening a device file
  903. in the filesystem eventually ends up calling the device driver open()
  904. method.
  905. Directory Entry Cache (dcache)
  906. ==============================
  907. struct dentry_operations
  908. ------------------------
  909. This describes how a filesystem can overload the standard dentry
  910. operations. Dentries and the dcache are the domain of the VFS and the
  911. individual filesystem implementations. Device drivers have no business
  912. here. These methods may be set to NULL, as they are either optional or
  913. the VFS uses a default. As of kernel 2.6.22, the following members are
  914. defined:
  915. .. code-block:: c
  916. struct dentry_operations {
  917. int (*d_revalidate)(struct dentry *, unsigned int);
  918. int (*d_weak_revalidate)(struct dentry *, unsigned int);
  919. int (*d_hash)(const struct dentry *, struct qstr *);
  920. int (*d_compare)(const struct dentry *,
  921. unsigned int, const char *, const struct qstr *);
  922. int (*d_delete)(const struct dentry *);
  923. int (*d_init)(struct dentry *);
  924. void (*d_release)(struct dentry *);
  925. void (*d_iput)(struct dentry *, struct inode *);
  926. char *(*d_dname)(struct dentry *, char *, int);
  927. struct vfsmount *(*d_automount)(struct path *);
  928. int (*d_manage)(const struct path *, bool);
  929. struct dentry *(*d_real)(struct dentry *, const struct inode *);
  930. };
  931. ``d_revalidate``
  932. called when the VFS needs to revalidate a dentry. This is
  933. called whenever a name look-up finds a dentry in the dcache.
  934. Most local filesystems leave this as NULL, because all their
  935. dentries in the dcache are valid. Network filesystems are
  936. different since things can change on the server without the
  937. client necessarily being aware of it.
  938. This function should return a positive value if the dentry is
  939. still valid, and zero or a negative error code if it isn't.
  940. d_revalidate may be called in rcu-walk mode (flags &
  941. LOOKUP_RCU). If in rcu-walk mode, the filesystem must
  942. revalidate the dentry without blocking or storing to the dentry,
  943. d_parent and d_inode should not be used without care (because
  944. they can change and, in d_inode case, even become NULL under
  945. us).
  946. If a situation is encountered that rcu-walk cannot handle,
  947. return
  948. -ECHILD and it will be called again in ref-walk mode.
  949. ``_weak_revalidate``
  950. called when the VFS needs to revalidate a "jumped" dentry. This
  951. is called when a path-walk ends at dentry that was not acquired
  952. by doing a lookup in the parent directory. This includes "/",
  953. "." and "..", as well as procfs-style symlinks and mountpoint
  954. traversal.
  955. In this case, we are less concerned with whether the dentry is
  956. still fully correct, but rather that the inode is still valid.
  957. As with d_revalidate, most local filesystems will set this to
  958. NULL since their dcache entries are always valid.
  959. This function has the same return code semantics as
  960. d_revalidate.
  961. d_weak_revalidate is only called after leaving rcu-walk mode.
  962. ``d_hash``
  963. called when the VFS adds a dentry to the hash table. The first
  964. dentry passed to d_hash is the parent directory that the name is
  965. to be hashed into.
  966. Same locking and synchronisation rules as d_compare regarding
  967. what is safe to dereference etc.
  968. ``d_compare``
  969. called to compare a dentry name with a given name. The first
  970. dentry is the parent of the dentry to be compared, the second is
  971. the child dentry. len and name string are properties of the
  972. dentry to be compared. qstr is the name to compare it with.
  973. Must be constant and idempotent, and should not take locks if
  974. possible, and should not or store into the dentry. Should not
  975. dereference pointers outside the dentry without lots of care
  976. (eg. d_parent, d_inode, d_name should not be used).
  977. However, our vfsmount is pinned, and RCU held, so the dentries
  978. and inodes won't disappear, neither will our sb or filesystem
  979. module. ->d_sb may be used.
  980. It is a tricky calling convention because it needs to be called
  981. under "rcu-walk", ie. without any locks or references on things.
  982. ``d_delete``
  983. called when the last reference to a dentry is dropped and the
  984. dcache is deciding whether or not to cache it. Return 1 to
  985. delete immediately, or 0 to cache the dentry. Default is NULL
  986. which means to always cache a reachable dentry. d_delete must
  987. be constant and idempotent.
  988. ``d_init``
  989. called when a dentry is allocated
  990. ``d_release``
  991. called when a dentry is really deallocated
  992. ``d_iput``
  993. called when a dentry loses its inode (just prior to its being
  994. deallocated). The default when this is NULL is that the VFS
  995. calls iput(). If you define this method, you must call iput()
  996. yourself
  997. ``d_dname``
  998. called when the pathname of a dentry should be generated.
  999. Useful for some pseudo filesystems (sockfs, pipefs, ...) to
  1000. delay pathname generation. (Instead of doing it when dentry is
  1001. created, it's done only when the path is needed.). Real
  1002. filesystems probably dont want to use it, because their dentries
  1003. are present in global dcache hash, so their hash should be an
  1004. invariant. As no lock is held, d_dname() should not try to
  1005. modify the dentry itself, unless appropriate SMP safety is used.
  1006. CAUTION : d_path() logic is quite tricky. The correct way to
  1007. return for example "Hello" is to put it at the end of the
  1008. buffer, and returns a pointer to the first char.
  1009. dynamic_dname() helper function is provided to take care of
  1010. this.
  1011. Example :
  1012. .. code-block:: c
  1013. static char *pipefs_dname(struct dentry *dent, char *buffer, int buflen)
  1014. {
  1015. return dynamic_dname(dentry, buffer, buflen, "pipe:[%lu]",
  1016. dentry->d_inode->i_ino);
  1017. }
  1018. ``d_automount``
  1019. called when an automount dentry is to be traversed (optional).
  1020. This should create a new VFS mount record and return the record
  1021. to the caller. The caller is supplied with a path parameter
  1022. giving the automount directory to describe the automount target
  1023. and the parent VFS mount record to provide inheritable mount
  1024. parameters. NULL should be returned if someone else managed to
  1025. make the automount first. If the vfsmount creation failed, then
  1026. an error code should be returned. If -EISDIR is returned, then
  1027. the directory will be treated as an ordinary directory and
  1028. returned to pathwalk to continue walking.
  1029. If a vfsmount is returned, the caller will attempt to mount it
  1030. on the mountpoint and will remove the vfsmount from its
  1031. expiration list in the case of failure. The vfsmount should be
  1032. returned with 2 refs on it to prevent automatic expiration - the
  1033. caller will clean up the additional ref.
  1034. This function is only used if DCACHE_NEED_AUTOMOUNT is set on
  1035. the dentry. This is set by __d_instantiate() if S_AUTOMOUNT is
  1036. set on the inode being added.
  1037. ``d_manage``
  1038. called to allow the filesystem to manage the transition from a
  1039. dentry (optional). This allows autofs, for example, to hold up
  1040. clients waiting to explore behind a 'mountpoint' while letting
  1041. the daemon go past and construct the subtree there. 0 should be
  1042. returned to let the calling process continue. -EISDIR can be
  1043. returned to tell pathwalk to use this directory as an ordinary
  1044. directory and to ignore anything mounted on it and not to check
  1045. the automount flag. Any other error code will abort pathwalk
  1046. completely.
  1047. If the 'rcu_walk' parameter is true, then the caller is doing a
  1048. pathwalk in RCU-walk mode. Sleeping is not permitted in this
  1049. mode, and the caller can be asked to leave it and call again by
  1050. returning -ECHILD. -EISDIR may also be returned to tell
  1051. pathwalk to ignore d_automount or any mounts.
  1052. This function is only used if DCACHE_MANAGE_TRANSIT is set on
  1053. the dentry being transited from.
  1054. ``d_real``
  1055. overlay/union type filesystems implement this method to return
  1056. one of the underlying dentries hidden by the overlay. It is
  1057. used in two different modes:
  1058. Called from file_dentry() it returns the real dentry matching
  1059. the inode argument. The real dentry may be from a lower layer
  1060. already copied up, but still referenced from the file. This
  1061. mode is selected with a non-NULL inode argument.
  1062. With NULL inode the topmost real underlying dentry is returned.
  1063. Each dentry has a pointer to its parent dentry, as well as a hash list
  1064. of child dentries. Child dentries are basically like files in a
  1065. directory.
  1066. Directory Entry Cache API
  1067. --------------------------
  1068. There are a number of functions defined which permit a filesystem to
  1069. manipulate dentries:
  1070. ``dget``
  1071. open a new handle for an existing dentry (this just increments
  1072. the usage count)
  1073. ``dput``
  1074. close a handle for a dentry (decrements the usage count). If
  1075. the usage count drops to 0, and the dentry is still in its
  1076. parent's hash, the "d_delete" method is called to check whether
  1077. it should be cached. If it should not be cached, or if the
  1078. dentry is not hashed, it is deleted. Otherwise cached dentries
  1079. are put into an LRU list to be reclaimed on memory shortage.
  1080. ``d_drop``
  1081. this unhashes a dentry from its parents hash list. A subsequent
  1082. call to dput() will deallocate the dentry if its usage count
  1083. drops to 0
  1084. ``d_delete``
  1085. delete a dentry. If there are no other open references to the
  1086. dentry then the dentry is turned into a negative dentry (the
  1087. d_iput() method is called). If there are other references, then
  1088. d_drop() is called instead
  1089. ``d_add``
  1090. add a dentry to its parents hash list and then calls
  1091. d_instantiate()
  1092. ``d_instantiate``
  1093. add a dentry to the alias hash list for the inode and updates
  1094. the "d_inode" member. The "i_count" member in the inode
  1095. structure should be set/incremented. If the inode pointer is
  1096. NULL, the dentry is called a "negative dentry". This function
  1097. is commonly called when an inode is created for an existing
  1098. negative dentry
  1099. ``d_lookup``
  1100. look up a dentry given its parent and path name component It
  1101. looks up the child of that given name from the dcache hash
  1102. table. If it is found, the reference count is incremented and
  1103. the dentry is returned. The caller must use dput() to free the
  1104. dentry when it finishes using it.
  1105. Mount Options
  1106. =============
  1107. Parsing options
  1108. ---------------
  1109. On mount and remount the filesystem is passed a string containing a
  1110. comma separated list of mount options. The options can have either of
  1111. these forms:
  1112. option
  1113. option=value
  1114. The <linux/parser.h> header defines an API that helps parse these
  1115. options. There are plenty of examples on how to use it in existing
  1116. filesystems.
  1117. Showing options
  1118. ---------------
  1119. If a filesystem accepts mount options, it must define show_options() to
  1120. show all the currently active options. The rules are:
  1121. - options MUST be shown which are not default or their values differ
  1122. from the default
  1123. - options MAY be shown which are enabled by default or have their
  1124. default value
  1125. Options used only internally between a mount helper and the kernel (such
  1126. as file descriptors), or which only have an effect during the mounting
  1127. (such as ones controlling the creation of a journal) are exempt from the
  1128. above rules.
  1129. The underlying reason for the above rules is to make sure, that a mount
  1130. can be accurately replicated (e.g. umounting and mounting again) based
  1131. on the information found in /proc/mounts.
  1132. Resources
  1133. =========
  1134. (Note some of these resources are not up-to-date with the latest kernel
  1135. version.)
  1136. Creating Linux virtual filesystems. 2002
  1137. <https://lwn.net/Articles/13325/>
  1138. The Linux Virtual File-system Layer by Neil Brown. 1999
  1139. <http://www.cse.unsw.edu.au/~neilb/oss/linux-commentary/vfs.html>
  1140. A tour of the Linux VFS by Michael K. Johnson. 1996
  1141. <https://www.tldp.org/LDP/khg/HyperNews/get/fs/vfstour.html>
  1142. A small trail through the Linux kernel by Andries Brouwer. 2001
  1143. <https://www.win.tue.nl/~aeb/linux/vfs/trail.html>