fs.h 86 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555
  1. #ifndef _LINUX_FS_H
  2. #define _LINUX_FS_H
  3. /*
  4. * This file has definitions for some important file table
  5. * structures etc.
  6. */
  7. #include <linux/limits.h>
  8. #include <linux/ioctl.h>
  9. #include <linux/blk_types.h>
  10. #include <linux/types.h>
  11. /*
  12. * It's silly to have NR_OPEN bigger than NR_FILE, but you can change
  13. * the file limit at runtime and only root can increase the per-process
  14. * nr_file rlimit, so it's safe to set up a ridiculously high absolute
  15. * upper limit on files-per-process.
  16. *
  17. * Some programs (notably those using select()) may have to be
  18. * recompiled to take full advantage of the new limits..
  19. */
  20. /* Fixed constants first: */
  21. #undef NR_OPEN
  22. #define INR_OPEN 1024 /* Initial setting for nfile rlimits */
  23. #define BLOCK_SIZE_BITS 10
  24. #define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
  25. #define SEEK_SET 0 /* seek relative to beginning of file */
  26. #define SEEK_CUR 1 /* seek relative to current file position */
  27. #define SEEK_END 2 /* seek relative to end of file */
  28. #define SEEK_MAX SEEK_END
  29. struct fstrim_range {
  30. __u64 start;
  31. __u64 len;
  32. __u64 minlen;
  33. };
  34. /* And dynamically-tunable limits and defaults: */
  35. struct files_stat_struct {
  36. unsigned long nr_files; /* read only */
  37. unsigned long nr_free_files; /* read only */
  38. unsigned long max_files; /* tunable */
  39. };
  40. struct inodes_stat_t {
  41. int nr_inodes;
  42. int nr_unused;
  43. int dummy[5]; /* padding for sysctl ABI compatibility */
  44. };
  45. #define NR_FILE 8192 /* this can well be larger on a larger system */
  46. #define MAY_EXEC 1
  47. #define MAY_WRITE 2
  48. #define MAY_READ 4
  49. #define MAY_APPEND 8
  50. #define MAY_ACCESS 16
  51. #define MAY_OPEN 32
  52. #define MAY_CHDIR 64
  53. /*
  54. * flags in file.f_mode. Note that FMODE_READ and FMODE_WRITE must correspond
  55. * to O_WRONLY and O_RDWR via the strange trick in __dentry_open()
  56. */
  57. /* file is open for reading */
  58. #define FMODE_READ ((__force fmode_t)0x1)
  59. /* file is open for writing */
  60. #define FMODE_WRITE ((__force fmode_t)0x2)
  61. /* file is seekable */
  62. #define FMODE_LSEEK ((__force fmode_t)0x4)
  63. /* file can be accessed using pread */
  64. #define FMODE_PREAD ((__force fmode_t)0x8)
  65. /* file can be accessed using pwrite */
  66. #define FMODE_PWRITE ((__force fmode_t)0x10)
  67. /* File is opened for execution with sys_execve / sys_uselib */
  68. #define FMODE_EXEC ((__force fmode_t)0x20)
  69. /* File is opened with O_NDELAY (only set for block devices) */
  70. #define FMODE_NDELAY ((__force fmode_t)0x40)
  71. /* File is opened with O_EXCL (only set for block devices) */
  72. #define FMODE_EXCL ((__force fmode_t)0x80)
  73. /* File is opened using open(.., 3, ..) and is writeable only for ioctls
  74. (specialy hack for floppy.c) */
  75. #define FMODE_WRITE_IOCTL ((__force fmode_t)0x100)
  76. /*
  77. * Don't update ctime and mtime.
  78. *
  79. * Currently a special hack for the XFS open_by_handle ioctl, but we'll
  80. * hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon.
  81. */
  82. #define FMODE_NOCMTIME ((__force fmode_t)0x800)
  83. /* Expect random access pattern */
  84. #define FMODE_RANDOM ((__force fmode_t)0x1000)
  85. /* File is huge (eg. /dev/kmem): treat loff_t as unsigned */
  86. #define FMODE_UNSIGNED_OFFSET ((__force fmode_t)0x2000)
  87. /* File was opened by fanotify and shouldn't generate fanotify events */
  88. #define FMODE_NONOTIFY ((__force fmode_t)0x1000000)
  89. /*
  90. * The below are the various read and write types that we support. Some of
  91. * them include behavioral modifiers that send information down to the
  92. * block layer and IO scheduler. Terminology:
  93. *
  94. * The block layer uses device plugging to defer IO a little bit, in
  95. * the hope that we will see more IO very shortly. This increases
  96. * coalescing of adjacent IO and thus reduces the number of IOs we
  97. * have to send to the device. It also allows for better queuing,
  98. * if the IO isn't mergeable. If the caller is going to be waiting
  99. * for the IO, then he must ensure that the device is unplugged so
  100. * that the IO is dispatched to the driver.
  101. *
  102. * All IO is handled async in Linux. This is fine for background
  103. * writes, but for reads or writes that someone waits for completion
  104. * on, we want to notify the block layer and IO scheduler so that they
  105. * know about it. That allows them to make better scheduling
  106. * decisions. So when the below references 'sync' and 'async', it
  107. * is referencing this priority hint.
  108. *
  109. * With that in mind, the available types are:
  110. *
  111. * READ A normal read operation. Device will be plugged.
  112. * READ_SYNC A synchronous read. Device is not plugged, caller can
  113. * immediately wait on this read without caring about
  114. * unplugging.
  115. * READA Used for read-ahead operations. Lower priority, and the
  116. * block layer could (in theory) choose to ignore this
  117. * request if it runs into resource problems.
  118. * WRITE A normal async write. Device will be plugged.
  119. * WRITE_SYNC_PLUG Synchronous write. Identical to WRITE, but passes down
  120. * the hint that someone will be waiting on this IO
  121. * shortly. The device must still be unplugged explicitly,
  122. * WRITE_SYNC_PLUG does not do this as we could be
  123. * submitting more writes before we actually wait on any
  124. * of them.
  125. * WRITE_SYNC Like WRITE_SYNC_PLUG, but also unplugs the device
  126. * immediately after submission. The write equivalent
  127. * of READ_SYNC.
  128. * WRITE_ODIRECT_PLUG Special case write for O_DIRECT only.
  129. * WRITE_FLUSH Like WRITE_SYNC but with preceding cache flush.
  130. * WRITE_FUA Like WRITE_SYNC but data is guaranteed to be on
  131. * non-volatile media on completion.
  132. * WRITE_FLUSH_FUA Combination of WRITE_FLUSH and FUA. The IO is preceded
  133. * by a cache flush and data is guaranteed to be on
  134. * non-volatile media on completion.
  135. *
  136. */
  137. #define RW_MASK REQ_WRITE
  138. #define RWA_MASK REQ_RAHEAD
  139. #define READ 0
  140. #define WRITE RW_MASK
  141. #define READA RWA_MASK
  142. #define READ_SYNC (READ | REQ_SYNC | REQ_UNPLUG)
  143. #define READ_META (READ | REQ_META)
  144. #define WRITE_SYNC_PLUG (WRITE | REQ_SYNC | REQ_NOIDLE)
  145. #define WRITE_SYNC (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_UNPLUG)
  146. #define WRITE_ODIRECT_PLUG (WRITE | REQ_SYNC)
  147. #define WRITE_META (WRITE | REQ_META)
  148. #define WRITE_FLUSH (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_UNPLUG | \
  149. REQ_FLUSH)
  150. #define WRITE_FUA (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_UNPLUG | \
  151. REQ_FUA)
  152. #define WRITE_FLUSH_FUA (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_UNPLUG | \
  153. REQ_FLUSH | REQ_FUA)
  154. #define SEL_IN 1
  155. #define SEL_OUT 2
  156. #define SEL_EX 4
  157. /* public flags for file_system_type */
  158. #define FS_REQUIRES_DEV 1
  159. #define FS_BINARY_MOUNTDATA 2
  160. #define FS_HAS_SUBTYPE 4
  161. #define FS_REVAL_DOT 16384 /* Check the paths ".", ".." for staleness */
  162. #define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move()
  163. * during rename() internally.
  164. */
  165. /*
  166. * These are the fs-independent mount-flags: up to 32 flags are supported
  167. */
  168. #define MS_RDONLY 1 /* Mount read-only */
  169. #define MS_NOSUID 2 /* Ignore suid and sgid bits */
  170. #define MS_NODEV 4 /* Disallow access to device special files */
  171. #define MS_NOEXEC 8 /* Disallow program execution */
  172. #define MS_SYNCHRONOUS 16 /* Writes are synced at once */
  173. #define MS_REMOUNT 32 /* Alter flags of a mounted FS */
  174. #define MS_MANDLOCK 64 /* Allow mandatory locks on an FS */
  175. #define MS_DIRSYNC 128 /* Directory modifications are synchronous */
  176. #define MS_NOATIME 1024 /* Do not update access times. */
  177. #define MS_NODIRATIME 2048 /* Do not update directory access times */
  178. #define MS_BIND 4096
  179. #define MS_MOVE 8192
  180. #define MS_REC 16384
  181. #define MS_VERBOSE 32768 /* War is peace. Verbosity is silence.
  182. MS_VERBOSE is deprecated. */
  183. #define MS_SILENT 32768
  184. #define MS_POSIXACL (1<<16) /* VFS does not apply the umask */
  185. #define MS_UNBINDABLE (1<<17) /* change to unbindable */
  186. #define MS_PRIVATE (1<<18) /* change to private */
  187. #define MS_SLAVE (1<<19) /* change to slave */
  188. #define MS_SHARED (1<<20) /* change to shared */
  189. #define MS_RELATIME (1<<21) /* Update atime relative to mtime/ctime. */
  190. #define MS_KERNMOUNT (1<<22) /* this is a kern_mount call */
  191. #define MS_I_VERSION (1<<23) /* Update inode I_version field */
  192. #define MS_STRICTATIME (1<<24) /* Always perform atime updates */
  193. #define MS_BORN (1<<29)
  194. #define MS_ACTIVE (1<<30)
  195. #define MS_NOUSER (1<<31)
  196. /*
  197. * Superblock flags that can be altered by MS_REMOUNT
  198. */
  199. #define MS_RMT_MASK (MS_RDONLY|MS_SYNCHRONOUS|MS_MANDLOCK|MS_I_VERSION)
  200. /*
  201. * Old magic mount flag and mask
  202. */
  203. #define MS_MGC_VAL 0xC0ED0000
  204. #define MS_MGC_MSK 0xffff0000
  205. /* Inode flags - they have nothing to superblock flags now */
  206. #define S_SYNC 1 /* Writes are synced at once */
  207. #define S_NOATIME 2 /* Do not update access times */
  208. #define S_APPEND 4 /* Append-only file */
  209. #define S_IMMUTABLE 8 /* Immutable file */
  210. #define S_DEAD 16 /* removed, but still open directory */
  211. #define S_NOQUOTA 32 /* Inode is not counted to quota */
  212. #define S_DIRSYNC 64 /* Directory modifications are synchronous */
  213. #define S_NOCMTIME 128 /* Do not update file c/mtime */
  214. #define S_SWAPFILE 256 /* Do not truncate: swapon got its bmaps */
  215. #define S_PRIVATE 512 /* Inode is fs-internal */
  216. #define S_IMA 1024 /* Inode has an associated IMA struct */
  217. /*
  218. * Note that nosuid etc flags are inode-specific: setting some file-system
  219. * flags just means all the inodes inherit those flags by default. It might be
  220. * possible to override it selectively if you really wanted to with some
  221. * ioctl() that is not currently implemented.
  222. *
  223. * Exception: MS_RDONLY is always applied to the entire file system.
  224. *
  225. * Unfortunately, it is possible to change a filesystems flags with it mounted
  226. * with files in use. This means that all of the inodes will not have their
  227. * i_flags updated. Hence, i_flags no longer inherit the superblock mount
  228. * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org
  229. */
  230. #define __IS_FLG(inode,flg) ((inode)->i_sb->s_flags & (flg))
  231. #define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY)
  232. #define IS_SYNC(inode) (__IS_FLG(inode, MS_SYNCHRONOUS) || \
  233. ((inode)->i_flags & S_SYNC))
  234. #define IS_DIRSYNC(inode) (__IS_FLG(inode, MS_SYNCHRONOUS|MS_DIRSYNC) || \
  235. ((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
  236. #define IS_MANDLOCK(inode) __IS_FLG(inode, MS_MANDLOCK)
  237. #define IS_NOATIME(inode) __IS_FLG(inode, MS_RDONLY|MS_NOATIME)
  238. #define IS_I_VERSION(inode) __IS_FLG(inode, MS_I_VERSION)
  239. #define IS_NOQUOTA(inode) ((inode)->i_flags & S_NOQUOTA)
  240. #define IS_APPEND(inode) ((inode)->i_flags & S_APPEND)
  241. #define IS_IMMUTABLE(inode) ((inode)->i_flags & S_IMMUTABLE)
  242. #define IS_POSIXACL(inode) __IS_FLG(inode, MS_POSIXACL)
  243. #define IS_DEADDIR(inode) ((inode)->i_flags & S_DEAD)
  244. #define IS_NOCMTIME(inode) ((inode)->i_flags & S_NOCMTIME)
  245. #define IS_SWAPFILE(inode) ((inode)->i_flags & S_SWAPFILE)
  246. #define IS_PRIVATE(inode) ((inode)->i_flags & S_PRIVATE)
  247. #define IS_IMA(inode) ((inode)->i_flags & S_IMA)
  248. /* the read-only stuff doesn't really belong here, but any other place is
  249. probably as bad and I don't want to create yet another include file. */
  250. #define BLKROSET _IO(0x12,93) /* set device read-only (0 = read-write) */
  251. #define BLKROGET _IO(0x12,94) /* get read-only status (0 = read_write) */
  252. #define BLKRRPART _IO(0x12,95) /* re-read partition table */
  253. #define BLKGETSIZE _IO(0x12,96) /* return device size /512 (long *arg) */
  254. #define BLKFLSBUF _IO(0x12,97) /* flush buffer cache */
  255. #define BLKRASET _IO(0x12,98) /* set read ahead for block device */
  256. #define BLKRAGET _IO(0x12,99) /* get current read ahead setting */
  257. #define BLKFRASET _IO(0x12,100)/* set filesystem (mm/filemap.c) read-ahead */
  258. #define BLKFRAGET _IO(0x12,101)/* get filesystem (mm/filemap.c) read-ahead */
  259. #define BLKSECTSET _IO(0x12,102)/* set max sectors per request (ll_rw_blk.c) */
  260. #define BLKSECTGET _IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */
  261. #define BLKSSZGET _IO(0x12,104)/* get block device sector size */
  262. #if 0
  263. #define BLKPG _IO(0x12,105)/* See blkpg.h */
  264. /* Some people are morons. Do not use sizeof! */
  265. #define BLKELVGET _IOR(0x12,106,size_t)/* elevator get */
  266. #define BLKELVSET _IOW(0x12,107,size_t)/* elevator set */
  267. /* This was here just to show that the number is taken -
  268. probably all these _IO(0x12,*) ioctls should be moved to blkpg.h. */
  269. #endif
  270. /* A jump here: 108-111 have been used for various private purposes. */
  271. #define BLKBSZGET _IOR(0x12,112,size_t)
  272. #define BLKBSZSET _IOW(0x12,113,size_t)
  273. #define BLKGETSIZE64 _IOR(0x12,114,size_t) /* return device size in bytes (u64 *arg) */
  274. #define BLKTRACESETUP _IOWR(0x12,115,struct blk_user_trace_setup)
  275. #define BLKTRACESTART _IO(0x12,116)
  276. #define BLKTRACESTOP _IO(0x12,117)
  277. #define BLKTRACETEARDOWN _IO(0x12,118)
  278. #define BLKDISCARD _IO(0x12,119)
  279. #define BLKIOMIN _IO(0x12,120)
  280. #define BLKIOOPT _IO(0x12,121)
  281. #define BLKALIGNOFF _IO(0x12,122)
  282. #define BLKPBSZGET _IO(0x12,123)
  283. #define BLKDISCARDZEROES _IO(0x12,124)
  284. #define BLKSECDISCARD _IO(0x12,125)
  285. #define BMAP_IOCTL 1 /* obsolete - kept for compatibility */
  286. #define FIBMAP _IO(0x00,1) /* bmap access */
  287. #define FIGETBSZ _IO(0x00,2) /* get the block size used for bmap */
  288. #define FIFREEZE _IOWR('X', 119, int) /* Freeze */
  289. #define FITHAW _IOWR('X', 120, int) /* Thaw */
  290. #define FITRIM _IOWR('X', 121, struct fstrim_range) /* Trim */
  291. #define FS_IOC_GETFLAGS _IOR('f', 1, long)
  292. #define FS_IOC_SETFLAGS _IOW('f', 2, long)
  293. #define FS_IOC_GETVERSION _IOR('v', 1, long)
  294. #define FS_IOC_SETVERSION _IOW('v', 2, long)
  295. #define FS_IOC_FIEMAP _IOWR('f', 11, struct fiemap)
  296. #define FS_IOC32_GETFLAGS _IOR('f', 1, int)
  297. #define FS_IOC32_SETFLAGS _IOW('f', 2, int)
  298. #define FS_IOC32_GETVERSION _IOR('v', 1, int)
  299. #define FS_IOC32_SETVERSION _IOW('v', 2, int)
  300. /*
  301. * Inode flags (FS_IOC_GETFLAGS / FS_IOC_SETFLAGS)
  302. */
  303. #define FS_SECRM_FL 0x00000001 /* Secure deletion */
  304. #define FS_UNRM_FL 0x00000002 /* Undelete */
  305. #define FS_COMPR_FL 0x00000004 /* Compress file */
  306. #define FS_SYNC_FL 0x00000008 /* Synchronous updates */
  307. #define FS_IMMUTABLE_FL 0x00000010 /* Immutable file */
  308. #define FS_APPEND_FL 0x00000020 /* writes to file may only append */
  309. #define FS_NODUMP_FL 0x00000040 /* do not dump file */
  310. #define FS_NOATIME_FL 0x00000080 /* do not update atime */
  311. /* Reserved for compression usage... */
  312. #define FS_DIRTY_FL 0x00000100
  313. #define FS_COMPRBLK_FL 0x00000200 /* One or more compressed clusters */
  314. #define FS_NOCOMP_FL 0x00000400 /* Don't compress */
  315. #define FS_ECOMPR_FL 0x00000800 /* Compression error */
  316. /* End compression flags --- maybe not all used */
  317. #define FS_BTREE_FL 0x00001000 /* btree format dir */
  318. #define FS_INDEX_FL 0x00001000 /* hash-indexed directory */
  319. #define FS_IMAGIC_FL 0x00002000 /* AFS directory */
  320. #define FS_JOURNAL_DATA_FL 0x00004000 /* Reserved for ext3 */
  321. #define FS_NOTAIL_FL 0x00008000 /* file tail should not be merged */
  322. #define FS_DIRSYNC_FL 0x00010000 /* dirsync behaviour (directories only) */
  323. #define FS_TOPDIR_FL 0x00020000 /* Top of directory hierarchies*/
  324. #define FS_EXTENT_FL 0x00080000 /* Extents */
  325. #define FS_DIRECTIO_FL 0x00100000 /* Use direct i/o */
  326. #define FS_RESERVED_FL 0x80000000 /* reserved for ext2 lib */
  327. #define FS_FL_USER_VISIBLE 0x0003DFFF /* User visible flags */
  328. #define FS_FL_USER_MODIFIABLE 0x000380FF /* User modifiable flags */
  329. #define SYNC_FILE_RANGE_WAIT_BEFORE 1
  330. #define SYNC_FILE_RANGE_WRITE 2
  331. #define SYNC_FILE_RANGE_WAIT_AFTER 4
  332. #ifdef __KERNEL__
  333. #include <linux/linkage.h>
  334. #include <linux/wait.h>
  335. #include <linux/types.h>
  336. #include <linux/kdev_t.h>
  337. #include <linux/dcache.h>
  338. #include <linux/path.h>
  339. #include <linux/stat.h>
  340. #include <linux/cache.h>
  341. #include <linux/list.h>
  342. #include <linux/radix-tree.h>
  343. #include <linux/prio_tree.h>
  344. #include <linux/init.h>
  345. #include <linux/pid.h>
  346. #include <linux/mutex.h>
  347. #include <linux/capability.h>
  348. #include <linux/semaphore.h>
  349. #include <linux/fiemap.h>
  350. #include <linux/rculist_bl.h>
  351. #include <asm/atomic.h>
  352. #include <asm/byteorder.h>
  353. struct export_operations;
  354. struct hd_geometry;
  355. struct iovec;
  356. struct nameidata;
  357. struct kiocb;
  358. struct kobject;
  359. struct pipe_inode_info;
  360. struct poll_table_struct;
  361. struct kstatfs;
  362. struct vm_area_struct;
  363. struct vfsmount;
  364. struct cred;
  365. extern void __init inode_init(void);
  366. extern void __init inode_init_early(void);
  367. extern void __init files_init(unsigned long);
  368. extern struct files_stat_struct files_stat;
  369. extern unsigned long get_max_files(void);
  370. extern int sysctl_nr_open;
  371. extern struct inodes_stat_t inodes_stat;
  372. extern int leases_enable, lease_break_time;
  373. struct buffer_head;
  374. typedef int (get_block_t)(struct inode *inode, sector_t iblock,
  375. struct buffer_head *bh_result, int create);
  376. typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
  377. ssize_t bytes, void *private, int ret,
  378. bool is_async);
  379. /*
  380. * Attribute flags. These should be or-ed together to figure out what
  381. * has been changed!
  382. */
  383. #define ATTR_MODE (1 << 0)
  384. #define ATTR_UID (1 << 1)
  385. #define ATTR_GID (1 << 2)
  386. #define ATTR_SIZE (1 << 3)
  387. #define ATTR_ATIME (1 << 4)
  388. #define ATTR_MTIME (1 << 5)
  389. #define ATTR_CTIME (1 << 6)
  390. #define ATTR_ATIME_SET (1 << 7)
  391. #define ATTR_MTIME_SET (1 << 8)
  392. #define ATTR_FORCE (1 << 9) /* Not a change, but a change it */
  393. #define ATTR_ATTR_FLAG (1 << 10)
  394. #define ATTR_KILL_SUID (1 << 11)
  395. #define ATTR_KILL_SGID (1 << 12)
  396. #define ATTR_FILE (1 << 13)
  397. #define ATTR_KILL_PRIV (1 << 14)
  398. #define ATTR_OPEN (1 << 15) /* Truncating from open(O_TRUNC) */
  399. #define ATTR_TIMES_SET (1 << 16)
  400. /*
  401. * This is the Inode Attributes structure, used for notify_change(). It
  402. * uses the above definitions as flags, to know which values have changed.
  403. * Also, in this manner, a Filesystem can look at only the values it cares
  404. * about. Basically, these are the attributes that the VFS layer can
  405. * request to change from the FS layer.
  406. *
  407. * Derek Atkins <warlord@MIT.EDU> 94-10-20
  408. */
  409. struct iattr {
  410. unsigned int ia_valid;
  411. umode_t ia_mode;
  412. uid_t ia_uid;
  413. gid_t ia_gid;
  414. loff_t ia_size;
  415. struct timespec ia_atime;
  416. struct timespec ia_mtime;
  417. struct timespec ia_ctime;
  418. /*
  419. * Not an attribute, but an auxilary info for filesystems wanting to
  420. * implement an ftruncate() like method. NOTE: filesystem should
  421. * check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL).
  422. */
  423. struct file *ia_file;
  424. };
  425. /*
  426. * Includes for diskquotas.
  427. */
  428. #include <linux/quota.h>
  429. /**
  430. * enum positive_aop_returns - aop return codes with specific semantics
  431. *
  432. * @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has
  433. * completed, that the page is still locked, and
  434. * should be considered active. The VM uses this hint
  435. * to return the page to the active list -- it won't
  436. * be a candidate for writeback again in the near
  437. * future. Other callers must be careful to unlock
  438. * the page if they get this return. Returned by
  439. * writepage();
  440. *
  441. * @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has
  442. * unlocked it and the page might have been truncated.
  443. * The caller should back up to acquiring a new page and
  444. * trying again. The aop will be taking reasonable
  445. * precautions not to livelock. If the caller held a page
  446. * reference, it should drop it before retrying. Returned
  447. * by readpage().
  448. *
  449. * address_space_operation functions return these large constants to indicate
  450. * special semantics to the caller. These are much larger than the bytes in a
  451. * page to allow for functions that return the number of bytes operated on in a
  452. * given page.
  453. */
  454. enum positive_aop_returns {
  455. AOP_WRITEPAGE_ACTIVATE = 0x80000,
  456. AOP_TRUNCATED_PAGE = 0x80001,
  457. };
  458. #define AOP_FLAG_UNINTERRUPTIBLE 0x0001 /* will not do a short write */
  459. #define AOP_FLAG_CONT_EXPAND 0x0002 /* called from cont_expand */
  460. #define AOP_FLAG_NOFS 0x0004 /* used by filesystem to direct
  461. * helper code (eg buffer layer)
  462. * to clear GFP_FS from alloc */
  463. /*
  464. * oh the beauties of C type declarations.
  465. */
  466. struct page;
  467. struct address_space;
  468. struct writeback_control;
  469. struct iov_iter {
  470. const struct iovec *iov;
  471. unsigned long nr_segs;
  472. size_t iov_offset;
  473. size_t count;
  474. };
  475. size_t iov_iter_copy_from_user_atomic(struct page *page,
  476. struct iov_iter *i, unsigned long offset, size_t bytes);
  477. size_t iov_iter_copy_from_user(struct page *page,
  478. struct iov_iter *i, unsigned long offset, size_t bytes);
  479. void iov_iter_advance(struct iov_iter *i, size_t bytes);
  480. int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes);
  481. size_t iov_iter_single_seg_count(struct iov_iter *i);
  482. static inline void iov_iter_init(struct iov_iter *i,
  483. const struct iovec *iov, unsigned long nr_segs,
  484. size_t count, size_t written)
  485. {
  486. i->iov = iov;
  487. i->nr_segs = nr_segs;
  488. i->iov_offset = 0;
  489. i->count = count + written;
  490. iov_iter_advance(i, written);
  491. }
  492. static inline size_t iov_iter_count(struct iov_iter *i)
  493. {
  494. return i->count;
  495. }
  496. /*
  497. * "descriptor" for what we're up to with a read.
  498. * This allows us to use the same read code yet
  499. * have multiple different users of the data that
  500. * we read from a file.
  501. *
  502. * The simplest case just copies the data to user
  503. * mode.
  504. */
  505. typedef struct {
  506. size_t written;
  507. size_t count;
  508. union {
  509. char __user *buf;
  510. void *data;
  511. } arg;
  512. int error;
  513. } read_descriptor_t;
  514. typedef int (*read_actor_t)(read_descriptor_t *, struct page *,
  515. unsigned long, unsigned long);
  516. struct address_space_operations {
  517. int (*writepage)(struct page *page, struct writeback_control *wbc);
  518. int (*readpage)(struct file *, struct page *);
  519. void (*sync_page)(struct page *);
  520. /* Write back some dirty pages from this mapping. */
  521. int (*writepages)(struct address_space *, struct writeback_control *);
  522. /* Set a page dirty. Return true if this dirtied it */
  523. int (*set_page_dirty)(struct page *page);
  524. int (*readpages)(struct file *filp, struct address_space *mapping,
  525. struct list_head *pages, unsigned nr_pages);
  526. int (*write_begin)(struct file *, struct address_space *mapping,
  527. loff_t pos, unsigned len, unsigned flags,
  528. struct page **pagep, void **fsdata);
  529. int (*write_end)(struct file *, struct address_space *mapping,
  530. loff_t pos, unsigned len, unsigned copied,
  531. struct page *page, void *fsdata);
  532. /* Unfortunately this kludge is needed for FIBMAP. Don't use it */
  533. sector_t (*bmap)(struct address_space *, sector_t);
  534. void (*invalidatepage) (struct page *, unsigned long);
  535. int (*releasepage) (struct page *, gfp_t);
  536. void (*freepage)(struct page *);
  537. ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
  538. loff_t offset, unsigned long nr_segs);
  539. int (*get_xip_mem)(struct address_space *, pgoff_t, int,
  540. void **, unsigned long *);
  541. /* migrate the contents of a page to the specified target */
  542. int (*migratepage) (struct address_space *,
  543. struct page *, struct page *);
  544. int (*launder_page) (struct page *);
  545. int (*is_partially_uptodate) (struct page *, read_descriptor_t *,
  546. unsigned long);
  547. int (*error_remove_page)(struct address_space *, struct page *);
  548. };
  549. /*
  550. * pagecache_write_begin/pagecache_write_end must be used by general code
  551. * to write into the pagecache.
  552. */
  553. int pagecache_write_begin(struct file *, struct address_space *mapping,
  554. loff_t pos, unsigned len, unsigned flags,
  555. struct page **pagep, void **fsdata);
  556. int pagecache_write_end(struct file *, struct address_space *mapping,
  557. loff_t pos, unsigned len, unsigned copied,
  558. struct page *page, void *fsdata);
  559. struct backing_dev_info;
  560. struct address_space {
  561. struct inode *host; /* owner: inode, block_device */
  562. struct radix_tree_root page_tree; /* radix tree of all pages */
  563. spinlock_t tree_lock; /* and lock protecting it */
  564. unsigned int i_mmap_writable;/* count VM_SHARED mappings */
  565. struct prio_tree_root i_mmap; /* tree of private and shared mappings */
  566. struct list_head i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
  567. spinlock_t i_mmap_lock; /* protect tree, count, list */
  568. unsigned int truncate_count; /* Cover race condition with truncate */
  569. unsigned long nrpages; /* number of total pages */
  570. pgoff_t writeback_index;/* writeback starts here */
  571. const struct address_space_operations *a_ops; /* methods */
  572. unsigned long flags; /* error bits/gfp mask */
  573. struct backing_dev_info *backing_dev_info; /* device readahead, etc */
  574. spinlock_t private_lock; /* for use by the address_space */
  575. struct list_head private_list; /* ditto */
  576. struct address_space *assoc_mapping; /* ditto */
  577. } __attribute__((aligned(sizeof(long))));
  578. /*
  579. * On most architectures that alignment is already the case; but
  580. * must be enforced here for CRIS, to let the least signficant bit
  581. * of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
  582. */
  583. struct block_device {
  584. dev_t bd_dev; /* not a kdev_t - it's a search key */
  585. struct inode * bd_inode; /* will die */
  586. struct super_block * bd_super;
  587. int bd_openers;
  588. struct mutex bd_mutex; /* open/close mutex */
  589. struct list_head bd_inodes;
  590. void * bd_claiming;
  591. void * bd_holder;
  592. int bd_holders;
  593. bool bd_write_holder;
  594. #ifdef CONFIG_SYSFS
  595. struct gendisk * bd_holder_disk; /* for sysfs slave linkng */
  596. #endif
  597. struct block_device * bd_contains;
  598. unsigned bd_block_size;
  599. struct hd_struct * bd_part;
  600. /* number of times partitions within this device have been opened. */
  601. unsigned bd_part_count;
  602. int bd_invalidated;
  603. struct gendisk * bd_disk;
  604. struct list_head bd_list;
  605. /*
  606. * Private data. You must have bd_claim'ed the block_device
  607. * to use this. NOTE: bd_claim allows an owner to claim
  608. * the same device multiple times, the owner must take special
  609. * care to not mess up bd_private for that case.
  610. */
  611. unsigned long bd_private;
  612. /* The counter of freeze processes */
  613. int bd_fsfreeze_count;
  614. /* Mutex for freeze */
  615. struct mutex bd_fsfreeze_mutex;
  616. };
  617. /*
  618. * Radix-tree tags, for tagging dirty and writeback pages within the pagecache
  619. * radix trees
  620. */
  621. #define PAGECACHE_TAG_DIRTY 0
  622. #define PAGECACHE_TAG_WRITEBACK 1
  623. #define PAGECACHE_TAG_TOWRITE 2
  624. int mapping_tagged(struct address_space *mapping, int tag);
  625. /*
  626. * Might pages of this file be mapped into userspace?
  627. */
  628. static inline int mapping_mapped(struct address_space *mapping)
  629. {
  630. return !prio_tree_empty(&mapping->i_mmap) ||
  631. !list_empty(&mapping->i_mmap_nonlinear);
  632. }
  633. /*
  634. * Might pages of this file have been modified in userspace?
  635. * Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap_pgoff
  636. * marks vma as VM_SHARED if it is shared, and the file was opened for
  637. * writing i.e. vma may be mprotected writable even if now readonly.
  638. */
  639. static inline int mapping_writably_mapped(struct address_space *mapping)
  640. {
  641. return mapping->i_mmap_writable != 0;
  642. }
  643. /*
  644. * Use sequence counter to get consistent i_size on 32-bit processors.
  645. */
  646. #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
  647. #include <linux/seqlock.h>
  648. #define __NEED_I_SIZE_ORDERED
  649. #define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
  650. #else
  651. #define i_size_ordered_init(inode) do { } while (0)
  652. #endif
  653. struct posix_acl;
  654. #define ACL_NOT_CACHED ((void *)(-1))
  655. struct inode {
  656. /* RCU path lookup touches following: */
  657. umode_t i_mode;
  658. uid_t i_uid;
  659. gid_t i_gid;
  660. const struct inode_operations *i_op;
  661. struct super_block *i_sb;
  662. spinlock_t i_lock; /* i_blocks, i_bytes, maybe i_size */
  663. unsigned int i_flags;
  664. struct mutex i_mutex;
  665. unsigned long i_state;
  666. unsigned long dirtied_when; /* jiffies of first dirtying */
  667. struct hlist_node i_hash;
  668. struct list_head i_wb_list; /* backing dev IO list */
  669. struct list_head i_lru; /* inode LRU list */
  670. struct list_head i_sb_list;
  671. union {
  672. struct list_head i_dentry;
  673. struct rcu_head i_rcu;
  674. };
  675. unsigned long i_ino;
  676. atomic_t i_count;
  677. unsigned int i_nlink;
  678. dev_t i_rdev;
  679. unsigned int i_blkbits;
  680. u64 i_version;
  681. loff_t i_size;
  682. #ifdef __NEED_I_SIZE_ORDERED
  683. seqcount_t i_size_seqcount;
  684. #endif
  685. struct timespec i_atime;
  686. struct timespec i_mtime;
  687. struct timespec i_ctime;
  688. blkcnt_t i_blocks;
  689. unsigned short i_bytes;
  690. struct rw_semaphore i_alloc_sem;
  691. const struct file_operations *i_fop; /* former ->i_op->default_file_ops */
  692. struct file_lock *i_flock;
  693. struct address_space *i_mapping;
  694. struct address_space i_data;
  695. #ifdef CONFIG_QUOTA
  696. struct dquot *i_dquot[MAXQUOTAS];
  697. #endif
  698. struct list_head i_devices;
  699. union {
  700. struct pipe_inode_info *i_pipe;
  701. struct block_device *i_bdev;
  702. struct cdev *i_cdev;
  703. };
  704. __u32 i_generation;
  705. #ifdef CONFIG_FSNOTIFY
  706. __u32 i_fsnotify_mask; /* all events this inode cares about */
  707. struct hlist_head i_fsnotify_marks;
  708. #endif
  709. #ifdef CONFIG_IMA
  710. /* protected by i_lock */
  711. unsigned int i_readcount; /* struct files open RO */
  712. #endif
  713. atomic_t i_writecount;
  714. #ifdef CONFIG_SECURITY
  715. void *i_security;
  716. #endif
  717. #ifdef CONFIG_FS_POSIX_ACL
  718. struct posix_acl *i_acl;
  719. struct posix_acl *i_default_acl;
  720. #endif
  721. void *i_private; /* fs or device private pointer */
  722. };
  723. static inline int inode_unhashed(struct inode *inode)
  724. {
  725. return hlist_unhashed(&inode->i_hash);
  726. }
  727. /*
  728. * inode->i_mutex nesting subclasses for the lock validator:
  729. *
  730. * 0: the object of the current VFS operation
  731. * 1: parent
  732. * 2: child/target
  733. * 3: quota file
  734. *
  735. * The locking order between these classes is
  736. * parent -> child -> normal -> xattr -> quota
  737. */
  738. enum inode_i_mutex_lock_class
  739. {
  740. I_MUTEX_NORMAL,
  741. I_MUTEX_PARENT,
  742. I_MUTEX_CHILD,
  743. I_MUTEX_XATTR,
  744. I_MUTEX_QUOTA
  745. };
  746. /*
  747. * NOTE: in a 32bit arch with a preemptable kernel and
  748. * an UP compile the i_size_read/write must be atomic
  749. * with respect to the local cpu (unlike with preempt disabled),
  750. * but they don't need to be atomic with respect to other cpus like in
  751. * true SMP (so they need either to either locally disable irq around
  752. * the read or for example on x86 they can be still implemented as a
  753. * cmpxchg8b without the need of the lock prefix). For SMP compiles
  754. * and 64bit archs it makes no difference if preempt is enabled or not.
  755. */
  756. static inline loff_t i_size_read(const struct inode *inode)
  757. {
  758. #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
  759. loff_t i_size;
  760. unsigned int seq;
  761. do {
  762. seq = read_seqcount_begin(&inode->i_size_seqcount);
  763. i_size = inode->i_size;
  764. } while (read_seqcount_retry(&inode->i_size_seqcount, seq));
  765. return i_size;
  766. #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
  767. loff_t i_size;
  768. preempt_disable();
  769. i_size = inode->i_size;
  770. preempt_enable();
  771. return i_size;
  772. #else
  773. return inode->i_size;
  774. #endif
  775. }
  776. /*
  777. * NOTE: unlike i_size_read(), i_size_write() does need locking around it
  778. * (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount
  779. * can be lost, resulting in subsequent i_size_read() calls spinning forever.
  780. */
  781. static inline void i_size_write(struct inode *inode, loff_t i_size)
  782. {
  783. #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
  784. write_seqcount_begin(&inode->i_size_seqcount);
  785. inode->i_size = i_size;
  786. write_seqcount_end(&inode->i_size_seqcount);
  787. #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
  788. preempt_disable();
  789. inode->i_size = i_size;
  790. preempt_enable();
  791. #else
  792. inode->i_size = i_size;
  793. #endif
  794. }
  795. static inline unsigned iminor(const struct inode *inode)
  796. {
  797. return MINOR(inode->i_rdev);
  798. }
  799. static inline unsigned imajor(const struct inode *inode)
  800. {
  801. return MAJOR(inode->i_rdev);
  802. }
  803. extern struct block_device *I_BDEV(struct inode *inode);
  804. struct fown_struct {
  805. rwlock_t lock; /* protects pid, uid, euid fields */
  806. struct pid *pid; /* pid or -pgrp where SIGIO should be sent */
  807. enum pid_type pid_type; /* Kind of process group SIGIO should be sent to */
  808. uid_t uid, euid; /* uid/euid of process setting the owner */
  809. int signum; /* posix.1b rt signal to be delivered on IO */
  810. };
  811. /*
  812. * Track a single file's readahead state
  813. */
  814. struct file_ra_state {
  815. pgoff_t start; /* where readahead started */
  816. unsigned int size; /* # of readahead pages */
  817. unsigned int async_size; /* do asynchronous readahead when
  818. there are only # of pages ahead */
  819. unsigned int ra_pages; /* Maximum readahead window */
  820. unsigned int mmap_miss; /* Cache miss stat for mmap accesses */
  821. loff_t prev_pos; /* Cache last read() position */
  822. };
  823. /*
  824. * Check if @index falls in the readahead windows.
  825. */
  826. static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
  827. {
  828. return (index >= ra->start &&
  829. index < ra->start + ra->size);
  830. }
  831. #define FILE_MNT_WRITE_TAKEN 1
  832. #define FILE_MNT_WRITE_RELEASED 2
  833. struct file {
  834. /*
  835. * fu_list becomes invalid after file_free is called and queued via
  836. * fu_rcuhead for RCU freeing
  837. */
  838. union {
  839. struct list_head fu_list;
  840. struct rcu_head fu_rcuhead;
  841. } f_u;
  842. struct path f_path;
  843. #define f_dentry f_path.dentry
  844. #define f_vfsmnt f_path.mnt
  845. const struct file_operations *f_op;
  846. spinlock_t f_lock; /* f_ep_links, f_flags, no IRQ */
  847. #ifdef CONFIG_SMP
  848. int f_sb_list_cpu;
  849. #endif
  850. atomic_long_t f_count;
  851. unsigned int f_flags;
  852. fmode_t f_mode;
  853. loff_t f_pos;
  854. struct fown_struct f_owner;
  855. const struct cred *f_cred;
  856. struct file_ra_state f_ra;
  857. u64 f_version;
  858. #ifdef CONFIG_SECURITY
  859. void *f_security;
  860. #endif
  861. /* needed for tty driver, and maybe others */
  862. void *private_data;
  863. #ifdef CONFIG_EPOLL
  864. /* Used by fs/eventpoll.c to link all the hooks to this file */
  865. struct list_head f_ep_links;
  866. #endif /* #ifdef CONFIG_EPOLL */
  867. struct address_space *f_mapping;
  868. #ifdef CONFIG_DEBUG_WRITECOUNT
  869. unsigned long f_mnt_write_state;
  870. #endif
  871. };
  872. #define get_file(x) atomic_long_inc(&(x)->f_count)
  873. #define fput_atomic(x) atomic_long_add_unless(&(x)->f_count, -1, 1)
  874. #define file_count(x) atomic_long_read(&(x)->f_count)
  875. #ifdef CONFIG_DEBUG_WRITECOUNT
  876. static inline void file_take_write(struct file *f)
  877. {
  878. WARN_ON(f->f_mnt_write_state != 0);
  879. f->f_mnt_write_state = FILE_MNT_WRITE_TAKEN;
  880. }
  881. static inline void file_release_write(struct file *f)
  882. {
  883. f->f_mnt_write_state |= FILE_MNT_WRITE_RELEASED;
  884. }
  885. static inline void file_reset_write(struct file *f)
  886. {
  887. f->f_mnt_write_state = 0;
  888. }
  889. static inline void file_check_state(struct file *f)
  890. {
  891. /*
  892. * At this point, either both or neither of these bits
  893. * should be set.
  894. */
  895. WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN);
  896. WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_RELEASED);
  897. }
  898. static inline int file_check_writeable(struct file *f)
  899. {
  900. if (f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN)
  901. return 0;
  902. printk(KERN_WARNING "writeable file with no "
  903. "mnt_want_write()\n");
  904. WARN_ON(1);
  905. return -EINVAL;
  906. }
  907. #else /* !CONFIG_DEBUG_WRITECOUNT */
  908. static inline void file_take_write(struct file *filp) {}
  909. static inline void file_release_write(struct file *filp) {}
  910. static inline void file_reset_write(struct file *filp) {}
  911. static inline void file_check_state(struct file *filp) {}
  912. static inline int file_check_writeable(struct file *filp)
  913. {
  914. return 0;
  915. }
  916. #endif /* CONFIG_DEBUG_WRITECOUNT */
  917. #define MAX_NON_LFS ((1UL<<31) - 1)
  918. /* Page cache limit. The filesystems should put that into their s_maxbytes
  919. limits, otherwise bad things can happen in VM. */
  920. #if BITS_PER_LONG==32
  921. #define MAX_LFS_FILESIZE (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
  922. #elif BITS_PER_LONG==64
  923. #define MAX_LFS_FILESIZE 0x7fffffffffffffffUL
  924. #endif
  925. #define FL_POSIX 1
  926. #define FL_FLOCK 2
  927. #define FL_ACCESS 8 /* not trying to lock, just looking */
  928. #define FL_EXISTS 16 /* when unlocking, test for existence */
  929. #define FL_LEASE 32 /* lease held on this file */
  930. #define FL_CLOSE 64 /* unlock on close */
  931. #define FL_SLEEP 128 /* A blocking lock */
  932. /*
  933. * Special return value from posix_lock_file() and vfs_lock_file() for
  934. * asynchronous locking.
  935. */
  936. #define FILE_LOCK_DEFERRED 1
  937. /*
  938. * The POSIX file lock owner is determined by
  939. * the "struct files_struct" in the thread group
  940. * (or NULL for no owner - BSD locks).
  941. *
  942. * Lockd stuffs a "host" pointer into this.
  943. */
  944. typedef struct files_struct *fl_owner_t;
  945. struct file_lock_operations {
  946. void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
  947. void (*fl_release_private)(struct file_lock *);
  948. };
  949. struct lock_manager_operations {
  950. int (*fl_compare_owner)(struct file_lock *, struct file_lock *);
  951. void (*fl_notify)(struct file_lock *); /* unblock callback */
  952. int (*fl_grant)(struct file_lock *, struct file_lock *, int);
  953. void (*fl_release_private)(struct file_lock *);
  954. void (*fl_break)(struct file_lock *);
  955. int (*fl_change)(struct file_lock **, int);
  956. };
  957. struct lock_manager {
  958. struct list_head list;
  959. };
  960. void locks_start_grace(struct lock_manager *);
  961. void locks_end_grace(struct lock_manager *);
  962. int locks_in_grace(void);
  963. /* that will die - we need it for nfs_lock_info */
  964. #include <linux/nfs_fs_i.h>
  965. struct file_lock {
  966. struct file_lock *fl_next; /* singly linked list for this inode */
  967. struct list_head fl_link; /* doubly linked list of all locks */
  968. struct list_head fl_block; /* circular list of blocked processes */
  969. fl_owner_t fl_owner;
  970. unsigned char fl_flags;
  971. unsigned char fl_type;
  972. unsigned int fl_pid;
  973. struct pid *fl_nspid;
  974. wait_queue_head_t fl_wait;
  975. struct file *fl_file;
  976. loff_t fl_start;
  977. loff_t fl_end;
  978. struct fasync_struct * fl_fasync; /* for lease break notifications */
  979. unsigned long fl_break_time; /* for nonblocking lease breaks */
  980. const struct file_lock_operations *fl_ops; /* Callbacks for filesystems */
  981. const struct lock_manager_operations *fl_lmops; /* Callbacks for lockmanagers */
  982. union {
  983. struct nfs_lock_info nfs_fl;
  984. struct nfs4_lock_info nfs4_fl;
  985. struct {
  986. struct list_head link; /* link in AFS vnode's pending_locks list */
  987. int state; /* state of grant or error if -ve */
  988. } afs;
  989. } fl_u;
  990. };
  991. /* The following constant reflects the upper bound of the file/locking space */
  992. #ifndef OFFSET_MAX
  993. #define INT_LIMIT(x) (~((x)1 << (sizeof(x)*8 - 1)))
  994. #define OFFSET_MAX INT_LIMIT(loff_t)
  995. #define OFFT_OFFSET_MAX INT_LIMIT(off_t)
  996. #endif
  997. #include <linux/fcntl.h>
  998. extern void send_sigio(struct fown_struct *fown, int fd, int band);
  999. #ifdef CONFIG_FILE_LOCKING
  1000. extern int fcntl_getlk(struct file *, struct flock __user *);
  1001. extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
  1002. struct flock __user *);
  1003. #if BITS_PER_LONG == 32
  1004. extern int fcntl_getlk64(struct file *, struct flock64 __user *);
  1005. extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
  1006. struct flock64 __user *);
  1007. #endif
  1008. extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
  1009. extern int fcntl_getlease(struct file *filp);
  1010. /* fs/locks.c */
  1011. void locks_free_lock(struct file_lock *fl);
  1012. extern void locks_init_lock(struct file_lock *);
  1013. extern struct file_lock * locks_alloc_lock(void);
  1014. extern void locks_copy_lock(struct file_lock *, struct file_lock *);
  1015. extern void __locks_copy_lock(struct file_lock *, const struct file_lock *);
  1016. extern void locks_remove_posix(struct file *, fl_owner_t);
  1017. extern void locks_remove_flock(struct file *);
  1018. extern void locks_release_private(struct file_lock *);
  1019. extern void posix_test_lock(struct file *, struct file_lock *);
  1020. extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
  1021. extern int posix_lock_file_wait(struct file *, struct file_lock *);
  1022. extern int posix_unblock_lock(struct file *, struct file_lock *);
  1023. extern int vfs_test_lock(struct file *, struct file_lock *);
  1024. extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
  1025. extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
  1026. extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
  1027. extern int __break_lease(struct inode *inode, unsigned int flags);
  1028. extern void lease_get_mtime(struct inode *, struct timespec *time);
  1029. extern int generic_setlease(struct file *, long, struct file_lock **);
  1030. extern int vfs_setlease(struct file *, long, struct file_lock **);
  1031. extern int lease_modify(struct file_lock **, int);
  1032. extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
  1033. extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
  1034. extern void lock_flocks(void);
  1035. extern void unlock_flocks(void);
  1036. #else /* !CONFIG_FILE_LOCKING */
  1037. static inline int fcntl_getlk(struct file *file, struct flock __user *user)
  1038. {
  1039. return -EINVAL;
  1040. }
  1041. static inline int fcntl_setlk(unsigned int fd, struct file *file,
  1042. unsigned int cmd, struct flock __user *user)
  1043. {
  1044. return -EACCES;
  1045. }
  1046. #if BITS_PER_LONG == 32
  1047. static inline int fcntl_getlk64(struct file *file, struct flock64 __user *user)
  1048. {
  1049. return -EINVAL;
  1050. }
  1051. static inline int fcntl_setlk64(unsigned int fd, struct file *file,
  1052. unsigned int cmd, struct flock64 __user *user)
  1053. {
  1054. return -EACCES;
  1055. }
  1056. #endif
  1057. static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
  1058. {
  1059. return 0;
  1060. }
  1061. static inline int fcntl_getlease(struct file *filp)
  1062. {
  1063. return 0;
  1064. }
  1065. static inline void locks_init_lock(struct file_lock *fl)
  1066. {
  1067. return;
  1068. }
  1069. static inline void __locks_copy_lock(struct file_lock *new, struct file_lock *fl)
  1070. {
  1071. return;
  1072. }
  1073. static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
  1074. {
  1075. return;
  1076. }
  1077. static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
  1078. {
  1079. return;
  1080. }
  1081. static inline void locks_remove_flock(struct file *filp)
  1082. {
  1083. return;
  1084. }
  1085. static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
  1086. {
  1087. return;
  1088. }
  1089. static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
  1090. struct file_lock *conflock)
  1091. {
  1092. return -ENOLCK;
  1093. }
  1094. static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
  1095. {
  1096. return -ENOLCK;
  1097. }
  1098. static inline int posix_unblock_lock(struct file *filp,
  1099. struct file_lock *waiter)
  1100. {
  1101. return -ENOENT;
  1102. }
  1103. static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
  1104. {
  1105. return 0;
  1106. }
  1107. static inline int vfs_lock_file(struct file *filp, unsigned int cmd,
  1108. struct file_lock *fl, struct file_lock *conf)
  1109. {
  1110. return -ENOLCK;
  1111. }
  1112. static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
  1113. {
  1114. return 0;
  1115. }
  1116. static inline int flock_lock_file_wait(struct file *filp,
  1117. struct file_lock *request)
  1118. {
  1119. return -ENOLCK;
  1120. }
  1121. static inline int __break_lease(struct inode *inode, unsigned int mode)
  1122. {
  1123. return 0;
  1124. }
  1125. static inline void lease_get_mtime(struct inode *inode, struct timespec *time)
  1126. {
  1127. return;
  1128. }
  1129. static inline int generic_setlease(struct file *filp, long arg,
  1130. struct file_lock **flp)
  1131. {
  1132. return -EINVAL;
  1133. }
  1134. static inline int vfs_setlease(struct file *filp, long arg,
  1135. struct file_lock **lease)
  1136. {
  1137. return -EINVAL;
  1138. }
  1139. static inline int lease_modify(struct file_lock **before, int arg)
  1140. {
  1141. return -EINVAL;
  1142. }
  1143. static inline int lock_may_read(struct inode *inode, loff_t start,
  1144. unsigned long len)
  1145. {
  1146. return 1;
  1147. }
  1148. static inline int lock_may_write(struct inode *inode, loff_t start,
  1149. unsigned long len)
  1150. {
  1151. return 1;
  1152. }
  1153. static inline void lock_flocks(void)
  1154. {
  1155. }
  1156. static inline void unlock_flocks(void)
  1157. {
  1158. }
  1159. #endif /* !CONFIG_FILE_LOCKING */
  1160. struct fasync_struct {
  1161. spinlock_t fa_lock;
  1162. int magic;
  1163. int fa_fd;
  1164. struct fasync_struct *fa_next; /* singly linked list */
  1165. struct file *fa_file;
  1166. struct rcu_head fa_rcu;
  1167. };
  1168. #define FASYNC_MAGIC 0x4601
  1169. /* SMP safe fasync helpers: */
  1170. extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
  1171. extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *);
  1172. extern int fasync_remove_entry(struct file *, struct fasync_struct **);
  1173. extern struct fasync_struct *fasync_alloc(void);
  1174. extern void fasync_free(struct fasync_struct *);
  1175. /* can be called from interrupts */
  1176. extern void kill_fasync(struct fasync_struct **, int, int);
  1177. extern int __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
  1178. extern int f_setown(struct file *filp, unsigned long arg, int force);
  1179. extern void f_delown(struct file *filp);
  1180. extern pid_t f_getown(struct file *filp);
  1181. extern int send_sigurg(struct fown_struct *fown);
  1182. /*
  1183. * Umount options
  1184. */
  1185. #define MNT_FORCE 0x00000001 /* Attempt to forcibily umount */
  1186. #define MNT_DETACH 0x00000002 /* Just detach from the tree */
  1187. #define MNT_EXPIRE 0x00000004 /* Mark for expiry */
  1188. #define UMOUNT_NOFOLLOW 0x00000008 /* Don't follow symlink on umount */
  1189. #define UMOUNT_UNUSED 0x80000000 /* Flag guaranteed to be unused */
  1190. extern struct list_head super_blocks;
  1191. extern spinlock_t sb_lock;
  1192. struct super_block {
  1193. struct list_head s_list; /* Keep this first */
  1194. dev_t s_dev; /* search index; _not_ kdev_t */
  1195. unsigned char s_dirt;
  1196. unsigned char s_blocksize_bits;
  1197. unsigned long s_blocksize;
  1198. loff_t s_maxbytes; /* Max file size */
  1199. struct file_system_type *s_type;
  1200. const struct super_operations *s_op;
  1201. const struct dquot_operations *dq_op;
  1202. const struct quotactl_ops *s_qcop;
  1203. const struct export_operations *s_export_op;
  1204. unsigned long s_flags;
  1205. unsigned long s_magic;
  1206. struct dentry *s_root;
  1207. struct rw_semaphore s_umount;
  1208. struct mutex s_lock;
  1209. int s_count;
  1210. atomic_t s_active;
  1211. #ifdef CONFIG_SECURITY
  1212. void *s_security;
  1213. #endif
  1214. const struct xattr_handler **s_xattr;
  1215. struct list_head s_inodes; /* all inodes */
  1216. struct hlist_bl_head s_anon; /* anonymous dentries for (nfs) exporting */
  1217. #ifdef CONFIG_SMP
  1218. struct list_head __percpu *s_files;
  1219. #else
  1220. struct list_head s_files;
  1221. #endif
  1222. /* s_dentry_lru, s_nr_dentry_unused protected by dcache.c lru locks */
  1223. struct list_head s_dentry_lru; /* unused dentry lru */
  1224. int s_nr_dentry_unused; /* # of dentry on lru */
  1225. struct block_device *s_bdev;
  1226. struct backing_dev_info *s_bdi;
  1227. struct mtd_info *s_mtd;
  1228. struct list_head s_instances;
  1229. struct quota_info s_dquot; /* Diskquota specific options */
  1230. int s_frozen;
  1231. wait_queue_head_t s_wait_unfrozen;
  1232. char s_id[32]; /* Informational name */
  1233. void *s_fs_info; /* Filesystem private info */
  1234. fmode_t s_mode;
  1235. /* Granularity of c/m/atime in ns.
  1236. Cannot be worse than a second */
  1237. u32 s_time_gran;
  1238. /*
  1239. * The next field is for VFS *only*. No filesystems have any business
  1240. * even looking at it. You had been warned.
  1241. */
  1242. struct mutex s_vfs_rename_mutex; /* Kludge */
  1243. /*
  1244. * Filesystem subtype. If non-empty the filesystem type field
  1245. * in /proc/mounts will be "type.subtype"
  1246. */
  1247. char *s_subtype;
  1248. /*
  1249. * Saved mount options for lazy filesystems using
  1250. * generic_show_options()
  1251. */
  1252. char __rcu *s_options;
  1253. const struct dentry_operations *s_d_op; /* default d_op for dentries */
  1254. };
  1255. extern struct timespec current_fs_time(struct super_block *sb);
  1256. /*
  1257. * Snapshotting support.
  1258. */
  1259. enum {
  1260. SB_UNFROZEN = 0,
  1261. SB_FREEZE_WRITE = 1,
  1262. SB_FREEZE_TRANS = 2,
  1263. };
  1264. #define vfs_check_frozen(sb, level) \
  1265. wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level)))
  1266. #define get_fs_excl() atomic_inc(&current->fs_excl)
  1267. #define put_fs_excl() atomic_dec(&current->fs_excl)
  1268. #define has_fs_excl() atomic_read(&current->fs_excl)
  1269. #define is_owner_or_cap(inode) \
  1270. ((current_fsuid() == (inode)->i_uid) || capable(CAP_FOWNER))
  1271. /* not quite ready to be deprecated, but... */
  1272. extern void lock_super(struct super_block *);
  1273. extern void unlock_super(struct super_block *);
  1274. /*
  1275. * VFS helper functions..
  1276. */
  1277. extern int vfs_create(struct inode *, struct dentry *, int, struct nameidata *);
  1278. extern int vfs_mkdir(struct inode *, struct dentry *, int);
  1279. extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);
  1280. extern int vfs_symlink(struct inode *, struct dentry *, const char *);
  1281. extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
  1282. extern int vfs_rmdir(struct inode *, struct dentry *);
  1283. extern int vfs_unlink(struct inode *, struct dentry *);
  1284. extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
  1285. /*
  1286. * VFS dentry helper functions.
  1287. */
  1288. extern void dentry_unhash(struct dentry *dentry);
  1289. /*
  1290. * VFS file helper functions.
  1291. */
  1292. extern int file_permission(struct file *, int);
  1293. extern void inode_init_owner(struct inode *inode, const struct inode *dir,
  1294. mode_t mode);
  1295. /*
  1296. * VFS FS_IOC_FIEMAP helper definitions.
  1297. */
  1298. struct fiemap_extent_info {
  1299. unsigned int fi_flags; /* Flags as passed from user */
  1300. unsigned int fi_extents_mapped; /* Number of mapped extents */
  1301. unsigned int fi_extents_max; /* Size of fiemap_extent array */
  1302. struct fiemap_extent *fi_extents_start; /* Start of fiemap_extent
  1303. * array */
  1304. };
  1305. int fiemap_fill_next_extent(struct fiemap_extent_info *info, u64 logical,
  1306. u64 phys, u64 len, u32 flags);
  1307. int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);
  1308. /*
  1309. * File types
  1310. *
  1311. * NOTE! These match bits 12..15 of stat.st_mode
  1312. * (ie "(i_mode >> 12) & 15").
  1313. */
  1314. #define DT_UNKNOWN 0
  1315. #define DT_FIFO 1
  1316. #define DT_CHR 2
  1317. #define DT_DIR 4
  1318. #define DT_BLK 6
  1319. #define DT_REG 8
  1320. #define DT_LNK 10
  1321. #define DT_SOCK 12
  1322. #define DT_WHT 14
  1323. /*
  1324. * This is the "filldir" function type, used by readdir() to let
  1325. * the kernel specify what kind of dirent layout it wants to have.
  1326. * This allows the kernel to read directories into kernel space or
  1327. * to have different dirent layouts depending on the binary type.
  1328. */
  1329. typedef int (*filldir_t)(void *, const char *, int, loff_t, u64, unsigned);
  1330. struct block_device_operations;
  1331. /* These macros are for out of kernel modules to test that
  1332. * the kernel supports the unlocked_ioctl and compat_ioctl
  1333. * fields in struct file_operations. */
  1334. #define HAVE_COMPAT_IOCTL 1
  1335. #define HAVE_UNLOCKED_IOCTL 1
  1336. /*
  1337. * NOTE:
  1338. * all file operations except setlease can be called without
  1339. * the big kernel lock held in all filesystems.
  1340. */
  1341. struct file_operations {
  1342. struct module *owner;
  1343. loff_t (*llseek) (struct file *, loff_t, int);
  1344. ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
  1345. ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
  1346. ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
  1347. ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
  1348. int (*readdir) (struct file *, void *, filldir_t);
  1349. unsigned int (*poll) (struct file *, struct poll_table_struct *);
  1350. long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
  1351. long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
  1352. int (*mmap) (struct file *, struct vm_area_struct *);
  1353. int (*open) (struct inode *, struct file *);
  1354. int (*flush) (struct file *, fl_owner_t id);
  1355. int (*release) (struct inode *, struct file *);
  1356. int (*fsync) (struct file *, int datasync);
  1357. int (*aio_fsync) (struct kiocb *, int datasync);
  1358. int (*fasync) (int, struct file *, int);
  1359. int (*lock) (struct file *, int, struct file_lock *);
  1360. ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
  1361. unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
  1362. int (*check_flags)(int);
  1363. int (*flock) (struct file *, int, struct file_lock *);
  1364. ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
  1365. ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
  1366. int (*setlease)(struct file *, long, struct file_lock **);
  1367. };
  1368. #define IPERM_FLAG_RCU 0x0001
  1369. struct inode_operations {
  1370. struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
  1371. void * (*follow_link) (struct dentry *, struct nameidata *);
  1372. int (*permission) (struct inode *, int, unsigned int);
  1373. int (*check_acl)(struct inode *, int, unsigned int);
  1374. int (*readlink) (struct dentry *, char __user *,int);
  1375. void (*put_link) (struct dentry *, struct nameidata *, void *);
  1376. int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
  1377. int (*link) (struct dentry *,struct inode *,struct dentry *);
  1378. int (*unlink) (struct inode *,struct dentry *);
  1379. int (*symlink) (struct inode *,struct dentry *,const char *);
  1380. int (*mkdir) (struct inode *,struct dentry *,int);
  1381. int (*rmdir) (struct inode *,struct dentry *);
  1382. int (*mknod) (struct inode *,struct dentry *,int,dev_t);
  1383. int (*rename) (struct inode *, struct dentry *,
  1384. struct inode *, struct dentry *);
  1385. void (*truncate) (struct inode *);
  1386. int (*setattr) (struct dentry *, struct iattr *);
  1387. int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
  1388. int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
  1389. ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
  1390. ssize_t (*listxattr) (struct dentry *, char *, size_t);
  1391. int (*removexattr) (struct dentry *, const char *);
  1392. void (*truncate_range)(struct inode *, loff_t, loff_t);
  1393. long (*fallocate)(struct inode *inode, int mode, loff_t offset,
  1394. loff_t len);
  1395. int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
  1396. u64 len);
  1397. } ____cacheline_aligned;
  1398. struct seq_file;
  1399. ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
  1400. unsigned long nr_segs, unsigned long fast_segs,
  1401. struct iovec *fast_pointer,
  1402. struct iovec **ret_pointer);
  1403. extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
  1404. extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
  1405. extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
  1406. unsigned long, loff_t *);
  1407. extern ssize_t vfs_writev(struct file *, const struct iovec __user *,
  1408. unsigned long, loff_t *);
  1409. struct super_operations {
  1410. struct inode *(*alloc_inode)(struct super_block *sb);
  1411. void (*destroy_inode)(struct inode *);
  1412. void (*dirty_inode) (struct inode *);
  1413. int (*write_inode) (struct inode *, struct writeback_control *wbc);
  1414. int (*drop_inode) (struct inode *);
  1415. void (*evict_inode) (struct inode *);
  1416. void (*put_super) (struct super_block *);
  1417. void (*write_super) (struct super_block *);
  1418. int (*sync_fs)(struct super_block *sb, int wait);
  1419. int (*freeze_fs) (struct super_block *);
  1420. int (*unfreeze_fs) (struct super_block *);
  1421. int (*statfs) (struct dentry *, struct kstatfs *);
  1422. int (*remount_fs) (struct super_block *, int *, char *);
  1423. void (*umount_begin) (struct super_block *);
  1424. int (*show_options)(struct seq_file *, struct vfsmount *);
  1425. int (*show_stats)(struct seq_file *, struct vfsmount *);
  1426. #ifdef CONFIG_QUOTA
  1427. ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
  1428. ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
  1429. #endif
  1430. int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
  1431. };
  1432. /*
  1433. * Inode state bits. Protected by inode_lock.
  1434. *
  1435. * Three bits determine the dirty state of the inode, I_DIRTY_SYNC,
  1436. * I_DIRTY_DATASYNC and I_DIRTY_PAGES.
  1437. *
  1438. * Four bits define the lifetime of an inode. Initially, inodes are I_NEW,
  1439. * until that flag is cleared. I_WILL_FREE, I_FREEING and I_CLEAR are set at
  1440. * various stages of removing an inode.
  1441. *
  1442. * Two bits are used for locking and completion notification, I_NEW and I_SYNC.
  1443. *
  1444. * I_DIRTY_SYNC Inode is dirty, but doesn't have to be written on
  1445. * fdatasync(). i_atime is the usual cause.
  1446. * I_DIRTY_DATASYNC Data-related inode changes pending. We keep track of
  1447. * these changes separately from I_DIRTY_SYNC so that we
  1448. * don't have to write inode on fdatasync() when only
  1449. * mtime has changed in it.
  1450. * I_DIRTY_PAGES Inode has dirty pages. Inode itself may be clean.
  1451. * I_NEW Serves as both a mutex and completion notification.
  1452. * New inodes set I_NEW. If two processes both create
  1453. * the same inode, one of them will release its inode and
  1454. * wait for I_NEW to be released before returning.
  1455. * Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can
  1456. * also cause waiting on I_NEW, without I_NEW actually
  1457. * being set. find_inode() uses this to prevent returning
  1458. * nearly-dead inodes.
  1459. * I_WILL_FREE Must be set when calling write_inode_now() if i_count
  1460. * is zero. I_FREEING must be set when I_WILL_FREE is
  1461. * cleared.
  1462. * I_FREEING Set when inode is about to be freed but still has dirty
  1463. * pages or buffers attached or the inode itself is still
  1464. * dirty.
  1465. * I_CLEAR Added by end_writeback(). In this state the inode is clean
  1466. * and can be destroyed. Inode keeps I_FREEING.
  1467. *
  1468. * Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
  1469. * prohibited for many purposes. iget() must wait for
  1470. * the inode to be completely released, then create it
  1471. * anew. Other functions will just ignore such inodes,
  1472. * if appropriate. I_NEW is used for waiting.
  1473. *
  1474. * I_SYNC Synchonized write of dirty inode data. The bits is
  1475. * set during data writeback, and cleared with a wakeup
  1476. * on the bit address once it is done.
  1477. *
  1478. * Q: What is the difference between I_WILL_FREE and I_FREEING?
  1479. */
  1480. #define I_DIRTY_SYNC (1 << 0)
  1481. #define I_DIRTY_DATASYNC (1 << 1)
  1482. #define I_DIRTY_PAGES (1 << 2)
  1483. #define __I_NEW 3
  1484. #define I_NEW (1 << __I_NEW)
  1485. #define I_WILL_FREE (1 << 4)
  1486. #define I_FREEING (1 << 5)
  1487. #define I_CLEAR (1 << 6)
  1488. #define __I_SYNC 7
  1489. #define I_SYNC (1 << __I_SYNC)
  1490. #define I_REFERENCED (1 << 8)
  1491. #define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
  1492. extern void __mark_inode_dirty(struct inode *, int);
  1493. static inline void mark_inode_dirty(struct inode *inode)
  1494. {
  1495. __mark_inode_dirty(inode, I_DIRTY);
  1496. }
  1497. static inline void mark_inode_dirty_sync(struct inode *inode)
  1498. {
  1499. __mark_inode_dirty(inode, I_DIRTY_SYNC);
  1500. }
  1501. /**
  1502. * inc_nlink - directly increment an inode's link count
  1503. * @inode: inode
  1504. *
  1505. * This is a low-level filesystem helper to replace any
  1506. * direct filesystem manipulation of i_nlink. Currently,
  1507. * it is only here for parity with dec_nlink().
  1508. */
  1509. static inline void inc_nlink(struct inode *inode)
  1510. {
  1511. inode->i_nlink++;
  1512. }
  1513. static inline void inode_inc_link_count(struct inode *inode)
  1514. {
  1515. inc_nlink(inode);
  1516. mark_inode_dirty(inode);
  1517. }
  1518. /**
  1519. * drop_nlink - directly drop an inode's link count
  1520. * @inode: inode
  1521. *
  1522. * This is a low-level filesystem helper to replace any
  1523. * direct filesystem manipulation of i_nlink. In cases
  1524. * where we are attempting to track writes to the
  1525. * filesystem, a decrement to zero means an imminent
  1526. * write when the file is truncated and actually unlinked
  1527. * on the filesystem.
  1528. */
  1529. static inline void drop_nlink(struct inode *inode)
  1530. {
  1531. inode->i_nlink--;
  1532. }
  1533. /**
  1534. * clear_nlink - directly zero an inode's link count
  1535. * @inode: inode
  1536. *
  1537. * This is a low-level filesystem helper to replace any
  1538. * direct filesystem manipulation of i_nlink. See
  1539. * drop_nlink() for why we care about i_nlink hitting zero.
  1540. */
  1541. static inline void clear_nlink(struct inode *inode)
  1542. {
  1543. inode->i_nlink = 0;
  1544. }
  1545. static inline void inode_dec_link_count(struct inode *inode)
  1546. {
  1547. drop_nlink(inode);
  1548. mark_inode_dirty(inode);
  1549. }
  1550. /**
  1551. * inode_inc_iversion - increments i_version
  1552. * @inode: inode that need to be updated
  1553. *
  1554. * Every time the inode is modified, the i_version field will be incremented.
  1555. * The filesystem has to be mounted with i_version flag
  1556. */
  1557. static inline void inode_inc_iversion(struct inode *inode)
  1558. {
  1559. spin_lock(&inode->i_lock);
  1560. inode->i_version++;
  1561. spin_unlock(&inode->i_lock);
  1562. }
  1563. extern void touch_atime(struct vfsmount *mnt, struct dentry *dentry);
  1564. static inline void file_accessed(struct file *file)
  1565. {
  1566. if (!(file->f_flags & O_NOATIME))
  1567. touch_atime(file->f_path.mnt, file->f_path.dentry);
  1568. }
  1569. int sync_inode(struct inode *inode, struct writeback_control *wbc);
  1570. int sync_inode_metadata(struct inode *inode, int wait);
  1571. struct file_system_type {
  1572. const char *name;
  1573. int fs_flags;
  1574. int (*get_sb) (struct file_system_type *, int,
  1575. const char *, void *, struct vfsmount *);
  1576. struct dentry *(*mount) (struct file_system_type *, int,
  1577. const char *, void *);
  1578. void (*kill_sb) (struct super_block *);
  1579. struct module *owner;
  1580. struct file_system_type * next;
  1581. struct list_head fs_supers;
  1582. struct lock_class_key s_lock_key;
  1583. struct lock_class_key s_umount_key;
  1584. struct lock_class_key s_vfs_rename_key;
  1585. struct lock_class_key i_lock_key;
  1586. struct lock_class_key i_mutex_key;
  1587. struct lock_class_key i_mutex_dir_key;
  1588. struct lock_class_key i_alloc_sem_key;
  1589. };
  1590. extern struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
  1591. void *data, int (*fill_super)(struct super_block *, void *, int));
  1592. extern struct dentry *mount_bdev(struct file_system_type *fs_type,
  1593. int flags, const char *dev_name, void *data,
  1594. int (*fill_super)(struct super_block *, void *, int));
  1595. extern int get_sb_bdev(struct file_system_type *fs_type,
  1596. int flags, const char *dev_name, void *data,
  1597. int (*fill_super)(struct super_block *, void *, int),
  1598. struct vfsmount *mnt);
  1599. extern struct dentry *mount_single(struct file_system_type *fs_type,
  1600. int flags, void *data,
  1601. int (*fill_super)(struct super_block *, void *, int));
  1602. extern int get_sb_single(struct file_system_type *fs_type,
  1603. int flags, void *data,
  1604. int (*fill_super)(struct super_block *, void *, int),
  1605. struct vfsmount *mnt);
  1606. extern struct dentry *mount_nodev(struct file_system_type *fs_type,
  1607. int flags, void *data,
  1608. int (*fill_super)(struct super_block *, void *, int));
  1609. extern int get_sb_nodev(struct file_system_type *fs_type,
  1610. int flags, void *data,
  1611. int (*fill_super)(struct super_block *, void *, int),
  1612. struct vfsmount *mnt);
  1613. void generic_shutdown_super(struct super_block *sb);
  1614. void kill_block_super(struct super_block *sb);
  1615. void kill_anon_super(struct super_block *sb);
  1616. void kill_litter_super(struct super_block *sb);
  1617. void deactivate_super(struct super_block *sb);
  1618. void deactivate_locked_super(struct super_block *sb);
  1619. int set_anon_super(struct super_block *s, void *data);
  1620. struct super_block *sget(struct file_system_type *type,
  1621. int (*test)(struct super_block *,void *),
  1622. int (*set)(struct super_block *,void *),
  1623. void *data);
  1624. extern struct dentry *mount_pseudo(struct file_system_type *, char *,
  1625. const struct super_operations *ops,
  1626. const struct dentry_operations *dops,
  1627. unsigned long);
  1628. extern void simple_set_mnt(struct vfsmount *mnt, struct super_block *sb);
  1629. static inline void sb_mark_dirty(struct super_block *sb)
  1630. {
  1631. sb->s_dirt = 1;
  1632. }
  1633. static inline void sb_mark_clean(struct super_block *sb)
  1634. {
  1635. sb->s_dirt = 0;
  1636. }
  1637. static inline int sb_is_dirty(struct super_block *sb)
  1638. {
  1639. return sb->s_dirt;
  1640. }
  1641. /* Alas, no aliases. Too much hassle with bringing module.h everywhere */
  1642. #define fops_get(fops) \
  1643. (((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
  1644. #define fops_put(fops) \
  1645. do { if (fops) module_put((fops)->owner); } while(0)
  1646. extern int register_filesystem(struct file_system_type *);
  1647. extern int unregister_filesystem(struct file_system_type *);
  1648. extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);
  1649. #define kern_mount(type) kern_mount_data(type, NULL)
  1650. extern int may_umount_tree(struct vfsmount *);
  1651. extern int may_umount(struct vfsmount *);
  1652. extern long do_mount(char *, char *, char *, unsigned long, void *);
  1653. extern struct vfsmount *collect_mounts(struct path *);
  1654. extern void drop_collected_mounts(struct vfsmount *);
  1655. extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *,
  1656. struct vfsmount *);
  1657. extern int vfs_statfs(struct path *, struct kstatfs *);
  1658. extern int statfs_by_dentry(struct dentry *, struct kstatfs *);
  1659. extern int freeze_super(struct super_block *super);
  1660. extern int thaw_super(struct super_block *super);
  1661. extern int current_umask(void);
  1662. /* /sys/fs */
  1663. extern struct kobject *fs_kobj;
  1664. #define MAX_RW_COUNT (INT_MAX & PAGE_CACHE_MASK)
  1665. extern int rw_verify_area(int, struct file *, loff_t *, size_t);
  1666. #define FLOCK_VERIFY_READ 1
  1667. #define FLOCK_VERIFY_WRITE 2
  1668. #ifdef CONFIG_FILE_LOCKING
  1669. extern int locks_mandatory_locked(struct inode *);
  1670. extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
  1671. /*
  1672. * Candidates for mandatory locking have the setgid bit set
  1673. * but no group execute bit - an otherwise meaningless combination.
  1674. */
  1675. static inline int __mandatory_lock(struct inode *ino)
  1676. {
  1677. return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID;
  1678. }
  1679. /*
  1680. * ... and these candidates should be on MS_MANDLOCK mounted fs,
  1681. * otherwise these will be advisory locks
  1682. */
  1683. static inline int mandatory_lock(struct inode *ino)
  1684. {
  1685. return IS_MANDLOCK(ino) && __mandatory_lock(ino);
  1686. }
  1687. static inline int locks_verify_locked(struct inode *inode)
  1688. {
  1689. if (mandatory_lock(inode))
  1690. return locks_mandatory_locked(inode);
  1691. return 0;
  1692. }
  1693. static inline int locks_verify_truncate(struct inode *inode,
  1694. struct file *filp,
  1695. loff_t size)
  1696. {
  1697. if (inode->i_flock && mandatory_lock(inode))
  1698. return locks_mandatory_area(
  1699. FLOCK_VERIFY_WRITE, inode, filp,
  1700. size < inode->i_size ? size : inode->i_size,
  1701. (size < inode->i_size ? inode->i_size - size
  1702. : size - inode->i_size)
  1703. );
  1704. return 0;
  1705. }
  1706. static inline int break_lease(struct inode *inode, unsigned int mode)
  1707. {
  1708. if (inode->i_flock)
  1709. return __break_lease(inode, mode);
  1710. return 0;
  1711. }
  1712. #else /* !CONFIG_FILE_LOCKING */
  1713. static inline int locks_mandatory_locked(struct inode *inode)
  1714. {
  1715. return 0;
  1716. }
  1717. static inline int locks_mandatory_area(int rw, struct inode *inode,
  1718. struct file *filp, loff_t offset,
  1719. size_t count)
  1720. {
  1721. return 0;
  1722. }
  1723. static inline int __mandatory_lock(struct inode *inode)
  1724. {
  1725. return 0;
  1726. }
  1727. static inline int mandatory_lock(struct inode *inode)
  1728. {
  1729. return 0;
  1730. }
  1731. static inline int locks_verify_locked(struct inode *inode)
  1732. {
  1733. return 0;
  1734. }
  1735. static inline int locks_verify_truncate(struct inode *inode, struct file *filp,
  1736. size_t size)
  1737. {
  1738. return 0;
  1739. }
  1740. static inline int break_lease(struct inode *inode, unsigned int mode)
  1741. {
  1742. return 0;
  1743. }
  1744. #endif /* CONFIG_FILE_LOCKING */
  1745. /* fs/open.c */
  1746. extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
  1747. struct file *filp);
  1748. extern int do_fallocate(struct file *file, int mode, loff_t offset,
  1749. loff_t len);
  1750. extern long do_sys_open(int dfd, const char __user *filename, int flags,
  1751. int mode);
  1752. extern struct file *filp_open(const char *, int, int);
  1753. extern struct file * dentry_open(struct dentry *, struct vfsmount *, int,
  1754. const struct cred *);
  1755. extern int filp_close(struct file *, fl_owner_t id);
  1756. extern char * getname(const char __user *);
  1757. /* fs/ioctl.c */
  1758. extern int ioctl_preallocate(struct file *filp, void __user *argp);
  1759. /* fs/dcache.c */
  1760. extern void __init vfs_caches_init_early(void);
  1761. extern void __init vfs_caches_init(unsigned long);
  1762. extern struct kmem_cache *names_cachep;
  1763. #define __getname_gfp(gfp) kmem_cache_alloc(names_cachep, (gfp))
  1764. #define __getname() __getname_gfp(GFP_KERNEL)
  1765. #define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
  1766. #ifndef CONFIG_AUDITSYSCALL
  1767. #define putname(name) __putname(name)
  1768. #else
  1769. extern void putname(const char *name);
  1770. #endif
  1771. #ifdef CONFIG_BLOCK
  1772. extern int register_blkdev(unsigned int, const char *);
  1773. extern void unregister_blkdev(unsigned int, const char *);
  1774. extern struct block_device *bdget(dev_t);
  1775. extern struct block_device *bdgrab(struct block_device *bdev);
  1776. extern void bd_set_size(struct block_device *, loff_t size);
  1777. extern void bd_forget(struct inode *inode);
  1778. extern void bdput(struct block_device *);
  1779. extern void invalidate_bdev(struct block_device *);
  1780. extern int sync_blockdev(struct block_device *bdev);
  1781. extern struct super_block *freeze_bdev(struct block_device *);
  1782. extern void emergency_thaw_all(void);
  1783. extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
  1784. extern int fsync_bdev(struct block_device *);
  1785. #else
  1786. static inline void bd_forget(struct inode *inode) {}
  1787. static inline int sync_blockdev(struct block_device *bdev) { return 0; }
  1788. static inline void invalidate_bdev(struct block_device *bdev) {}
  1789. static inline struct super_block *freeze_bdev(struct block_device *sb)
  1790. {
  1791. return NULL;
  1792. }
  1793. static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb)
  1794. {
  1795. return 0;
  1796. }
  1797. #endif
  1798. extern int sync_filesystem(struct super_block *);
  1799. extern const struct file_operations def_blk_fops;
  1800. extern const struct file_operations def_chr_fops;
  1801. extern const struct file_operations bad_sock_fops;
  1802. extern const struct file_operations def_fifo_fops;
  1803. #ifdef CONFIG_BLOCK
  1804. extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
  1805. extern int blkdev_ioctl(struct block_device *, fmode_t, unsigned, unsigned long);
  1806. extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
  1807. extern int blkdev_get(struct block_device *bdev, fmode_t mode, void *holder);
  1808. extern struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
  1809. void *holder);
  1810. extern struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode,
  1811. void *holder);
  1812. extern int blkdev_put(struct block_device *bdev, fmode_t mode);
  1813. #ifdef CONFIG_SYSFS
  1814. extern int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk);
  1815. #else
  1816. static inline int bd_link_disk_holder(struct block_device *bdev,
  1817. struct gendisk *disk)
  1818. {
  1819. return 0;
  1820. }
  1821. #endif
  1822. #endif
  1823. /* fs/char_dev.c */
  1824. #define CHRDEV_MAJOR_HASH_SIZE 255
  1825. extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
  1826. extern int register_chrdev_region(dev_t, unsigned, const char *);
  1827. extern int __register_chrdev(unsigned int major, unsigned int baseminor,
  1828. unsigned int count, const char *name,
  1829. const struct file_operations *fops);
  1830. extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
  1831. unsigned int count, const char *name);
  1832. extern void unregister_chrdev_region(dev_t, unsigned);
  1833. extern void chrdev_show(struct seq_file *,off_t);
  1834. static inline int register_chrdev(unsigned int major, const char *name,
  1835. const struct file_operations *fops)
  1836. {
  1837. return __register_chrdev(major, 0, 256, name, fops);
  1838. }
  1839. static inline void unregister_chrdev(unsigned int major, const char *name)
  1840. {
  1841. __unregister_chrdev(major, 0, 256, name);
  1842. }
  1843. /* fs/block_dev.c */
  1844. #define BDEVNAME_SIZE 32 /* Largest string for a blockdev identifier */
  1845. #define BDEVT_SIZE 10 /* Largest string for MAJ:MIN for blkdev */
  1846. #ifdef CONFIG_BLOCK
  1847. #define BLKDEV_MAJOR_HASH_SIZE 255
  1848. extern const char *__bdevname(dev_t, char *buffer);
  1849. extern const char *bdevname(struct block_device *bdev, char *buffer);
  1850. extern struct block_device *lookup_bdev(const char *);
  1851. extern void blkdev_show(struct seq_file *,off_t);
  1852. #else
  1853. #define BLKDEV_MAJOR_HASH_SIZE 0
  1854. #endif
  1855. extern void init_special_inode(struct inode *, umode_t, dev_t);
  1856. /* Invalid inode operations -- fs/bad_inode.c */
  1857. extern void make_bad_inode(struct inode *);
  1858. extern int is_bad_inode(struct inode *);
  1859. extern const struct file_operations read_pipefifo_fops;
  1860. extern const struct file_operations write_pipefifo_fops;
  1861. extern const struct file_operations rdwr_pipefifo_fops;
  1862. extern int fs_may_remount_ro(struct super_block *);
  1863. #ifdef CONFIG_BLOCK
  1864. /*
  1865. * return READ, READA, or WRITE
  1866. */
  1867. #define bio_rw(bio) ((bio)->bi_rw & (RW_MASK | RWA_MASK))
  1868. /*
  1869. * return data direction, READ or WRITE
  1870. */
  1871. #define bio_data_dir(bio) ((bio)->bi_rw & 1)
  1872. extern void check_disk_size_change(struct gendisk *disk,
  1873. struct block_device *bdev);
  1874. extern int revalidate_disk(struct gendisk *);
  1875. extern int check_disk_change(struct block_device *);
  1876. extern int __invalidate_device(struct block_device *);
  1877. extern int invalidate_partition(struct gendisk *, int);
  1878. #endif
  1879. unsigned long invalidate_mapping_pages(struct address_space *mapping,
  1880. pgoff_t start, pgoff_t end);
  1881. static inline void invalidate_remote_inode(struct inode *inode)
  1882. {
  1883. if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
  1884. S_ISLNK(inode->i_mode))
  1885. invalidate_mapping_pages(inode->i_mapping, 0, -1);
  1886. }
  1887. extern int invalidate_inode_pages2(struct address_space *mapping);
  1888. extern int invalidate_inode_pages2_range(struct address_space *mapping,
  1889. pgoff_t start, pgoff_t end);
  1890. extern int write_inode_now(struct inode *, int);
  1891. extern int filemap_fdatawrite(struct address_space *);
  1892. extern int filemap_flush(struct address_space *);
  1893. extern int filemap_fdatawait(struct address_space *);
  1894. extern int filemap_fdatawait_range(struct address_space *, loff_t lstart,
  1895. loff_t lend);
  1896. extern int filemap_write_and_wait(struct address_space *mapping);
  1897. extern int filemap_write_and_wait_range(struct address_space *mapping,
  1898. loff_t lstart, loff_t lend);
  1899. extern int __filemap_fdatawrite_range(struct address_space *mapping,
  1900. loff_t start, loff_t end, int sync_mode);
  1901. extern int filemap_fdatawrite_range(struct address_space *mapping,
  1902. loff_t start, loff_t end);
  1903. extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
  1904. int datasync);
  1905. extern int vfs_fsync(struct file *file, int datasync);
  1906. extern int generic_write_sync(struct file *file, loff_t pos, loff_t count);
  1907. extern void sync_supers(void);
  1908. extern void emergency_sync(void);
  1909. extern void emergency_remount(void);
  1910. #ifdef CONFIG_BLOCK
  1911. extern sector_t bmap(struct inode *, sector_t);
  1912. #endif
  1913. extern int notify_change(struct dentry *, struct iattr *);
  1914. extern int inode_permission(struct inode *, int);
  1915. extern int generic_permission(struct inode *, int, unsigned int,
  1916. int (*check_acl)(struct inode *, int, unsigned int));
  1917. static inline bool execute_ok(struct inode *inode)
  1918. {
  1919. return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
  1920. }
  1921. extern int get_write_access(struct inode *);
  1922. extern int deny_write_access(struct file *);
  1923. static inline void put_write_access(struct inode * inode)
  1924. {
  1925. atomic_dec(&inode->i_writecount);
  1926. }
  1927. static inline void allow_write_access(struct file *file)
  1928. {
  1929. if (file)
  1930. atomic_inc(&file->f_path.dentry->d_inode->i_writecount);
  1931. }
  1932. extern int do_pipe_flags(int *, int);
  1933. extern struct file *create_read_pipe(struct file *f, int flags);
  1934. extern struct file *create_write_pipe(int flags);
  1935. extern void free_write_pipe(struct file *);
  1936. extern struct file *do_filp_open(int dfd, const char *pathname,
  1937. int open_flag, int mode, int acc_mode);
  1938. extern int may_open(struct path *, int, int);
  1939. extern int kernel_read(struct file *, loff_t, char *, unsigned long);
  1940. extern struct file * open_exec(const char *);
  1941. /* fs/dcache.c -- generic fs support functions */
  1942. extern int is_subdir(struct dentry *, struct dentry *);
  1943. extern int path_is_under(struct path *, struct path *);
  1944. extern ino_t find_inode_number(struct dentry *, struct qstr *);
  1945. #include <linux/err.h>
  1946. /* needed for stackable file system support */
  1947. extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
  1948. extern loff_t vfs_llseek(struct file *file, loff_t offset, int origin);
  1949. extern int inode_init_always(struct super_block *, struct inode *);
  1950. extern void inode_init_once(struct inode *);
  1951. extern void ihold(struct inode * inode);
  1952. extern void iput(struct inode *);
  1953. extern struct inode * igrab(struct inode *);
  1954. extern ino_t iunique(struct super_block *, ino_t);
  1955. extern int inode_needs_sync(struct inode *inode);
  1956. extern int generic_delete_inode(struct inode *inode);
  1957. extern int generic_drop_inode(struct inode *inode);
  1958. extern struct inode *ilookup5_nowait(struct super_block *sb,
  1959. unsigned long hashval, int (*test)(struct inode *, void *),
  1960. void *data);
  1961. extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
  1962. int (*test)(struct inode *, void *), void *data);
  1963. extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
  1964. extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
  1965. extern struct inode * iget_locked(struct super_block *, unsigned long);
  1966. extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
  1967. extern int insert_inode_locked(struct inode *);
  1968. extern void unlock_new_inode(struct inode *);
  1969. extern unsigned int get_next_ino(void);
  1970. extern void __iget(struct inode * inode);
  1971. extern void iget_failed(struct inode *);
  1972. extern void end_writeback(struct inode *);
  1973. extern void __destroy_inode(struct inode *);
  1974. extern struct inode *new_inode(struct super_block *);
  1975. extern void free_inode_nonrcu(struct inode *inode);
  1976. extern int should_remove_suid(struct dentry *);
  1977. extern int file_remove_suid(struct file *);
  1978. extern void __insert_inode_hash(struct inode *, unsigned long hashval);
  1979. extern void remove_inode_hash(struct inode *);
  1980. static inline void insert_inode_hash(struct inode *inode)
  1981. {
  1982. __insert_inode_hash(inode, inode->i_ino);
  1983. }
  1984. extern void inode_sb_list_add(struct inode *inode);
  1985. #ifdef CONFIG_BLOCK
  1986. extern void submit_bio(int, struct bio *);
  1987. extern int bdev_read_only(struct block_device *);
  1988. #endif
  1989. extern int set_blocksize(struct block_device *, int);
  1990. extern int sb_set_blocksize(struct super_block *, int);
  1991. extern int sb_min_blocksize(struct super_block *, int);
  1992. extern int generic_file_mmap(struct file *, struct vm_area_struct *);
  1993. extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
  1994. extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
  1995. int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
  1996. extern ssize_t generic_file_aio_read(struct kiocb *, const struct iovec *, unsigned long, loff_t);
  1997. extern ssize_t __generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long,
  1998. loff_t *);
  1999. extern ssize_t generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long, loff_t);
  2000. extern ssize_t generic_file_direct_write(struct kiocb *, const struct iovec *,
  2001. unsigned long *, loff_t, loff_t *, size_t, size_t);
  2002. extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
  2003. unsigned long, loff_t, loff_t *, size_t, ssize_t);
  2004. extern ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos);
  2005. extern ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);
  2006. extern int generic_segment_checks(const struct iovec *iov,
  2007. unsigned long *nr_segs, size_t *count, int access_flags);
  2008. /* fs/block_dev.c */
  2009. extern ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
  2010. unsigned long nr_segs, loff_t pos);
  2011. extern int blkdev_fsync(struct file *filp, int datasync);
  2012. /* fs/splice.c */
  2013. extern ssize_t generic_file_splice_read(struct file *, loff_t *,
  2014. struct pipe_inode_info *, size_t, unsigned int);
  2015. extern ssize_t default_file_splice_read(struct file *, loff_t *,
  2016. struct pipe_inode_info *, size_t, unsigned int);
  2017. extern ssize_t generic_file_splice_write(struct pipe_inode_info *,
  2018. struct file *, loff_t *, size_t, unsigned int);
  2019. extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
  2020. struct file *out, loff_t *, size_t len, unsigned int flags);
  2021. extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
  2022. size_t len, unsigned int flags);
  2023. extern void
  2024. file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
  2025. extern loff_t noop_llseek(struct file *file, loff_t offset, int origin);
  2026. extern loff_t no_llseek(struct file *file, loff_t offset, int origin);
  2027. extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);
  2028. extern loff_t generic_file_llseek_unlocked(struct file *file, loff_t offset,
  2029. int origin);
  2030. extern int generic_file_open(struct inode * inode, struct file * filp);
  2031. extern int nonseekable_open(struct inode * inode, struct file * filp);
  2032. #ifdef CONFIG_FS_XIP
  2033. extern ssize_t xip_file_read(struct file *filp, char __user *buf, size_t len,
  2034. loff_t *ppos);
  2035. extern int xip_file_mmap(struct file * file, struct vm_area_struct * vma);
  2036. extern ssize_t xip_file_write(struct file *filp, const char __user *buf,
  2037. size_t len, loff_t *ppos);
  2038. extern int xip_truncate_page(struct address_space *mapping, loff_t from);
  2039. #else
  2040. static inline int xip_truncate_page(struct address_space *mapping, loff_t from)
  2041. {
  2042. return 0;
  2043. }
  2044. #endif
  2045. #ifdef CONFIG_BLOCK
  2046. typedef void (dio_submit_t)(int rw, struct bio *bio, struct inode *inode,
  2047. loff_t file_offset);
  2048. enum {
  2049. /* need locking between buffered and direct access */
  2050. DIO_LOCKING = 0x01,
  2051. /* filesystem does not support filling holes */
  2052. DIO_SKIP_HOLES = 0x02,
  2053. };
  2054. void dio_end_io(struct bio *bio, int error);
  2055. ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
  2056. struct block_device *bdev, const struct iovec *iov, loff_t offset,
  2057. unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
  2058. dio_submit_t submit_io, int flags);
  2059. static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
  2060. struct inode *inode, struct block_device *bdev, const struct iovec *iov,
  2061. loff_t offset, unsigned long nr_segs, get_block_t get_block,
  2062. dio_iodone_t end_io)
  2063. {
  2064. return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
  2065. nr_segs, get_block, end_io, NULL,
  2066. DIO_LOCKING | DIO_SKIP_HOLES);
  2067. }
  2068. #endif
  2069. extern const struct file_operations generic_ro_fops;
  2070. #define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
  2071. extern int vfs_readlink(struct dentry *, char __user *, int, const char *);
  2072. extern int vfs_follow_link(struct nameidata *, const char *);
  2073. extern int page_readlink(struct dentry *, char __user *, int);
  2074. extern void *page_follow_link_light(struct dentry *, struct nameidata *);
  2075. extern void page_put_link(struct dentry *, struct nameidata *, void *);
  2076. extern int __page_symlink(struct inode *inode, const char *symname, int len,
  2077. int nofs);
  2078. extern int page_symlink(struct inode *inode, const char *symname, int len);
  2079. extern const struct inode_operations page_symlink_inode_operations;
  2080. extern int generic_readlink(struct dentry *, char __user *, int);
  2081. extern void generic_fillattr(struct inode *, struct kstat *);
  2082. extern int vfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
  2083. void __inode_add_bytes(struct inode *inode, loff_t bytes);
  2084. void inode_add_bytes(struct inode *inode, loff_t bytes);
  2085. void inode_sub_bytes(struct inode *inode, loff_t bytes);
  2086. loff_t inode_get_bytes(struct inode *inode);
  2087. void inode_set_bytes(struct inode *inode, loff_t bytes);
  2088. extern int vfs_readdir(struct file *, filldir_t, void *);
  2089. extern int vfs_stat(const char __user *, struct kstat *);
  2090. extern int vfs_lstat(const char __user *, struct kstat *);
  2091. extern int vfs_fstat(unsigned int, struct kstat *);
  2092. extern int vfs_fstatat(int , const char __user *, struct kstat *, int);
  2093. extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
  2094. unsigned long arg);
  2095. extern int __generic_block_fiemap(struct inode *inode,
  2096. struct fiemap_extent_info *fieinfo,
  2097. loff_t start, loff_t len,
  2098. get_block_t *get_block);
  2099. extern int generic_block_fiemap(struct inode *inode,
  2100. struct fiemap_extent_info *fieinfo, u64 start,
  2101. u64 len, get_block_t *get_block);
  2102. extern void get_filesystem(struct file_system_type *fs);
  2103. extern void put_filesystem(struct file_system_type *fs);
  2104. extern struct file_system_type *get_fs_type(const char *name);
  2105. extern struct super_block *get_super(struct block_device *);
  2106. extern struct super_block *get_active_super(struct block_device *bdev);
  2107. extern struct super_block *user_get_super(dev_t);
  2108. extern void drop_super(struct super_block *sb);
  2109. extern void iterate_supers(void (*)(struct super_block *, void *), void *);
  2110. extern int dcache_dir_open(struct inode *, struct file *);
  2111. extern int dcache_dir_close(struct inode *, struct file *);
  2112. extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
  2113. extern int dcache_readdir(struct file *, void *, filldir_t);
  2114. extern int simple_setattr(struct dentry *, struct iattr *);
  2115. extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
  2116. extern int simple_statfs(struct dentry *, struct kstatfs *);
  2117. extern int simple_link(struct dentry *, struct inode *, struct dentry *);
  2118. extern int simple_unlink(struct inode *, struct dentry *);
  2119. extern int simple_rmdir(struct inode *, struct dentry *);
  2120. extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
  2121. extern int noop_fsync(struct file *, int);
  2122. extern int simple_empty(struct dentry *);
  2123. extern int simple_readpage(struct file *file, struct page *page);
  2124. extern int simple_write_begin(struct file *file, struct address_space *mapping,
  2125. loff_t pos, unsigned len, unsigned flags,
  2126. struct page **pagep, void **fsdata);
  2127. extern int simple_write_end(struct file *file, struct address_space *mapping,
  2128. loff_t pos, unsigned len, unsigned copied,
  2129. struct page *page, void *fsdata);
  2130. extern struct dentry *simple_lookup(struct inode *, struct dentry *, struct nameidata *);
  2131. extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
  2132. extern const struct file_operations simple_dir_operations;
  2133. extern const struct inode_operations simple_dir_inode_operations;
  2134. struct tree_descr { char *name; const struct file_operations *ops; int mode; };
  2135. struct dentry *d_alloc_name(struct dentry *, const char *);
  2136. extern int simple_fill_super(struct super_block *, unsigned long, struct tree_descr *);
  2137. extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
  2138. extern void simple_release_fs(struct vfsmount **mount, int *count);
  2139. extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
  2140. loff_t *ppos, const void *from, size_t available);
  2141. extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
  2142. const void __user *from, size_t count);
  2143. extern int generic_file_fsync(struct file *, int);
  2144. extern int generic_check_addressable(unsigned, u64);
  2145. #ifdef CONFIG_MIGRATION
  2146. extern int buffer_migrate_page(struct address_space *,
  2147. struct page *, struct page *);
  2148. #else
  2149. #define buffer_migrate_page NULL
  2150. #endif
  2151. extern int inode_change_ok(const struct inode *, struct iattr *);
  2152. extern int inode_newsize_ok(const struct inode *, loff_t offset);
  2153. extern void setattr_copy(struct inode *inode, const struct iattr *attr);
  2154. extern void file_update_time(struct file *file);
  2155. extern int generic_show_options(struct seq_file *m, struct vfsmount *mnt);
  2156. extern void save_mount_options(struct super_block *sb, char *options);
  2157. extern void replace_mount_options(struct super_block *sb, char *options);
  2158. static inline ino_t parent_ino(struct dentry *dentry)
  2159. {
  2160. ino_t res;
  2161. /*
  2162. * Don't strictly need d_lock here? If the parent ino could change
  2163. * then surely we'd have a deeper race in the caller?
  2164. */
  2165. spin_lock(&dentry->d_lock);
  2166. res = dentry->d_parent->d_inode->i_ino;
  2167. spin_unlock(&dentry->d_lock);
  2168. return res;
  2169. }
  2170. /* Transaction based IO helpers */
  2171. /*
  2172. * An argresp is stored in an allocated page and holds the
  2173. * size of the argument or response, along with its content
  2174. */
  2175. struct simple_transaction_argresp {
  2176. ssize_t size;
  2177. char data[0];
  2178. };
  2179. #define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
  2180. char *simple_transaction_get(struct file *file, const char __user *buf,
  2181. size_t size);
  2182. ssize_t simple_transaction_read(struct file *file, char __user *buf,
  2183. size_t size, loff_t *pos);
  2184. int simple_transaction_release(struct inode *inode, struct file *file);
  2185. void simple_transaction_set(struct file *file, size_t n);
  2186. /*
  2187. * simple attribute files
  2188. *
  2189. * These attributes behave similar to those in sysfs:
  2190. *
  2191. * Writing to an attribute immediately sets a value, an open file can be
  2192. * written to multiple times.
  2193. *
  2194. * Reading from an attribute creates a buffer from the value that might get
  2195. * read with multiple read calls. When the attribute has been read
  2196. * completely, no further read calls are possible until the file is opened
  2197. * again.
  2198. *
  2199. * All attributes contain a text representation of a numeric value
  2200. * that are accessed with the get() and set() functions.
  2201. */
  2202. #define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \
  2203. static int __fops ## _open(struct inode *inode, struct file *file) \
  2204. { \
  2205. __simple_attr_check_format(__fmt, 0ull); \
  2206. return simple_attr_open(inode, file, __get, __set, __fmt); \
  2207. } \
  2208. static const struct file_operations __fops = { \
  2209. .owner = THIS_MODULE, \
  2210. .open = __fops ## _open, \
  2211. .release = simple_attr_release, \
  2212. .read = simple_attr_read, \
  2213. .write = simple_attr_write, \
  2214. .llseek = generic_file_llseek, \
  2215. };
  2216. static inline void __attribute__((format(printf, 1, 2)))
  2217. __simple_attr_check_format(const char *fmt, ...)
  2218. {
  2219. /* don't do anything, just let the compiler check the arguments; */
  2220. }
  2221. int simple_attr_open(struct inode *inode, struct file *file,
  2222. int (*get)(void *, u64 *), int (*set)(void *, u64),
  2223. const char *fmt);
  2224. int simple_attr_release(struct inode *inode, struct file *file);
  2225. ssize_t simple_attr_read(struct file *file, char __user *buf,
  2226. size_t len, loff_t *ppos);
  2227. ssize_t simple_attr_write(struct file *file, const char __user *buf,
  2228. size_t len, loff_t *ppos);
  2229. struct ctl_table;
  2230. int proc_nr_files(struct ctl_table *table, int write,
  2231. void __user *buffer, size_t *lenp, loff_t *ppos);
  2232. int proc_nr_dentry(struct ctl_table *table, int write,
  2233. void __user *buffer, size_t *lenp, loff_t *ppos);
  2234. int proc_nr_inodes(struct ctl_table *table, int write,
  2235. void __user *buffer, size_t *lenp, loff_t *ppos);
  2236. int __init get_filesystem_list(char *buf);
  2237. #define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE])
  2238. #define OPEN_FMODE(flag) ((__force fmode_t)(((flag + 1) & O_ACCMODE) | \
  2239. (flag & FMODE_NONOTIFY)))
  2240. #endif /* __KERNEL__ */
  2241. #endif /* _LINUX_FS_H */