fs.h 89 KB

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