ext4.h 130 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * ext4.h
  4. *
  5. * Copyright (C) 1992, 1993, 1994, 1995
  6. * Remy Card (card@masi.ibp.fr)
  7. * Laboratoire MASI - Institut Blaise Pascal
  8. * Universite Pierre et Marie Curie (Paris VI)
  9. *
  10. * from
  11. *
  12. * linux/include/linux/minix_fs.h
  13. *
  14. * Copyright (C) 1991, 1992 Linus Torvalds
  15. */
  16. #ifndef _EXT4_H
  17. #define _EXT4_H
  18. #include <linux/types.h>
  19. #include <linux/blkdev.h>
  20. #include <linux/magic.h>
  21. #include <linux/jbd2.h>
  22. #include <linux/quota.h>
  23. #include <linux/rwsem.h>
  24. #include <linux/rbtree.h>
  25. #include <linux/seqlock.h>
  26. #include <linux/mutex.h>
  27. #include <linux/timer.h>
  28. #include <linux/wait.h>
  29. #include <linux/sched/signal.h>
  30. #include <linux/blockgroup_lock.h>
  31. #include <linux/percpu_counter.h>
  32. #include <linux/ratelimit.h>
  33. #include <crypto/hash.h>
  34. #include <linux/falloc.h>
  35. #include <linux/percpu-rwsem.h>
  36. #include <linux/fiemap.h>
  37. #ifdef __KERNEL__
  38. #include <linux/compat.h>
  39. #endif
  40. #include <linux/fscrypt.h>
  41. #include <linux/fsverity.h>
  42. #include <linux/compiler.h>
  43. /*
  44. * The fourth extended filesystem constants/structures
  45. */
  46. /*
  47. * with AGGRESSIVE_CHECK allocator runs consistency checks over
  48. * structures. these checks slow things down a lot
  49. */
  50. #define AGGRESSIVE_CHECK__
  51. /*
  52. * with DOUBLE_CHECK defined mballoc creates persistent in-core
  53. * bitmaps, maintains and uses them to check for double allocations
  54. */
  55. #define DOUBLE_CHECK__
  56. /*
  57. * Define EXT4FS_DEBUG to produce debug messages
  58. */
  59. #undef EXT4FS_DEBUG
  60. /*
  61. * Debug code
  62. */
  63. #ifdef EXT4FS_DEBUG
  64. #define ext4_debug(f, a...) \
  65. do { \
  66. printk(KERN_DEBUG "EXT4-fs DEBUG (%s, %d): %s:", \
  67. __FILE__, __LINE__, __func__); \
  68. printk(KERN_DEBUG f, ## a); \
  69. } while (0)
  70. #else
  71. #define ext4_debug(fmt, ...) no_printk(fmt, ##__VA_ARGS__)
  72. #endif
  73. /*
  74. * Turn on EXT_DEBUG to enable ext4_ext_show_path/leaf/move in extents.c
  75. */
  76. #define EXT_DEBUG__
  77. /*
  78. * Dynamic printk for controlled extents debugging.
  79. */
  80. #ifdef CONFIG_EXT4_DEBUG
  81. #define ext_debug(ino, fmt, ...) \
  82. pr_debug("[%s/%d] EXT4-fs (%s): ino %lu: (%s, %d): %s:" fmt, \
  83. current->comm, task_pid_nr(current), \
  84. ino->i_sb->s_id, ino->i_ino, __FILE__, __LINE__, \
  85. __func__, ##__VA_ARGS__)
  86. #else
  87. #define ext_debug(ino, fmt, ...) no_printk(fmt, ##__VA_ARGS__)
  88. #endif
  89. /* data type for block offset of block group */
  90. typedef int ext4_grpblk_t;
  91. /* data type for filesystem-wide blocks number */
  92. typedef unsigned long long ext4_fsblk_t;
  93. /* data type for file logical block number */
  94. typedef __u32 ext4_lblk_t;
  95. /* data type for block group number */
  96. typedef unsigned int ext4_group_t;
  97. enum SHIFT_DIRECTION {
  98. SHIFT_LEFT = 0,
  99. SHIFT_RIGHT,
  100. };
  101. /*
  102. * Flags used in mballoc's allocation_context flags field.
  103. *
  104. * Also used to show what's going on for debugging purposes when the
  105. * flag field is exported via the traceport interface
  106. */
  107. /* prefer goal again. length */
  108. #define EXT4_MB_HINT_MERGE 0x0001
  109. /* blocks already reserved */
  110. #define EXT4_MB_HINT_RESERVED 0x0002
  111. /* metadata is being allocated */
  112. #define EXT4_MB_HINT_METADATA 0x0004
  113. /* first blocks in the file */
  114. #define EXT4_MB_HINT_FIRST 0x0008
  115. /* search for the best chunk */
  116. #define EXT4_MB_HINT_BEST 0x0010
  117. /* data is being allocated */
  118. #define EXT4_MB_HINT_DATA 0x0020
  119. /* don't preallocate (for tails) */
  120. #define EXT4_MB_HINT_NOPREALLOC 0x0040
  121. /* allocate for locality group */
  122. #define EXT4_MB_HINT_GROUP_ALLOC 0x0080
  123. /* allocate goal blocks or none */
  124. #define EXT4_MB_HINT_GOAL_ONLY 0x0100
  125. /* goal is meaningful */
  126. #define EXT4_MB_HINT_TRY_GOAL 0x0200
  127. /* blocks already pre-reserved by delayed allocation */
  128. #define EXT4_MB_DELALLOC_RESERVED 0x0400
  129. /* We are doing stream allocation */
  130. #define EXT4_MB_STREAM_ALLOC 0x0800
  131. /* Use reserved root blocks if needed */
  132. #define EXT4_MB_USE_ROOT_BLOCKS 0x1000
  133. /* Use blocks from reserved pool */
  134. #define EXT4_MB_USE_RESERVED 0x2000
  135. /* Do strict check for free blocks while retrying block allocation */
  136. #define EXT4_MB_STRICT_CHECK 0x4000
  137. struct ext4_allocation_request {
  138. /* target inode for block we're allocating */
  139. struct inode *inode;
  140. /* how many blocks we want to allocate */
  141. unsigned int len;
  142. /* logical block in target inode */
  143. ext4_lblk_t logical;
  144. /* the closest logical allocated block to the left */
  145. ext4_lblk_t lleft;
  146. /* the closest logical allocated block to the right */
  147. ext4_lblk_t lright;
  148. /* phys. target (a hint) */
  149. ext4_fsblk_t goal;
  150. /* phys. block for the closest logical allocated block to the left */
  151. ext4_fsblk_t pleft;
  152. /* phys. block for the closest logical allocated block to the right */
  153. ext4_fsblk_t pright;
  154. /* flags. see above EXT4_MB_HINT_* */
  155. unsigned int flags;
  156. };
  157. /*
  158. * Logical to physical block mapping, used by ext4_map_blocks()
  159. *
  160. * This structure is used to pass requests into ext4_map_blocks() as
  161. * well as to store the information returned by ext4_map_blocks(). It
  162. * takes less room on the stack than a struct buffer_head.
  163. */
  164. #define EXT4_MAP_NEW BIT(BH_New)
  165. #define EXT4_MAP_MAPPED BIT(BH_Mapped)
  166. #define EXT4_MAP_UNWRITTEN BIT(BH_Unwritten)
  167. #define EXT4_MAP_BOUNDARY BIT(BH_Boundary)
  168. #define EXT4_MAP_FLAGS (EXT4_MAP_NEW | EXT4_MAP_MAPPED |\
  169. EXT4_MAP_UNWRITTEN | EXT4_MAP_BOUNDARY)
  170. struct ext4_map_blocks {
  171. ext4_fsblk_t m_pblk;
  172. ext4_lblk_t m_lblk;
  173. unsigned int m_len;
  174. unsigned int m_flags;
  175. };
  176. /*
  177. * Block validity checking, system zone rbtree.
  178. */
  179. struct ext4_system_blocks {
  180. struct rb_root root;
  181. struct rcu_head rcu;
  182. };
  183. /*
  184. * Flags for ext4_io_end->flags
  185. */
  186. #define EXT4_IO_END_UNWRITTEN 0x0001
  187. struct ext4_io_end_vec {
  188. struct list_head list; /* list of io_end_vec */
  189. loff_t offset; /* offset in the file */
  190. ssize_t size; /* size of the extent */
  191. };
  192. /*
  193. * For converting unwritten extents on a work queue. 'handle' is used for
  194. * buffered writeback.
  195. */
  196. typedef struct ext4_io_end {
  197. struct list_head list; /* per-file finished IO list */
  198. handle_t *handle; /* handle reserved for extent
  199. * conversion */
  200. struct inode *inode; /* file being written to */
  201. struct bio *bio; /* Linked list of completed
  202. * bios covering the extent */
  203. unsigned int flag; /* unwritten or not */
  204. atomic_t count; /* reference counter */
  205. struct list_head list_vec; /* list of ext4_io_end_vec */
  206. } ext4_io_end_t;
  207. struct ext4_io_submit {
  208. struct writeback_control *io_wbc;
  209. struct bio *io_bio;
  210. ext4_io_end_t *io_end;
  211. sector_t io_next_block;
  212. };
  213. /*
  214. * Special inodes numbers
  215. */
  216. #define EXT4_BAD_INO 1 /* Bad blocks inode */
  217. #define EXT4_ROOT_INO 2 /* Root inode */
  218. #define EXT4_USR_QUOTA_INO 3 /* User quota inode */
  219. #define EXT4_GRP_QUOTA_INO 4 /* Group quota inode */
  220. #define EXT4_BOOT_LOADER_INO 5 /* Boot loader inode */
  221. #define EXT4_UNDEL_DIR_INO 6 /* Undelete directory inode */
  222. #define EXT4_RESIZE_INO 7 /* Reserved group descriptors inode */
  223. #define EXT4_JOURNAL_INO 8 /* Journal inode */
  224. /* First non-reserved inode for old ext4 filesystems */
  225. #define EXT4_GOOD_OLD_FIRST_INO 11
  226. /*
  227. * Maximal count of links to a file
  228. */
  229. #define EXT4_LINK_MAX 65000
  230. /*
  231. * Macro-instructions used to manage several block sizes
  232. */
  233. #define EXT4_MIN_BLOCK_SIZE 1024
  234. #define EXT4_MAX_BLOCK_SIZE 65536
  235. #define EXT4_MIN_BLOCK_LOG_SIZE 10
  236. #define EXT4_MAX_BLOCK_LOG_SIZE 16
  237. #define EXT4_MAX_CLUSTER_LOG_SIZE 30
  238. #ifdef __KERNEL__
  239. # define EXT4_BLOCK_SIZE(s) ((s)->s_blocksize)
  240. #else
  241. # define EXT4_BLOCK_SIZE(s) (EXT4_MIN_BLOCK_SIZE << (s)->s_log_block_size)
  242. #endif
  243. #define EXT4_ADDR_PER_BLOCK(s) (EXT4_BLOCK_SIZE(s) / sizeof(__u32))
  244. #define EXT4_CLUSTER_SIZE(s) (EXT4_BLOCK_SIZE(s) << \
  245. EXT4_SB(s)->s_cluster_bits)
  246. #ifdef __KERNEL__
  247. # define EXT4_BLOCK_SIZE_BITS(s) ((s)->s_blocksize_bits)
  248. # define EXT4_CLUSTER_BITS(s) (EXT4_SB(s)->s_cluster_bits)
  249. #else
  250. # define EXT4_BLOCK_SIZE_BITS(s) ((s)->s_log_block_size + 10)
  251. #endif
  252. #ifdef __KERNEL__
  253. #define EXT4_ADDR_PER_BLOCK_BITS(s) (EXT4_SB(s)->s_addr_per_block_bits)
  254. #define EXT4_INODE_SIZE(s) (EXT4_SB(s)->s_inode_size)
  255. #define EXT4_FIRST_INO(s) (EXT4_SB(s)->s_first_ino)
  256. #else
  257. #define EXT4_INODE_SIZE(s) (((s)->s_rev_level == EXT4_GOOD_OLD_REV) ? \
  258. EXT4_GOOD_OLD_INODE_SIZE : \
  259. (s)->s_inode_size)
  260. #define EXT4_FIRST_INO(s) (((s)->s_rev_level == EXT4_GOOD_OLD_REV) ? \
  261. EXT4_GOOD_OLD_FIRST_INO : \
  262. (s)->s_first_ino)
  263. #endif
  264. #define EXT4_BLOCK_ALIGN(size, blkbits) ALIGN((size), (1 << (blkbits)))
  265. #define EXT4_MAX_BLOCKS(size, offset, blkbits) \
  266. ((EXT4_BLOCK_ALIGN(size + offset, blkbits) >> blkbits) - (offset >> \
  267. blkbits))
  268. /* Translate a block number to a cluster number */
  269. #define EXT4_B2C(sbi, blk) ((blk) >> (sbi)->s_cluster_bits)
  270. /* Translate a cluster number to a block number */
  271. #define EXT4_C2B(sbi, cluster) ((cluster) << (sbi)->s_cluster_bits)
  272. /* Translate # of blks to # of clusters */
  273. #define EXT4_NUM_B2C(sbi, blks) (((blks) + (sbi)->s_cluster_ratio - 1) >> \
  274. (sbi)->s_cluster_bits)
  275. /* Mask out the low bits to get the starting block of the cluster */
  276. #define EXT4_PBLK_CMASK(s, pblk) ((pblk) & \
  277. ~((ext4_fsblk_t) (s)->s_cluster_ratio - 1))
  278. #define EXT4_LBLK_CMASK(s, lblk) ((lblk) & \
  279. ~((ext4_lblk_t) (s)->s_cluster_ratio - 1))
  280. /* Fill in the low bits to get the last block of the cluster */
  281. #define EXT4_LBLK_CFILL(sbi, lblk) ((lblk) | \
  282. ((ext4_lblk_t) (sbi)->s_cluster_ratio - 1))
  283. /* Get the cluster offset */
  284. #define EXT4_PBLK_COFF(s, pblk) ((pblk) & \
  285. ((ext4_fsblk_t) (s)->s_cluster_ratio - 1))
  286. #define EXT4_LBLK_COFF(s, lblk) ((lblk) & \
  287. ((ext4_lblk_t) (s)->s_cluster_ratio - 1))
  288. /*
  289. * Structure of a blocks group descriptor
  290. */
  291. struct ext4_group_desc
  292. {
  293. __le32 bg_block_bitmap_lo; /* Blocks bitmap block */
  294. __le32 bg_inode_bitmap_lo; /* Inodes bitmap block */
  295. __le32 bg_inode_table_lo; /* Inodes table block */
  296. __le16 bg_free_blocks_count_lo;/* Free blocks count */
  297. __le16 bg_free_inodes_count_lo;/* Free inodes count */
  298. __le16 bg_used_dirs_count_lo; /* Directories count */
  299. __le16 bg_flags; /* EXT4_BG_flags (INODE_UNINIT, etc) */
  300. __le32 bg_exclude_bitmap_lo; /* Exclude bitmap for snapshots */
  301. __le16 bg_block_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+bbitmap) LE */
  302. __le16 bg_inode_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+ibitmap) LE */
  303. __le16 bg_itable_unused_lo; /* Unused inodes count */
  304. __le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
  305. __le32 bg_block_bitmap_hi; /* Blocks bitmap block MSB */
  306. __le32 bg_inode_bitmap_hi; /* Inodes bitmap block MSB */
  307. __le32 bg_inode_table_hi; /* Inodes table block MSB */
  308. __le16 bg_free_blocks_count_hi;/* Free blocks count MSB */
  309. __le16 bg_free_inodes_count_hi;/* Free inodes count MSB */
  310. __le16 bg_used_dirs_count_hi; /* Directories count MSB */
  311. __le16 bg_itable_unused_hi; /* Unused inodes count MSB */
  312. __le32 bg_exclude_bitmap_hi; /* Exclude bitmap block MSB */
  313. __le16 bg_block_bitmap_csum_hi;/* crc32c(s_uuid+grp_num+bbitmap) BE */
  314. __le16 bg_inode_bitmap_csum_hi;/* crc32c(s_uuid+grp_num+ibitmap) BE */
  315. __u32 bg_reserved;
  316. };
  317. #define EXT4_BG_INODE_BITMAP_CSUM_HI_END \
  318. (offsetof(struct ext4_group_desc, bg_inode_bitmap_csum_hi) + \
  319. sizeof(__le16))
  320. #define EXT4_BG_BLOCK_BITMAP_CSUM_HI_END \
  321. (offsetof(struct ext4_group_desc, bg_block_bitmap_csum_hi) + \
  322. sizeof(__le16))
  323. /*
  324. * Structure of a flex block group info
  325. */
  326. struct flex_groups {
  327. atomic64_t free_clusters;
  328. atomic_t free_inodes;
  329. atomic_t used_dirs;
  330. };
  331. #define EXT4_BG_INODE_UNINIT 0x0001 /* Inode table/bitmap not in use */
  332. #define EXT4_BG_BLOCK_UNINIT 0x0002 /* Block bitmap not in use */
  333. #define EXT4_BG_INODE_ZEROED 0x0004 /* On-disk itable initialized to zero */
  334. /*
  335. * Macro-instructions used to manage group descriptors
  336. */
  337. #define EXT4_MIN_DESC_SIZE 32
  338. #define EXT4_MIN_DESC_SIZE_64BIT 64
  339. #define EXT4_MAX_DESC_SIZE EXT4_MIN_BLOCK_SIZE
  340. #define EXT4_DESC_SIZE(s) (EXT4_SB(s)->s_desc_size)
  341. #ifdef __KERNEL__
  342. # define EXT4_BLOCKS_PER_GROUP(s) (EXT4_SB(s)->s_blocks_per_group)
  343. # define EXT4_CLUSTERS_PER_GROUP(s) (EXT4_SB(s)->s_clusters_per_group)
  344. # define EXT4_DESC_PER_BLOCK(s) (EXT4_SB(s)->s_desc_per_block)
  345. # define EXT4_INODES_PER_GROUP(s) (EXT4_SB(s)->s_inodes_per_group)
  346. # define EXT4_DESC_PER_BLOCK_BITS(s) (EXT4_SB(s)->s_desc_per_block_bits)
  347. #else
  348. # define EXT4_BLOCKS_PER_GROUP(s) ((s)->s_blocks_per_group)
  349. # define EXT4_DESC_PER_BLOCK(s) (EXT4_BLOCK_SIZE(s) / EXT4_DESC_SIZE(s))
  350. # define EXT4_INODES_PER_GROUP(s) ((s)->s_inodes_per_group)
  351. #endif
  352. /*
  353. * Constants relative to the data blocks
  354. */
  355. #define EXT4_NDIR_BLOCKS 12
  356. #define EXT4_IND_BLOCK EXT4_NDIR_BLOCKS
  357. #define EXT4_DIND_BLOCK (EXT4_IND_BLOCK + 1)
  358. #define EXT4_TIND_BLOCK (EXT4_DIND_BLOCK + 1)
  359. #define EXT4_N_BLOCKS (EXT4_TIND_BLOCK + 1)
  360. /*
  361. * Inode flags
  362. */
  363. #define EXT4_SECRM_FL 0x00000001 /* Secure deletion */
  364. #define EXT4_UNRM_FL 0x00000002 /* Undelete */
  365. #define EXT4_COMPR_FL 0x00000004 /* Compress file */
  366. #define EXT4_SYNC_FL 0x00000008 /* Synchronous updates */
  367. #define EXT4_IMMUTABLE_FL 0x00000010 /* Immutable file */
  368. #define EXT4_APPEND_FL 0x00000020 /* writes to file may only append */
  369. #define EXT4_NODUMP_FL 0x00000040 /* do not dump file */
  370. #define EXT4_NOATIME_FL 0x00000080 /* do not update atime */
  371. /* Reserved for compression usage... */
  372. #define EXT4_DIRTY_FL 0x00000100
  373. #define EXT4_COMPRBLK_FL 0x00000200 /* One or more compressed clusters */
  374. #define EXT4_NOCOMPR_FL 0x00000400 /* Don't compress */
  375. /* nb: was previously EXT2_ECOMPR_FL */
  376. #define EXT4_ENCRYPT_FL 0x00000800 /* encrypted file */
  377. /* End compression flags --- maybe not all used */
  378. #define EXT4_INDEX_FL 0x00001000 /* hash-indexed directory */
  379. #define EXT4_IMAGIC_FL 0x00002000 /* AFS directory */
  380. #define EXT4_JOURNAL_DATA_FL 0x00004000 /* file data should be journaled */
  381. #define EXT4_NOTAIL_FL 0x00008000 /* file tail should not be merged */
  382. #define EXT4_DIRSYNC_FL 0x00010000 /* dirsync behaviour (directories only) */
  383. #define EXT4_TOPDIR_FL 0x00020000 /* Top of directory hierarchies*/
  384. #define EXT4_HUGE_FILE_FL 0x00040000 /* Set to each huge file */
  385. #define EXT4_EXTENTS_FL 0x00080000 /* Inode uses extents */
  386. #define EXT4_VERITY_FL 0x00100000 /* Verity protected inode */
  387. #define EXT4_EA_INODE_FL 0x00200000 /* Inode used for large EA */
  388. /* 0x00400000 was formerly EXT4_EOFBLOCKS_FL */
  389. #define EXT4_DAX_FL 0x02000000 /* Inode is DAX */
  390. #define EXT4_INLINE_DATA_FL 0x10000000 /* Inode has inline data. */
  391. #define EXT4_PROJINHERIT_FL 0x20000000 /* Create with parents projid */
  392. #define EXT4_CASEFOLD_FL 0x40000000 /* Casefolded directory */
  393. #define EXT4_RESERVED_FL 0x80000000 /* reserved for ext4 lib */
  394. /* User modifiable flags */
  395. #define EXT4_FL_USER_MODIFIABLE (EXT4_SECRM_FL | \
  396. EXT4_UNRM_FL | \
  397. EXT4_COMPR_FL | \
  398. EXT4_SYNC_FL | \
  399. EXT4_IMMUTABLE_FL | \
  400. EXT4_APPEND_FL | \
  401. EXT4_NODUMP_FL | \
  402. EXT4_NOATIME_FL | \
  403. EXT4_JOURNAL_DATA_FL | \
  404. EXT4_NOTAIL_FL | \
  405. EXT4_DIRSYNC_FL | \
  406. EXT4_TOPDIR_FL | \
  407. EXT4_EXTENTS_FL | \
  408. 0x00400000 /* EXT4_EOFBLOCKS_FL */ | \
  409. EXT4_DAX_FL | \
  410. EXT4_PROJINHERIT_FL | \
  411. EXT4_CASEFOLD_FL)
  412. /* User visible flags */
  413. #define EXT4_FL_USER_VISIBLE (EXT4_FL_USER_MODIFIABLE | \
  414. EXT4_DIRTY_FL | \
  415. EXT4_COMPRBLK_FL | \
  416. EXT4_NOCOMPR_FL | \
  417. EXT4_ENCRYPT_FL | \
  418. EXT4_INDEX_FL | \
  419. EXT4_VERITY_FL | \
  420. EXT4_INLINE_DATA_FL)
  421. /* Flags we can manipulate with through FS_IOC_FSSETXATTR */
  422. #define EXT4_FL_XFLAG_VISIBLE (EXT4_SYNC_FL | \
  423. EXT4_IMMUTABLE_FL | \
  424. EXT4_APPEND_FL | \
  425. EXT4_NODUMP_FL | \
  426. EXT4_NOATIME_FL | \
  427. EXT4_PROJINHERIT_FL | \
  428. EXT4_DAX_FL)
  429. /* Flags that should be inherited by new inodes from their parent. */
  430. #define EXT4_FL_INHERITED (EXT4_SECRM_FL | EXT4_UNRM_FL | EXT4_COMPR_FL |\
  431. EXT4_SYNC_FL | EXT4_NODUMP_FL | EXT4_NOATIME_FL |\
  432. EXT4_NOCOMPR_FL | EXT4_JOURNAL_DATA_FL |\
  433. EXT4_NOTAIL_FL | EXT4_DIRSYNC_FL |\
  434. EXT4_PROJINHERIT_FL | EXT4_CASEFOLD_FL |\
  435. EXT4_DAX_FL)
  436. /* Flags that are appropriate for regular files (all but dir-specific ones). */
  437. #define EXT4_REG_FLMASK (~(EXT4_DIRSYNC_FL | EXT4_TOPDIR_FL | EXT4_CASEFOLD_FL |\
  438. EXT4_PROJINHERIT_FL))
  439. /* Flags that are appropriate for non-directories/regular files. */
  440. #define EXT4_OTHER_FLMASK (EXT4_NODUMP_FL | EXT4_NOATIME_FL)
  441. /* The only flags that should be swapped */
  442. #define EXT4_FL_SHOULD_SWAP (EXT4_HUGE_FILE_FL | EXT4_EXTENTS_FL)
  443. /* Flags which are mutually exclusive to DAX */
  444. #define EXT4_DAX_MUT_EXCL (EXT4_VERITY_FL | EXT4_ENCRYPT_FL |\
  445. EXT4_JOURNAL_DATA_FL | EXT4_INLINE_DATA_FL)
  446. /* Mask out flags that are inappropriate for the given type of inode. */
  447. static inline __u32 ext4_mask_flags(umode_t mode, __u32 flags)
  448. {
  449. if (S_ISDIR(mode))
  450. return flags;
  451. else if (S_ISREG(mode))
  452. return flags & EXT4_REG_FLMASK;
  453. else
  454. return flags & EXT4_OTHER_FLMASK;
  455. }
  456. /*
  457. * Inode flags used for atomic set/get
  458. */
  459. enum {
  460. EXT4_INODE_SECRM = 0, /* Secure deletion */
  461. EXT4_INODE_UNRM = 1, /* Undelete */
  462. EXT4_INODE_COMPR = 2, /* Compress file */
  463. EXT4_INODE_SYNC = 3, /* Synchronous updates */
  464. EXT4_INODE_IMMUTABLE = 4, /* Immutable file */
  465. EXT4_INODE_APPEND = 5, /* writes to file may only append */
  466. EXT4_INODE_NODUMP = 6, /* do not dump file */
  467. EXT4_INODE_NOATIME = 7, /* do not update atime */
  468. /* Reserved for compression usage... */
  469. EXT4_INODE_DIRTY = 8,
  470. EXT4_INODE_COMPRBLK = 9, /* One or more compressed clusters */
  471. EXT4_INODE_NOCOMPR = 10, /* Don't compress */
  472. EXT4_INODE_ENCRYPT = 11, /* Encrypted file */
  473. /* End compression flags --- maybe not all used */
  474. EXT4_INODE_INDEX = 12, /* hash-indexed directory */
  475. EXT4_INODE_IMAGIC = 13, /* AFS directory */
  476. EXT4_INODE_JOURNAL_DATA = 14, /* file data should be journaled */
  477. EXT4_INODE_NOTAIL = 15, /* file tail should not be merged */
  478. EXT4_INODE_DIRSYNC = 16, /* dirsync behaviour (directories only) */
  479. EXT4_INODE_TOPDIR = 17, /* Top of directory hierarchies*/
  480. EXT4_INODE_HUGE_FILE = 18, /* Set to each huge file */
  481. EXT4_INODE_EXTENTS = 19, /* Inode uses extents */
  482. EXT4_INODE_VERITY = 20, /* Verity protected inode */
  483. EXT4_INODE_EA_INODE = 21, /* Inode used for large EA */
  484. /* 22 was formerly EXT4_INODE_EOFBLOCKS */
  485. EXT4_INODE_DAX = 25, /* Inode is DAX */
  486. EXT4_INODE_INLINE_DATA = 28, /* Data in inode. */
  487. EXT4_INODE_PROJINHERIT = 29, /* Create with parents projid */
  488. EXT4_INODE_CASEFOLD = 30, /* Casefolded directory */
  489. EXT4_INODE_RESERVED = 31, /* reserved for ext4 lib */
  490. };
  491. /*
  492. * Since it's pretty easy to mix up bit numbers and hex values, we use a
  493. * build-time check to make sure that EXT4_XXX_FL is consistent with respect to
  494. * EXT4_INODE_XXX. If all is well, the macros will be dropped, so, it won't cost
  495. * any extra space in the compiled kernel image, otherwise, the build will fail.
  496. * It's important that these values are the same, since we are using
  497. * EXT4_INODE_XXX to test for flag values, but EXT4_XXX_FL must be consistent
  498. * with the values of FS_XXX_FL defined in include/linux/fs.h and the on-disk
  499. * values found in ext2, ext3 and ext4 filesystems, and of course the values
  500. * defined in e2fsprogs.
  501. *
  502. * It's not paranoia if the Murphy's Law really *is* out to get you. :-)
  503. */
  504. #define TEST_FLAG_VALUE(FLAG) (EXT4_##FLAG##_FL == (1 << EXT4_INODE_##FLAG))
  505. #define CHECK_FLAG_VALUE(FLAG) BUILD_BUG_ON(!TEST_FLAG_VALUE(FLAG))
  506. static inline void ext4_check_flag_values(void)
  507. {
  508. CHECK_FLAG_VALUE(SECRM);
  509. CHECK_FLAG_VALUE(UNRM);
  510. CHECK_FLAG_VALUE(COMPR);
  511. CHECK_FLAG_VALUE(SYNC);
  512. CHECK_FLAG_VALUE(IMMUTABLE);
  513. CHECK_FLAG_VALUE(APPEND);
  514. CHECK_FLAG_VALUE(NODUMP);
  515. CHECK_FLAG_VALUE(NOATIME);
  516. CHECK_FLAG_VALUE(DIRTY);
  517. CHECK_FLAG_VALUE(COMPRBLK);
  518. CHECK_FLAG_VALUE(NOCOMPR);
  519. CHECK_FLAG_VALUE(ENCRYPT);
  520. CHECK_FLAG_VALUE(INDEX);
  521. CHECK_FLAG_VALUE(IMAGIC);
  522. CHECK_FLAG_VALUE(JOURNAL_DATA);
  523. CHECK_FLAG_VALUE(NOTAIL);
  524. CHECK_FLAG_VALUE(DIRSYNC);
  525. CHECK_FLAG_VALUE(TOPDIR);
  526. CHECK_FLAG_VALUE(HUGE_FILE);
  527. CHECK_FLAG_VALUE(EXTENTS);
  528. CHECK_FLAG_VALUE(VERITY);
  529. CHECK_FLAG_VALUE(EA_INODE);
  530. CHECK_FLAG_VALUE(INLINE_DATA);
  531. CHECK_FLAG_VALUE(PROJINHERIT);
  532. CHECK_FLAG_VALUE(CASEFOLD);
  533. CHECK_FLAG_VALUE(RESERVED);
  534. }
  535. /* Used to pass group descriptor data when online resize is done */
  536. struct ext4_new_group_input {
  537. __u32 group; /* Group number for this data */
  538. __u64 block_bitmap; /* Absolute block number of block bitmap */
  539. __u64 inode_bitmap; /* Absolute block number of inode bitmap */
  540. __u64 inode_table; /* Absolute block number of inode table start */
  541. __u32 blocks_count; /* Total number of blocks in this group */
  542. __u16 reserved_blocks; /* Number of reserved blocks in this group */
  543. __u16 unused;
  544. };
  545. #if defined(__KERNEL__) && defined(CONFIG_COMPAT)
  546. struct compat_ext4_new_group_input {
  547. u32 group;
  548. compat_u64 block_bitmap;
  549. compat_u64 inode_bitmap;
  550. compat_u64 inode_table;
  551. u32 blocks_count;
  552. u16 reserved_blocks;
  553. u16 unused;
  554. };
  555. #endif
  556. /* The struct ext4_new_group_input in kernel space, with free_blocks_count */
  557. struct ext4_new_group_data {
  558. __u32 group;
  559. __u64 block_bitmap;
  560. __u64 inode_bitmap;
  561. __u64 inode_table;
  562. __u32 blocks_count;
  563. __u16 reserved_blocks;
  564. __u16 mdata_blocks;
  565. __u32 free_clusters_count;
  566. };
  567. /* Indexes used to index group tables in ext4_new_group_data */
  568. enum {
  569. BLOCK_BITMAP = 0, /* block bitmap */
  570. INODE_BITMAP, /* inode bitmap */
  571. INODE_TABLE, /* inode tables */
  572. GROUP_TABLE_COUNT,
  573. };
  574. /*
  575. * Flags used by ext4_map_blocks()
  576. */
  577. /* Allocate any needed blocks and/or convert an unwritten
  578. extent to be an initialized ext4 */
  579. #define EXT4_GET_BLOCKS_CREATE 0x0001
  580. /* Request the creation of an unwritten extent */
  581. #define EXT4_GET_BLOCKS_UNWRIT_EXT 0x0002
  582. #define EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT (EXT4_GET_BLOCKS_UNWRIT_EXT|\
  583. EXT4_GET_BLOCKS_CREATE)
  584. /* Caller is from the delayed allocation writeout path
  585. * finally doing the actual allocation of delayed blocks */
  586. #define EXT4_GET_BLOCKS_DELALLOC_RESERVE 0x0004
  587. /* caller is from the direct IO path, request to creation of an
  588. unwritten extents if not allocated, split the unwritten
  589. extent if blocks has been preallocated already*/
  590. #define EXT4_GET_BLOCKS_PRE_IO 0x0008
  591. #define EXT4_GET_BLOCKS_CONVERT 0x0010
  592. #define EXT4_GET_BLOCKS_IO_CREATE_EXT (EXT4_GET_BLOCKS_PRE_IO|\
  593. EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT)
  594. /* Convert extent to initialized after IO complete */
  595. #define EXT4_GET_BLOCKS_IO_CONVERT_EXT (EXT4_GET_BLOCKS_CONVERT|\
  596. EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT)
  597. /* Eventual metadata allocation (due to growing extent tree)
  598. * should not fail, so try to use reserved blocks for that.*/
  599. #define EXT4_GET_BLOCKS_METADATA_NOFAIL 0x0020
  600. /* Don't normalize allocation size (used for fallocate) */
  601. #define EXT4_GET_BLOCKS_NO_NORMALIZE 0x0040
  602. /* Convert written extents to unwritten */
  603. #define EXT4_GET_BLOCKS_CONVERT_UNWRITTEN 0x0100
  604. /* Write zeros to newly created written extents */
  605. #define EXT4_GET_BLOCKS_ZERO 0x0200
  606. #define EXT4_GET_BLOCKS_CREATE_ZERO (EXT4_GET_BLOCKS_CREATE |\
  607. EXT4_GET_BLOCKS_ZERO)
  608. /* Caller will submit data before dropping transaction handle. This
  609. * allows jbd2 to avoid submitting data before commit. */
  610. #define EXT4_GET_BLOCKS_IO_SUBMIT 0x0400
  611. /*
  612. * The bit position of these flags must not overlap with any of the
  613. * EXT4_GET_BLOCKS_*. They are used by ext4_find_extent(),
  614. * read_extent_tree_block(), ext4_split_extent_at(),
  615. * ext4_ext_insert_extent(), and ext4_ext_create_new_leaf().
  616. * EXT4_EX_NOCACHE is used to indicate that the we shouldn't be
  617. * caching the extents when reading from the extent tree while a
  618. * truncate or punch hole operation is in progress.
  619. */
  620. #define EXT4_EX_NOCACHE 0x40000000
  621. #define EXT4_EX_FORCE_CACHE 0x20000000
  622. #define EXT4_EX_NOFAIL 0x10000000
  623. /*
  624. * Flags used by ext4_free_blocks
  625. */
  626. #define EXT4_FREE_BLOCKS_METADATA 0x0001
  627. #define EXT4_FREE_BLOCKS_FORGET 0x0002
  628. #define EXT4_FREE_BLOCKS_VALIDATED 0x0004
  629. #define EXT4_FREE_BLOCKS_NO_QUOT_UPDATE 0x0008
  630. #define EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER 0x0010
  631. #define EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER 0x0020
  632. #define EXT4_FREE_BLOCKS_RERESERVE_CLUSTER 0x0040
  633. /*
  634. * ioctl commands
  635. */
  636. #define EXT4_IOC_GETVERSION _IOR('f', 3, long)
  637. #define EXT4_IOC_SETVERSION _IOW('f', 4, long)
  638. #define EXT4_IOC_GETVERSION_OLD FS_IOC_GETVERSION
  639. #define EXT4_IOC_SETVERSION_OLD FS_IOC_SETVERSION
  640. #define EXT4_IOC_GETRSVSZ _IOR('f', 5, long)
  641. #define EXT4_IOC_SETRSVSZ _IOW('f', 6, long)
  642. #define EXT4_IOC_GROUP_EXTEND _IOW('f', 7, unsigned long)
  643. #define EXT4_IOC_GROUP_ADD _IOW('f', 8, struct ext4_new_group_input)
  644. #define EXT4_IOC_MIGRATE _IO('f', 9)
  645. /* note ioctl 10 reserved for an early version of the FIEMAP ioctl */
  646. /* note ioctl 11 reserved for filesystem-independent FIEMAP ioctl */
  647. #define EXT4_IOC_ALLOC_DA_BLKS _IO('f', 12)
  648. #define EXT4_IOC_MOVE_EXT _IOWR('f', 15, struct move_extent)
  649. #define EXT4_IOC_RESIZE_FS _IOW('f', 16, __u64)
  650. #define EXT4_IOC_SWAP_BOOT _IO('f', 17)
  651. #define EXT4_IOC_PRECACHE_EXTENTS _IO('f', 18)
  652. /* ioctl codes 19--39 are reserved for fscrypt */
  653. #define EXT4_IOC_CLEAR_ES_CACHE _IO('f', 40)
  654. #define EXT4_IOC_GETSTATE _IOW('f', 41, __u32)
  655. #define EXT4_IOC_GET_ES_CACHE _IOWR('f', 42, struct fiemap)
  656. #define EXT4_IOC_SHUTDOWN _IOR ('X', 125, __u32)
  657. /*
  658. * Flags for going down operation
  659. */
  660. #define EXT4_GOING_FLAGS_DEFAULT 0x0 /* going down */
  661. #define EXT4_GOING_FLAGS_LOGFLUSH 0x1 /* flush log but not data */
  662. #define EXT4_GOING_FLAGS_NOLOGFLUSH 0x2 /* don't flush log nor data */
  663. /*
  664. * Flags returned by EXT4_IOC_GETSTATE
  665. *
  666. * We only expose to userspace a subset of the state flags in
  667. * i_state_flags
  668. */
  669. #define EXT4_STATE_FLAG_EXT_PRECACHED 0x00000001
  670. #define EXT4_STATE_FLAG_NEW 0x00000002
  671. #define EXT4_STATE_FLAG_NEWENTRY 0x00000004
  672. #define EXT4_STATE_FLAG_DA_ALLOC_CLOSE 0x00000008
  673. #if defined(__KERNEL__) && defined(CONFIG_COMPAT)
  674. /*
  675. * ioctl commands in 32 bit emulation
  676. */
  677. #define EXT4_IOC32_GETVERSION _IOR('f', 3, int)
  678. #define EXT4_IOC32_SETVERSION _IOW('f', 4, int)
  679. #define EXT4_IOC32_GETRSVSZ _IOR('f', 5, int)
  680. #define EXT4_IOC32_SETRSVSZ _IOW('f', 6, int)
  681. #define EXT4_IOC32_GROUP_EXTEND _IOW('f', 7, unsigned int)
  682. #define EXT4_IOC32_GROUP_ADD _IOW('f', 8, struct compat_ext4_new_group_input)
  683. #define EXT4_IOC32_GETVERSION_OLD FS_IOC32_GETVERSION
  684. #define EXT4_IOC32_SETVERSION_OLD FS_IOC32_SETVERSION
  685. #endif
  686. /*
  687. * Returned by EXT4_IOC_GET_ES_CACHE as an additional possible flag.
  688. * It indicates that the entry in extent status cache is for a hole.
  689. */
  690. #define EXT4_FIEMAP_EXTENT_HOLE 0x08000000
  691. /* Max physical block we can address w/o extents */
  692. #define EXT4_MAX_BLOCK_FILE_PHYS 0xFFFFFFFF
  693. /* Max logical block we can support */
  694. #define EXT4_MAX_LOGICAL_BLOCK 0xFFFFFFFE
  695. /*
  696. * Structure of an inode on the disk
  697. */
  698. struct ext4_inode {
  699. __le16 i_mode; /* File mode */
  700. __le16 i_uid; /* Low 16 bits of Owner Uid */
  701. __le32 i_size_lo; /* Size in bytes */
  702. __le32 i_atime; /* Access time */
  703. __le32 i_ctime; /* Inode Change time */
  704. __le32 i_mtime; /* Modification time */
  705. __le32 i_dtime; /* Deletion Time */
  706. __le16 i_gid; /* Low 16 bits of Group Id */
  707. __le16 i_links_count; /* Links count */
  708. __le32 i_blocks_lo; /* Blocks count */
  709. __le32 i_flags; /* File flags */
  710. union {
  711. struct {
  712. __le32 l_i_version;
  713. } linux1;
  714. struct {
  715. __u32 h_i_translator;
  716. } hurd1;
  717. struct {
  718. __u32 m_i_reserved1;
  719. } masix1;
  720. } osd1; /* OS dependent 1 */
  721. __le32 i_block[EXT4_N_BLOCKS];/* Pointers to blocks */
  722. __le32 i_generation; /* File version (for NFS) */
  723. __le32 i_file_acl_lo; /* File ACL */
  724. __le32 i_size_high;
  725. __le32 i_obso_faddr; /* Obsoleted fragment address */
  726. union {
  727. struct {
  728. __le16 l_i_blocks_high; /* were l_i_reserved1 */
  729. __le16 l_i_file_acl_high;
  730. __le16 l_i_uid_high; /* these 2 fields */
  731. __le16 l_i_gid_high; /* were reserved2[0] */
  732. __le16 l_i_checksum_lo;/* crc32c(uuid+inum+inode) LE */
  733. __le16 l_i_reserved;
  734. } linux2;
  735. struct {
  736. __le16 h_i_reserved1; /* Obsoleted fragment number/size which are removed in ext4 */
  737. __u16 h_i_mode_high;
  738. __u16 h_i_uid_high;
  739. __u16 h_i_gid_high;
  740. __u32 h_i_author;
  741. } hurd2;
  742. struct {
  743. __le16 h_i_reserved1; /* Obsoleted fragment number/size which are removed in ext4 */
  744. __le16 m_i_file_acl_high;
  745. __u32 m_i_reserved2[2];
  746. } masix2;
  747. } osd2; /* OS dependent 2 */
  748. __le16 i_extra_isize;
  749. __le16 i_checksum_hi; /* crc32c(uuid+inum+inode) BE */
  750. __le32 i_ctime_extra; /* extra Change time (nsec << 2 | epoch) */
  751. __le32 i_mtime_extra; /* extra Modification time(nsec << 2 | epoch) */
  752. __le32 i_atime_extra; /* extra Access time (nsec << 2 | epoch) */
  753. __le32 i_crtime; /* File Creation time */
  754. __le32 i_crtime_extra; /* extra FileCreationtime (nsec << 2 | epoch) */
  755. __le32 i_version_hi; /* high 32 bits for 64-bit version */
  756. __le32 i_projid; /* Project ID */
  757. };
  758. struct move_extent {
  759. __u32 reserved; /* should be zero */
  760. __u32 donor_fd; /* donor file descriptor */
  761. __u64 orig_start; /* logical start offset in block for orig */
  762. __u64 donor_start; /* logical start offset in block for donor */
  763. __u64 len; /* block length to be moved */
  764. __u64 moved_len; /* moved block length */
  765. };
  766. #define EXT4_EPOCH_BITS 2
  767. #define EXT4_EPOCH_MASK ((1 << EXT4_EPOCH_BITS) - 1)
  768. #define EXT4_NSEC_MASK (~0UL << EXT4_EPOCH_BITS)
  769. /*
  770. * Extended fields will fit into an inode if the filesystem was formatted
  771. * with large inodes (-I 256 or larger) and there are not currently any EAs
  772. * consuming all of the available space. For new inodes we always reserve
  773. * enough space for the kernel's known extended fields, but for inodes
  774. * created with an old kernel this might not have been the case. None of
  775. * the extended inode fields is critical for correct filesystem operation.
  776. * This macro checks if a certain field fits in the inode. Note that
  777. * inode-size = GOOD_OLD_INODE_SIZE + i_extra_isize
  778. */
  779. #define EXT4_FITS_IN_INODE(ext4_inode, einode, field) \
  780. ((offsetof(typeof(*ext4_inode), field) + \
  781. sizeof((ext4_inode)->field)) \
  782. <= (EXT4_GOOD_OLD_INODE_SIZE + \
  783. (einode)->i_extra_isize)) \
  784. /*
  785. * We use an encoding that preserves the times for extra epoch "00":
  786. *
  787. * extra msb of adjust for signed
  788. * epoch 32-bit 32-bit tv_sec to
  789. * bits time decoded 64-bit tv_sec 64-bit tv_sec valid time range
  790. * 0 0 1 -0x80000000..-0x00000001 0x000000000 1901-12-13..1969-12-31
  791. * 0 0 0 0x000000000..0x07fffffff 0x000000000 1970-01-01..2038-01-19
  792. * 0 1 1 0x080000000..0x0ffffffff 0x100000000 2038-01-19..2106-02-07
  793. * 0 1 0 0x100000000..0x17fffffff 0x100000000 2106-02-07..2174-02-25
  794. * 1 0 1 0x180000000..0x1ffffffff 0x200000000 2174-02-25..2242-03-16
  795. * 1 0 0 0x200000000..0x27fffffff 0x200000000 2242-03-16..2310-04-04
  796. * 1 1 1 0x280000000..0x2ffffffff 0x300000000 2310-04-04..2378-04-22
  797. * 1 1 0 0x300000000..0x37fffffff 0x300000000 2378-04-22..2446-05-10
  798. *
  799. * Note that previous versions of the kernel on 64-bit systems would
  800. * incorrectly use extra epoch bits 1,1 for dates between 1901 and
  801. * 1970. e2fsck will correct this, assuming that it is run on the
  802. * affected filesystem before 2242.
  803. */
  804. static inline __le32 ext4_encode_extra_time(struct timespec64 *time)
  805. {
  806. u32 extra =((time->tv_sec - (s32)time->tv_sec) >> 32) & EXT4_EPOCH_MASK;
  807. return cpu_to_le32(extra | (time->tv_nsec << EXT4_EPOCH_BITS));
  808. }
  809. static inline void ext4_decode_extra_time(struct timespec64 *time,
  810. __le32 extra)
  811. {
  812. if (unlikely(extra & cpu_to_le32(EXT4_EPOCH_MASK)))
  813. time->tv_sec += (u64)(le32_to_cpu(extra) & EXT4_EPOCH_MASK) << 32;
  814. time->tv_nsec = (le32_to_cpu(extra) & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
  815. }
  816. #define EXT4_INODE_SET_XTIME(xtime, inode, raw_inode) \
  817. do { \
  818. if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra)) {\
  819. (raw_inode)->xtime = cpu_to_le32((inode)->xtime.tv_sec); \
  820. (raw_inode)->xtime ## _extra = \
  821. ext4_encode_extra_time(&(inode)->xtime); \
  822. } \
  823. else \
  824. (raw_inode)->xtime = cpu_to_le32(clamp_t(int32_t, (inode)->xtime.tv_sec, S32_MIN, S32_MAX)); \
  825. } while (0)
  826. #define EXT4_EINODE_SET_XTIME(xtime, einode, raw_inode) \
  827. do { \
  828. if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime)) \
  829. (raw_inode)->xtime = cpu_to_le32((einode)->xtime.tv_sec); \
  830. if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime ## _extra)) \
  831. (raw_inode)->xtime ## _extra = \
  832. ext4_encode_extra_time(&(einode)->xtime); \
  833. } while (0)
  834. #define EXT4_INODE_GET_XTIME(xtime, inode, raw_inode) \
  835. do { \
  836. (inode)->xtime.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime); \
  837. if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra)) { \
  838. ext4_decode_extra_time(&(inode)->xtime, \
  839. raw_inode->xtime ## _extra); \
  840. } \
  841. else \
  842. (inode)->xtime.tv_nsec = 0; \
  843. } while (0)
  844. #define EXT4_EINODE_GET_XTIME(xtime, einode, raw_inode) \
  845. do { \
  846. if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime)) \
  847. (einode)->xtime.tv_sec = \
  848. (signed)le32_to_cpu((raw_inode)->xtime); \
  849. else \
  850. (einode)->xtime.tv_sec = 0; \
  851. if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime ## _extra)) \
  852. ext4_decode_extra_time(&(einode)->xtime, \
  853. raw_inode->xtime ## _extra); \
  854. else \
  855. (einode)->xtime.tv_nsec = 0; \
  856. } while (0)
  857. #define i_disk_version osd1.linux1.l_i_version
  858. #if defined(__KERNEL__) || defined(__linux__)
  859. #define i_reserved1 osd1.linux1.l_i_reserved1
  860. #define i_file_acl_high osd2.linux2.l_i_file_acl_high
  861. #define i_blocks_high osd2.linux2.l_i_blocks_high
  862. #define i_uid_low i_uid
  863. #define i_gid_low i_gid
  864. #define i_uid_high osd2.linux2.l_i_uid_high
  865. #define i_gid_high osd2.linux2.l_i_gid_high
  866. #define i_checksum_lo osd2.linux2.l_i_checksum_lo
  867. #elif defined(__GNU__)
  868. #define i_translator osd1.hurd1.h_i_translator
  869. #define i_uid_high osd2.hurd2.h_i_uid_high
  870. #define i_gid_high osd2.hurd2.h_i_gid_high
  871. #define i_author osd2.hurd2.h_i_author
  872. #elif defined(__masix__)
  873. #define i_reserved1 osd1.masix1.m_i_reserved1
  874. #define i_file_acl_high osd2.masix2.m_i_file_acl_high
  875. #define i_reserved2 osd2.masix2.m_i_reserved2
  876. #endif /* defined(__KERNEL__) || defined(__linux__) */
  877. #include "extents_status.h"
  878. #include "fast_commit.h"
  879. /*
  880. * Lock subclasses for i_data_sem in the ext4_inode_info structure.
  881. *
  882. * These are needed to avoid lockdep false positives when we need to
  883. * allocate blocks to the quota inode during ext4_map_blocks(), while
  884. * holding i_data_sem for a normal (non-quota) inode. Since we don't
  885. * do quota tracking for the quota inode, this avoids deadlock (as
  886. * well as infinite recursion, since it isn't turtles all the way
  887. * down...)
  888. *
  889. * I_DATA_SEM_NORMAL - Used for most inodes
  890. * I_DATA_SEM_OTHER - Used by move_inode.c for the second normal inode
  891. * where the second inode has larger inode number
  892. * than the first
  893. * I_DATA_SEM_QUOTA - Used for quota inodes only
  894. */
  895. enum {
  896. I_DATA_SEM_NORMAL = 0,
  897. I_DATA_SEM_OTHER,
  898. I_DATA_SEM_QUOTA,
  899. };
  900. /*
  901. * fourth extended file system inode data in memory
  902. */
  903. struct ext4_inode_info {
  904. __le32 i_data[15]; /* unconverted */
  905. __u32 i_dtime;
  906. ext4_fsblk_t i_file_acl;
  907. /*
  908. * i_block_group is the number of the block group which contains
  909. * this file's inode. Constant across the lifetime of the inode,
  910. * it is used for making block allocation decisions - we try to
  911. * place a file's data blocks near its inode block, and new inodes
  912. * near to their parent directory's inode.
  913. */
  914. ext4_group_t i_block_group;
  915. ext4_lblk_t i_dir_start_lookup;
  916. #if (BITS_PER_LONG < 64)
  917. unsigned long i_state_flags; /* Dynamic state flags */
  918. #endif
  919. unsigned long i_flags;
  920. /*
  921. * Extended attributes can be read independently of the main file
  922. * data. Taking i_mutex even when reading would cause contention
  923. * between readers of EAs and writers of regular file data, so
  924. * instead we synchronize on xattr_sem when reading or changing
  925. * EAs.
  926. */
  927. struct rw_semaphore xattr_sem;
  928. struct list_head i_orphan; /* unlinked but open inodes */
  929. /* Fast commit related info */
  930. struct list_head i_fc_list; /*
  931. * inodes that need fast commit
  932. * protected by sbi->s_fc_lock.
  933. */
  934. /* Start of lblk range that needs to be committed in this fast commit */
  935. ext4_lblk_t i_fc_lblk_start;
  936. /* End of lblk range that needs to be committed in this fast commit */
  937. ext4_lblk_t i_fc_lblk_len;
  938. /* Number of ongoing updates on this inode */
  939. atomic_t i_fc_updates;
  940. /* Fast commit wait queue for this inode */
  941. wait_queue_head_t i_fc_wait;
  942. /* Protect concurrent accesses on i_fc_lblk_start, i_fc_lblk_len */
  943. struct mutex i_fc_lock;
  944. /*
  945. * i_disksize keeps track of what the inode size is ON DISK, not
  946. * in memory. During truncate, i_size is set to the new size by
  947. * the VFS prior to calling ext4_truncate(), but the filesystem won't
  948. * set i_disksize to 0 until the truncate is actually under way.
  949. *
  950. * The intent is that i_disksize always represents the blocks which
  951. * are used by this file. This allows recovery to restart truncate
  952. * on orphans if we crash during truncate. We actually write i_disksize
  953. * into the on-disk inode when writing inodes out, instead of i_size.
  954. *
  955. * The only time when i_disksize and i_size may be different is when
  956. * a truncate is in progress. The only things which change i_disksize
  957. * are ext4_get_block (growth) and ext4_truncate (shrinkth).
  958. */
  959. loff_t i_disksize;
  960. /*
  961. * i_data_sem is for serialising ext4_truncate() against
  962. * ext4_getblock(). In the 2.4 ext2 design, great chunks of inode's
  963. * data tree are chopped off during truncate. We can't do that in
  964. * ext4 because whenever we perform intermediate commits during
  965. * truncate, the inode and all the metadata blocks *must* be in a
  966. * consistent state which allows truncation of the orphans to restart
  967. * during recovery. Hence we must fix the get_block-vs-truncate race
  968. * by other means, so we have i_data_sem.
  969. */
  970. struct rw_semaphore i_data_sem;
  971. /*
  972. * i_mmap_sem is for serializing page faults with truncate / punch hole
  973. * operations. We have to make sure that new page cannot be faulted in
  974. * a section of the inode that is being punched. We cannot easily use
  975. * i_data_sem for this since we need protection for the whole punch
  976. * operation and i_data_sem ranks below transaction start so we have
  977. * to occasionally drop it.
  978. */
  979. struct rw_semaphore i_mmap_sem;
  980. struct inode vfs_inode;
  981. struct jbd2_inode *jinode;
  982. spinlock_t i_raw_lock; /* protects updates to the raw inode */
  983. /*
  984. * File creation time. Its function is same as that of
  985. * struct timespec64 i_{a,c,m}time in the generic inode.
  986. */
  987. struct timespec64 i_crtime;
  988. /* mballoc */
  989. atomic_t i_prealloc_active;
  990. struct list_head i_prealloc_list;
  991. spinlock_t i_prealloc_lock;
  992. /* extents status tree */
  993. struct ext4_es_tree i_es_tree;
  994. rwlock_t i_es_lock;
  995. struct list_head i_es_list;
  996. unsigned int i_es_all_nr; /* protected by i_es_lock */
  997. unsigned int i_es_shk_nr; /* protected by i_es_lock */
  998. ext4_lblk_t i_es_shrink_lblk; /* Offset where we start searching for
  999. extents to shrink. Protected by
  1000. i_es_lock */
  1001. /* ialloc */
  1002. ext4_group_t i_last_alloc_group;
  1003. /* allocation reservation info for delalloc */
  1004. /* In case of bigalloc, this refer to clusters rather than blocks */
  1005. unsigned int i_reserved_data_blocks;
  1006. /* pending cluster reservations for bigalloc file systems */
  1007. struct ext4_pending_tree i_pending_tree;
  1008. /* on-disk additional length */
  1009. __u16 i_extra_isize;
  1010. /* Indicate the inline data space. */
  1011. u16 i_inline_off;
  1012. u16 i_inline_size;
  1013. #ifdef CONFIG_QUOTA
  1014. /* quota space reservation, managed internally by quota code */
  1015. qsize_t i_reserved_quota;
  1016. #endif
  1017. /* Lock protecting lists below */
  1018. spinlock_t i_completed_io_lock;
  1019. /*
  1020. * Completed IOs that need unwritten extents handling and have
  1021. * transaction reserved
  1022. */
  1023. struct list_head i_rsv_conversion_list;
  1024. struct work_struct i_rsv_conversion_work;
  1025. atomic_t i_unwritten; /* Nr. of inflight conversions pending */
  1026. spinlock_t i_block_reservation_lock;
  1027. /*
  1028. * Transactions that contain inode's metadata needed to complete
  1029. * fsync and fdatasync, respectively.
  1030. */
  1031. tid_t i_sync_tid;
  1032. tid_t i_datasync_tid;
  1033. #ifdef CONFIG_QUOTA
  1034. struct dquot *i_dquot[MAXQUOTAS];
  1035. #endif
  1036. /* Precomputed uuid+inum+igen checksum for seeding inode checksums */
  1037. __u32 i_csum_seed;
  1038. kprojid_t i_projid;
  1039. };
  1040. /*
  1041. * File system states
  1042. */
  1043. #define EXT4_VALID_FS 0x0001 /* Unmounted cleanly */
  1044. #define EXT4_ERROR_FS 0x0002 /* Errors detected */
  1045. #define EXT4_ORPHAN_FS 0x0004 /* Orphans being recovered */
  1046. #define EXT4_FC_REPLAY 0x0020 /* Fast commit replay ongoing */
  1047. /*
  1048. * Misc. filesystem flags
  1049. */
  1050. #define EXT2_FLAGS_SIGNED_HASH 0x0001 /* Signed dirhash in use */
  1051. #define EXT2_FLAGS_UNSIGNED_HASH 0x0002 /* Unsigned dirhash in use */
  1052. #define EXT2_FLAGS_TEST_FILESYS 0x0004 /* to test development code */
  1053. /*
  1054. * Mount flags set via mount options or defaults
  1055. */
  1056. #define EXT4_MOUNT_NO_MBCACHE 0x00001 /* Do not use mbcache */
  1057. #define EXT4_MOUNT_GRPID 0x00004 /* Create files with directory's group */
  1058. #define EXT4_MOUNT_DEBUG 0x00008 /* Some debugging messages */
  1059. #define EXT4_MOUNT_ERRORS_CONT 0x00010 /* Continue on errors */
  1060. #define EXT4_MOUNT_ERRORS_RO 0x00020 /* Remount fs ro on errors */
  1061. #define EXT4_MOUNT_ERRORS_PANIC 0x00040 /* Panic on errors */
  1062. #define EXT4_MOUNT_ERRORS_MASK 0x00070
  1063. #define EXT4_MOUNT_MINIX_DF 0x00080 /* Mimics the Minix statfs */
  1064. #define EXT4_MOUNT_NOLOAD 0x00100 /* Don't use existing journal*/
  1065. #ifdef CONFIG_FS_DAX
  1066. #define EXT4_MOUNT_DAX_ALWAYS 0x00200 /* Direct Access */
  1067. #else
  1068. #define EXT4_MOUNT_DAX_ALWAYS 0
  1069. #endif
  1070. #define EXT4_MOUNT_DATA_FLAGS 0x00C00 /* Mode for data writes: */
  1071. #define EXT4_MOUNT_JOURNAL_DATA 0x00400 /* Write data to journal */
  1072. #define EXT4_MOUNT_ORDERED_DATA 0x00800 /* Flush data before commit */
  1073. #define EXT4_MOUNT_WRITEBACK_DATA 0x00C00 /* No data ordering */
  1074. #define EXT4_MOUNT_UPDATE_JOURNAL 0x01000 /* Update the journal format */
  1075. #define EXT4_MOUNT_NO_UID32 0x02000 /* Disable 32-bit UIDs */
  1076. #define EXT4_MOUNT_XATTR_USER 0x04000 /* Extended user attributes */
  1077. #define EXT4_MOUNT_POSIX_ACL 0x08000 /* POSIX Access Control Lists */
  1078. #define EXT4_MOUNT_NO_AUTO_DA_ALLOC 0x10000 /* No auto delalloc mapping */
  1079. #define EXT4_MOUNT_BARRIER 0x20000 /* Use block barriers */
  1080. #define EXT4_MOUNT_QUOTA 0x40000 /* Some quota option set */
  1081. #define EXT4_MOUNT_USRQUOTA 0x80000 /* "old" user quota,
  1082. * enable enforcement for hidden
  1083. * quota files */
  1084. #define EXT4_MOUNT_GRPQUOTA 0x100000 /* "old" group quota, enable
  1085. * enforcement for hidden quota
  1086. * files */
  1087. #define EXT4_MOUNT_PRJQUOTA 0x200000 /* Enable project quota
  1088. * enforcement */
  1089. #define EXT4_MOUNT_DIOREAD_NOLOCK 0x400000 /* Enable support for dio read nolocking */
  1090. #define EXT4_MOUNT_JOURNAL_CHECKSUM 0x800000 /* Journal checksums */
  1091. #define EXT4_MOUNT_JOURNAL_ASYNC_COMMIT 0x1000000 /* Journal Async Commit */
  1092. #define EXT4_MOUNT_WARN_ON_ERROR 0x2000000 /* Trigger WARN_ON on error */
  1093. #define EXT4_MOUNT_PREFETCH_BLOCK_BITMAPS 0x4000000
  1094. #define EXT4_MOUNT_DELALLOC 0x8000000 /* Delalloc support */
  1095. #define EXT4_MOUNT_DATA_ERR_ABORT 0x10000000 /* Abort on file data write */
  1096. #define EXT4_MOUNT_BLOCK_VALIDITY 0x20000000 /* Block validity checking */
  1097. #define EXT4_MOUNT_DISCARD 0x40000000 /* Issue DISCARD requests */
  1098. #define EXT4_MOUNT_INIT_INODE_TABLE 0x80000000 /* Initialize uninitialized itables */
  1099. /*
  1100. * Mount flags set either automatically (could not be set by mount option)
  1101. * based on per file system feature or property or in special cases such as
  1102. * distinguishing between explicit mount option definition and default.
  1103. */
  1104. #define EXT4_MOUNT2_EXPLICIT_DELALLOC 0x00000001 /* User explicitly
  1105. specified delalloc */
  1106. #define EXT4_MOUNT2_STD_GROUP_SIZE 0x00000002 /* We have standard group
  1107. size of blocksize * 8
  1108. blocks */
  1109. #define EXT4_MOUNT2_HURD_COMPAT 0x00000004 /* Support HURD-castrated
  1110. file systems */
  1111. #define EXT4_MOUNT2_EXPLICIT_JOURNAL_CHECKSUM 0x00000008 /* User explicitly
  1112. specified journal checksum */
  1113. #define EXT4_MOUNT2_JOURNAL_FAST_COMMIT 0x00000010 /* Journal fast commit */
  1114. #define EXT4_MOUNT2_DAX_NEVER 0x00000020 /* Do not allow Direct Access */
  1115. #define EXT4_MOUNT2_DAX_INODE 0x00000040 /* For printing options only */
  1116. #define clear_opt(sb, opt) EXT4_SB(sb)->s_mount_opt &= \
  1117. ~EXT4_MOUNT_##opt
  1118. #define set_opt(sb, opt) EXT4_SB(sb)->s_mount_opt |= \
  1119. EXT4_MOUNT_##opt
  1120. #define test_opt(sb, opt) (EXT4_SB(sb)->s_mount_opt & \
  1121. EXT4_MOUNT_##opt)
  1122. #define clear_opt2(sb, opt) EXT4_SB(sb)->s_mount_opt2 &= \
  1123. ~EXT4_MOUNT2_##opt
  1124. #define set_opt2(sb, opt) EXT4_SB(sb)->s_mount_opt2 |= \
  1125. EXT4_MOUNT2_##opt
  1126. #define test_opt2(sb, opt) (EXT4_SB(sb)->s_mount_opt2 & \
  1127. EXT4_MOUNT2_##opt)
  1128. #define ext4_test_and_set_bit __test_and_set_bit_le
  1129. #define ext4_set_bit __set_bit_le
  1130. #define ext4_set_bit_atomic ext2_set_bit_atomic
  1131. #define ext4_test_and_clear_bit __test_and_clear_bit_le
  1132. #define ext4_clear_bit __clear_bit_le
  1133. #define ext4_clear_bit_atomic ext2_clear_bit_atomic
  1134. #define ext4_test_bit test_bit_le
  1135. #define ext4_find_next_zero_bit find_next_zero_bit_le
  1136. #define ext4_find_next_bit find_next_bit_le
  1137. extern void ext4_set_bits(void *bm, int cur, int len);
  1138. /*
  1139. * Maximal mount counts between two filesystem checks
  1140. */
  1141. #define EXT4_DFL_MAX_MNT_COUNT 20 /* Allow 20 mounts */
  1142. #define EXT4_DFL_CHECKINTERVAL 0 /* Don't use interval check */
  1143. /*
  1144. * Behaviour when detecting errors
  1145. */
  1146. #define EXT4_ERRORS_CONTINUE 1 /* Continue execution */
  1147. #define EXT4_ERRORS_RO 2 /* Remount fs read-only */
  1148. #define EXT4_ERRORS_PANIC 3 /* Panic */
  1149. #define EXT4_ERRORS_DEFAULT EXT4_ERRORS_CONTINUE
  1150. /* Metadata checksum algorithm codes */
  1151. #define EXT4_CRC32C_CHKSUM 1
  1152. /*
  1153. * Structure of the super block
  1154. */
  1155. struct ext4_super_block {
  1156. /*00*/ __le32 s_inodes_count; /* Inodes count */
  1157. __le32 s_blocks_count_lo; /* Blocks count */
  1158. __le32 s_r_blocks_count_lo; /* Reserved blocks count */
  1159. __le32 s_free_blocks_count_lo; /* Free blocks count */
  1160. /*10*/ __le32 s_free_inodes_count; /* Free inodes count */
  1161. __le32 s_first_data_block; /* First Data Block */
  1162. __le32 s_log_block_size; /* Block size */
  1163. __le32 s_log_cluster_size; /* Allocation cluster size */
  1164. /*20*/ __le32 s_blocks_per_group; /* # Blocks per group */
  1165. __le32 s_clusters_per_group; /* # Clusters per group */
  1166. __le32 s_inodes_per_group; /* # Inodes per group */
  1167. __le32 s_mtime; /* Mount time */
  1168. /*30*/ __le32 s_wtime; /* Write time */
  1169. __le16 s_mnt_count; /* Mount count */
  1170. __le16 s_max_mnt_count; /* Maximal mount count */
  1171. __le16 s_magic; /* Magic signature */
  1172. __le16 s_state; /* File system state */
  1173. __le16 s_errors; /* Behaviour when detecting errors */
  1174. __le16 s_minor_rev_level; /* minor revision level */
  1175. /*40*/ __le32 s_lastcheck; /* time of last check */
  1176. __le32 s_checkinterval; /* max. time between checks */
  1177. __le32 s_creator_os; /* OS */
  1178. __le32 s_rev_level; /* Revision level */
  1179. /*50*/ __le16 s_def_resuid; /* Default uid for reserved blocks */
  1180. __le16 s_def_resgid; /* Default gid for reserved blocks */
  1181. /*
  1182. * These fields are for EXT4_DYNAMIC_REV superblocks only.
  1183. *
  1184. * Note: the difference between the compatible feature set and
  1185. * the incompatible feature set is that if there is a bit set
  1186. * in the incompatible feature set that the kernel doesn't
  1187. * know about, it should refuse to mount the filesystem.
  1188. *
  1189. * e2fsck's requirements are more strict; if it doesn't know
  1190. * about a feature in either the compatible or incompatible
  1191. * feature set, it must abort and not try to meddle with
  1192. * things it doesn't understand...
  1193. */
  1194. __le32 s_first_ino; /* First non-reserved inode */
  1195. __le16 s_inode_size; /* size of inode structure */
  1196. __le16 s_block_group_nr; /* block group # of this superblock */
  1197. __le32 s_feature_compat; /* compatible feature set */
  1198. /*60*/ __le32 s_feature_incompat; /* incompatible feature set */
  1199. __le32 s_feature_ro_compat; /* readonly-compatible feature set */
  1200. /*68*/ __u8 s_uuid[16]; /* 128-bit uuid for volume */
  1201. /*78*/ char s_volume_name[16]; /* volume name */
  1202. /*88*/ char s_last_mounted[64] __nonstring; /* directory where last mounted */
  1203. /*C8*/ __le32 s_algorithm_usage_bitmap; /* For compression */
  1204. /*
  1205. * Performance hints. Directory preallocation should only
  1206. * happen if the EXT4_FEATURE_COMPAT_DIR_PREALLOC flag is on.
  1207. */
  1208. __u8 s_prealloc_blocks; /* Nr of blocks to try to preallocate*/
  1209. __u8 s_prealloc_dir_blocks; /* Nr to preallocate for dirs */
  1210. __le16 s_reserved_gdt_blocks; /* Per group desc for online growth */
  1211. /*
  1212. * Journaling support valid if EXT4_FEATURE_COMPAT_HAS_JOURNAL set.
  1213. */
  1214. /*D0*/ __u8 s_journal_uuid[16]; /* uuid of journal superblock */
  1215. /*E0*/ __le32 s_journal_inum; /* inode number of journal file */
  1216. __le32 s_journal_dev; /* device number of journal file */
  1217. __le32 s_last_orphan; /* start of list of inodes to delete */
  1218. __le32 s_hash_seed[4]; /* HTREE hash seed */
  1219. __u8 s_def_hash_version; /* Default hash version to use */
  1220. __u8 s_jnl_backup_type;
  1221. __le16 s_desc_size; /* size of group descriptor */
  1222. /*100*/ __le32 s_default_mount_opts;
  1223. __le32 s_first_meta_bg; /* First metablock block group */
  1224. __le32 s_mkfs_time; /* When the filesystem was created */
  1225. __le32 s_jnl_blocks[17]; /* Backup of the journal inode */
  1226. /* 64bit support valid if EXT4_FEATURE_COMPAT_64BIT */
  1227. /*150*/ __le32 s_blocks_count_hi; /* Blocks count */
  1228. __le32 s_r_blocks_count_hi; /* Reserved blocks count */
  1229. __le32 s_free_blocks_count_hi; /* Free blocks count */
  1230. __le16 s_min_extra_isize; /* All inodes have at least # bytes */
  1231. __le16 s_want_extra_isize; /* New inodes should reserve # bytes */
  1232. __le32 s_flags; /* Miscellaneous flags */
  1233. __le16 s_raid_stride; /* RAID stride */
  1234. __le16 s_mmp_update_interval; /* # seconds to wait in MMP checking */
  1235. __le64 s_mmp_block; /* Block for multi-mount protection */
  1236. __le32 s_raid_stripe_width; /* blocks on all data disks (N*stride)*/
  1237. __u8 s_log_groups_per_flex; /* FLEX_BG group size */
  1238. __u8 s_checksum_type; /* metadata checksum algorithm used */
  1239. __u8 s_encryption_level; /* versioning level for encryption */
  1240. __u8 s_reserved_pad; /* Padding to next 32bits */
  1241. __le64 s_kbytes_written; /* nr of lifetime kilobytes written */
  1242. __le32 s_snapshot_inum; /* Inode number of active snapshot */
  1243. __le32 s_snapshot_id; /* sequential ID of active snapshot */
  1244. __le64 s_snapshot_r_blocks_count; /* reserved blocks for active
  1245. snapshot's future use */
  1246. __le32 s_snapshot_list; /* inode number of the head of the
  1247. on-disk snapshot list */
  1248. #define EXT4_S_ERR_START offsetof(struct ext4_super_block, s_error_count)
  1249. __le32 s_error_count; /* number of fs errors */
  1250. __le32 s_first_error_time; /* first time an error happened */
  1251. __le32 s_first_error_ino; /* inode involved in first error */
  1252. __le64 s_first_error_block; /* block involved of first error */
  1253. __u8 s_first_error_func[32] __nonstring; /* function where the error happened */
  1254. __le32 s_first_error_line; /* line number where error happened */
  1255. __le32 s_last_error_time; /* most recent time of an error */
  1256. __le32 s_last_error_ino; /* inode involved in last error */
  1257. __le32 s_last_error_line; /* line number where error happened */
  1258. __le64 s_last_error_block; /* block involved of last error */
  1259. __u8 s_last_error_func[32] __nonstring; /* function where the error happened */
  1260. #define EXT4_S_ERR_END offsetof(struct ext4_super_block, s_mount_opts)
  1261. __u8 s_mount_opts[64];
  1262. __le32 s_usr_quota_inum; /* inode for tracking user quota */
  1263. __le32 s_grp_quota_inum; /* inode for tracking group quota */
  1264. __le32 s_overhead_clusters; /* overhead blocks/clusters in fs */
  1265. __le32 s_backup_bgs[2]; /* groups with sparse_super2 SBs */
  1266. __u8 s_encrypt_algos[4]; /* Encryption algorithms in use */
  1267. __u8 s_encrypt_pw_salt[16]; /* Salt used for string2key algorithm */
  1268. __le32 s_lpf_ino; /* Location of the lost+found inode */
  1269. __le32 s_prj_quota_inum; /* inode for tracking project quota */
  1270. __le32 s_checksum_seed; /* crc32c(uuid) if csum_seed set */
  1271. __u8 s_wtime_hi;
  1272. __u8 s_mtime_hi;
  1273. __u8 s_mkfs_time_hi;
  1274. __u8 s_lastcheck_hi;
  1275. __u8 s_first_error_time_hi;
  1276. __u8 s_last_error_time_hi;
  1277. __u8 s_first_error_errcode;
  1278. __u8 s_last_error_errcode;
  1279. __le16 s_encoding; /* Filename charset encoding */
  1280. __le16 s_encoding_flags; /* Filename charset encoding flags */
  1281. __le32 s_reserved[95]; /* Padding to the end of the block */
  1282. __le32 s_checksum; /* crc32c(superblock) */
  1283. };
  1284. #define EXT4_S_ERR_LEN (EXT4_S_ERR_END - EXT4_S_ERR_START)
  1285. #ifdef __KERNEL__
  1286. #ifdef CONFIG_FS_ENCRYPTION
  1287. #define DUMMY_ENCRYPTION_ENABLED(sbi) ((sbi)->s_dummy_enc_policy.policy != NULL)
  1288. #else
  1289. #define DUMMY_ENCRYPTION_ENABLED(sbi) (0)
  1290. #endif
  1291. /* Number of quota types we support */
  1292. #define EXT4_MAXQUOTAS 3
  1293. #define EXT4_ENC_UTF8_12_1 1
  1294. /*
  1295. * fourth extended-fs super-block data in memory
  1296. */
  1297. struct ext4_sb_info {
  1298. unsigned long s_desc_size; /* Size of a group descriptor in bytes */
  1299. unsigned long s_inodes_per_block;/* Number of inodes per block */
  1300. unsigned long s_blocks_per_group;/* Number of blocks in a group */
  1301. unsigned long s_clusters_per_group; /* Number of clusters in a group */
  1302. unsigned long s_inodes_per_group;/* Number of inodes in a group */
  1303. unsigned long s_itb_per_group; /* Number of inode table blocks per group */
  1304. unsigned long s_gdb_count; /* Number of group descriptor blocks */
  1305. unsigned long s_desc_per_block; /* Number of group descriptors per block */
  1306. ext4_group_t s_groups_count; /* Number of groups in the fs */
  1307. ext4_group_t s_blockfile_groups;/* Groups acceptable for non-extent files */
  1308. unsigned long s_overhead; /* # of fs overhead clusters */
  1309. unsigned int s_cluster_ratio; /* Number of blocks per cluster */
  1310. unsigned int s_cluster_bits; /* log2 of s_cluster_ratio */
  1311. loff_t s_bitmap_maxbytes; /* max bytes for bitmap files */
  1312. struct buffer_head * s_sbh; /* Buffer containing the super block */
  1313. struct ext4_super_block *s_es; /* Pointer to the super block in the buffer */
  1314. struct buffer_head * __rcu *s_group_desc;
  1315. unsigned int s_mount_opt;
  1316. unsigned int s_mount_opt2;
  1317. unsigned long s_mount_flags;
  1318. unsigned int s_def_mount_opt;
  1319. ext4_fsblk_t s_sb_block;
  1320. atomic64_t s_resv_clusters;
  1321. kuid_t s_resuid;
  1322. kgid_t s_resgid;
  1323. unsigned short s_mount_state;
  1324. unsigned short s_pad;
  1325. int s_addr_per_block_bits;
  1326. int s_desc_per_block_bits;
  1327. int s_inode_size;
  1328. int s_first_ino;
  1329. unsigned int s_inode_readahead_blks;
  1330. unsigned int s_inode_goal;
  1331. u32 s_hash_seed[4];
  1332. int s_def_hash_version;
  1333. int s_hash_unsigned; /* 3 if hash should be signed, 0 if not */
  1334. struct percpu_counter s_freeclusters_counter;
  1335. struct percpu_counter s_freeinodes_counter;
  1336. struct percpu_counter s_dirs_counter;
  1337. struct percpu_counter s_dirtyclusters_counter;
  1338. struct percpu_counter s_sra_exceeded_retry_limit;
  1339. struct blockgroup_lock *s_blockgroup_lock;
  1340. struct proc_dir_entry *s_proc;
  1341. struct kobject s_kobj;
  1342. struct completion s_kobj_unregister;
  1343. struct super_block *s_sb;
  1344. struct buffer_head *s_mmp_bh;
  1345. /* Journaling */
  1346. struct journal_s *s_journal;
  1347. struct list_head s_orphan;
  1348. struct mutex s_orphan_lock;
  1349. unsigned long s_ext4_flags; /* Ext4 superblock flags */
  1350. unsigned long s_commit_interval;
  1351. u32 s_max_batch_time;
  1352. u32 s_min_batch_time;
  1353. struct block_device *s_journal_bdev;
  1354. #ifdef CONFIG_QUOTA
  1355. /* Names of quota files with journalled quota */
  1356. char __rcu *s_qf_names[EXT4_MAXQUOTAS];
  1357. int s_jquota_fmt; /* Format of quota to use */
  1358. #endif
  1359. unsigned int s_want_extra_isize; /* New inodes should reserve # bytes */
  1360. struct ext4_system_blocks __rcu *s_system_blks;
  1361. #ifdef EXTENTS_STATS
  1362. /* ext4 extents stats */
  1363. unsigned long s_ext_min;
  1364. unsigned long s_ext_max;
  1365. unsigned long s_depth_max;
  1366. spinlock_t s_ext_stats_lock;
  1367. unsigned long s_ext_blocks;
  1368. unsigned long s_ext_extents;
  1369. #endif
  1370. /* for buddy allocator */
  1371. struct ext4_group_info ** __rcu *s_group_info;
  1372. struct inode *s_buddy_cache;
  1373. spinlock_t s_md_lock;
  1374. unsigned short *s_mb_offsets;
  1375. unsigned int *s_mb_maxs;
  1376. unsigned int s_group_info_size;
  1377. unsigned int s_mb_free_pending;
  1378. struct list_head s_freed_data_list; /* List of blocks to be freed
  1379. after commit completed */
  1380. /* tunables */
  1381. unsigned long s_stripe;
  1382. unsigned int s_mb_stream_request;
  1383. unsigned int s_mb_max_to_scan;
  1384. unsigned int s_mb_min_to_scan;
  1385. unsigned int s_mb_stats;
  1386. unsigned int s_mb_order2_reqs;
  1387. unsigned int s_mb_group_prealloc;
  1388. unsigned int s_mb_max_inode_prealloc;
  1389. unsigned int s_max_dir_size_kb;
  1390. /* where last allocation was done - for stream allocation */
  1391. unsigned long s_mb_last_group;
  1392. unsigned long s_mb_last_start;
  1393. unsigned int s_mb_prefetch;
  1394. unsigned int s_mb_prefetch_limit;
  1395. /* stats for buddy allocator */
  1396. atomic_t s_bal_reqs; /* number of reqs with len > 1 */
  1397. atomic_t s_bal_success; /* we found long enough chunks */
  1398. atomic_t s_bal_allocated; /* in blocks */
  1399. atomic_t s_bal_ex_scanned; /* total extents scanned */
  1400. atomic_t s_bal_goals; /* goal hits */
  1401. atomic_t s_bal_breaks; /* too long searches */
  1402. atomic_t s_bal_2orders; /* 2^order hits */
  1403. spinlock_t s_bal_lock;
  1404. unsigned long s_mb_buddies_generated;
  1405. unsigned long long s_mb_generation_time;
  1406. atomic_t s_mb_lost_chunks;
  1407. atomic_t s_mb_preallocated;
  1408. atomic_t s_mb_discarded;
  1409. atomic_t s_lock_busy;
  1410. /* locality groups */
  1411. struct ext4_locality_group __percpu *s_locality_groups;
  1412. /* for write statistics */
  1413. unsigned long s_sectors_written_start;
  1414. u64 s_kbytes_written;
  1415. /* the size of zero-out chunk */
  1416. unsigned int s_extent_max_zeroout_kb;
  1417. unsigned int s_log_groups_per_flex;
  1418. struct flex_groups * __rcu *s_flex_groups;
  1419. ext4_group_t s_flex_groups_allocated;
  1420. /* workqueue for reserved extent conversions (buffered io) */
  1421. struct workqueue_struct *rsv_conversion_wq;
  1422. /* timer for periodic error stats printing */
  1423. struct timer_list s_err_report;
  1424. /* Lazy inode table initialization info */
  1425. struct ext4_li_request *s_li_request;
  1426. /* Wait multiplier for lazy initialization thread */
  1427. unsigned int s_li_wait_mult;
  1428. /* Kernel thread for multiple mount protection */
  1429. struct task_struct *s_mmp_tsk;
  1430. /* record the last minlen when FITRIM is called. */
  1431. atomic_t s_last_trim_minblks;
  1432. /* Reference to checksum algorithm driver via cryptoapi */
  1433. struct crypto_shash *s_chksum_driver;
  1434. /* Precomputed FS UUID checksum for seeding other checksums */
  1435. __u32 s_csum_seed;
  1436. /* Reclaim extents from extent status tree */
  1437. struct shrinker s_es_shrinker;
  1438. struct list_head s_es_list; /* List of inodes with reclaimable extents */
  1439. long s_es_nr_inode;
  1440. struct ext4_es_stats s_es_stats;
  1441. struct mb_cache *s_ea_block_cache;
  1442. struct mb_cache *s_ea_inode_cache;
  1443. spinlock_t s_es_lock ____cacheline_aligned_in_smp;
  1444. /* Ratelimit ext4 messages. */
  1445. struct ratelimit_state s_err_ratelimit_state;
  1446. struct ratelimit_state s_warning_ratelimit_state;
  1447. struct ratelimit_state s_msg_ratelimit_state;
  1448. atomic_t s_warning_count;
  1449. atomic_t s_msg_count;
  1450. /* Encryption policy for '-o test_dummy_encryption' */
  1451. struct fscrypt_dummy_policy s_dummy_enc_policy;
  1452. /*
  1453. * Barrier between writepages ops and changing any inode's JOURNAL_DATA
  1454. * or EXTENTS flag.
  1455. */
  1456. struct percpu_rw_semaphore s_writepages_rwsem;
  1457. struct dax_device *s_daxdev;
  1458. #ifdef CONFIG_EXT4_DEBUG
  1459. unsigned long s_simulate_fail;
  1460. #endif
  1461. /* Record the errseq of the backing block device */
  1462. errseq_t s_bdev_wb_err;
  1463. spinlock_t s_bdev_wb_lock;
  1464. /* Ext4 fast commit stuff */
  1465. atomic_t s_fc_subtid;
  1466. atomic_t s_fc_ineligible_updates;
  1467. /*
  1468. * After commit starts, the main queue gets locked, and the further
  1469. * updates get added in the staging queue.
  1470. */
  1471. #define FC_Q_MAIN 0
  1472. #define FC_Q_STAGING 1
  1473. struct list_head s_fc_q[2]; /* Inodes staged for fast commit
  1474. * that have data changes in them.
  1475. */
  1476. struct list_head s_fc_dentry_q[2]; /* directory entry updates */
  1477. unsigned int s_fc_bytes;
  1478. /*
  1479. * Main fast commit lock. This lock protects accesses to the
  1480. * following fields:
  1481. * ei->i_fc_list, s_fc_dentry_q, s_fc_q, s_fc_bytes, s_fc_bh.
  1482. */
  1483. spinlock_t s_fc_lock;
  1484. struct buffer_head *s_fc_bh;
  1485. struct ext4_fc_stats s_fc_stats;
  1486. u64 s_fc_avg_commit_time;
  1487. #ifdef CONFIG_EXT4_DEBUG
  1488. int s_fc_debug_max_replay;
  1489. #endif
  1490. struct ext4_fc_replay_state s_fc_replay_state;
  1491. };
  1492. static inline struct ext4_sb_info *EXT4_SB(struct super_block *sb)
  1493. {
  1494. return sb->s_fs_info;
  1495. }
  1496. static inline struct ext4_inode_info *EXT4_I(struct inode *inode)
  1497. {
  1498. return container_of(inode, struct ext4_inode_info, vfs_inode);
  1499. }
  1500. static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino)
  1501. {
  1502. return ino == EXT4_ROOT_INO ||
  1503. (ino >= EXT4_FIRST_INO(sb) &&
  1504. ino <= le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count));
  1505. }
  1506. /*
  1507. * Returns: sbi->field[index]
  1508. * Used to access an array element from the following sbi fields which require
  1509. * rcu protection to avoid dereferencing an invalid pointer due to reassignment
  1510. * - s_group_desc
  1511. * - s_group_info
  1512. * - s_flex_group
  1513. */
  1514. #define sbi_array_rcu_deref(sbi, field, index) \
  1515. ({ \
  1516. typeof(*((sbi)->field)) _v; \
  1517. rcu_read_lock(); \
  1518. _v = ((typeof(_v)*)rcu_dereference((sbi)->field))[index]; \
  1519. rcu_read_unlock(); \
  1520. _v; \
  1521. })
  1522. /*
  1523. * run-time mount flags
  1524. */
  1525. enum {
  1526. EXT4_MF_MNTDIR_SAMPLED,
  1527. EXT4_MF_FS_ABORTED, /* Fatal error detected */
  1528. EXT4_MF_FC_INELIGIBLE, /* Fast commit ineligible */
  1529. EXT4_MF_FC_COMMITTING /* File system underoing a fast
  1530. * commit.
  1531. */
  1532. };
  1533. static inline void ext4_set_mount_flag(struct super_block *sb, int bit)
  1534. {
  1535. set_bit(bit, &EXT4_SB(sb)->s_mount_flags);
  1536. }
  1537. static inline void ext4_clear_mount_flag(struct super_block *sb, int bit)
  1538. {
  1539. clear_bit(bit, &EXT4_SB(sb)->s_mount_flags);
  1540. }
  1541. static inline int ext4_test_mount_flag(struct super_block *sb, int bit)
  1542. {
  1543. return test_bit(bit, &EXT4_SB(sb)->s_mount_flags);
  1544. }
  1545. /*
  1546. * Simulate_fail codes
  1547. */
  1548. #define EXT4_SIM_BBITMAP_EIO 1
  1549. #define EXT4_SIM_BBITMAP_CRC 2
  1550. #define EXT4_SIM_IBITMAP_EIO 3
  1551. #define EXT4_SIM_IBITMAP_CRC 4
  1552. #define EXT4_SIM_INODE_EIO 5
  1553. #define EXT4_SIM_INODE_CRC 6
  1554. #define EXT4_SIM_DIRBLOCK_EIO 7
  1555. #define EXT4_SIM_DIRBLOCK_CRC 8
  1556. static inline bool ext4_simulate_fail(struct super_block *sb,
  1557. unsigned long code)
  1558. {
  1559. #ifdef CONFIG_EXT4_DEBUG
  1560. struct ext4_sb_info *sbi = EXT4_SB(sb);
  1561. if (unlikely(sbi->s_simulate_fail == code)) {
  1562. sbi->s_simulate_fail = 0;
  1563. return true;
  1564. }
  1565. #endif
  1566. return false;
  1567. }
  1568. static inline void ext4_simulate_fail_bh(struct super_block *sb,
  1569. struct buffer_head *bh,
  1570. unsigned long code)
  1571. {
  1572. if (!IS_ERR(bh) && ext4_simulate_fail(sb, code))
  1573. clear_buffer_uptodate(bh);
  1574. }
  1575. /*
  1576. * Error number codes for s_{first,last}_error_errno
  1577. *
  1578. * Linux errno numbers are architecture specific, so we need to translate
  1579. * them into something which is architecture independent. We don't define
  1580. * codes for all errno's; just the ones which are most likely to be the cause
  1581. * of an ext4_error() call.
  1582. */
  1583. #define EXT4_ERR_UNKNOWN 1
  1584. #define EXT4_ERR_EIO 2
  1585. #define EXT4_ERR_ENOMEM 3
  1586. #define EXT4_ERR_EFSBADCRC 4
  1587. #define EXT4_ERR_EFSCORRUPTED 5
  1588. #define EXT4_ERR_ENOSPC 6
  1589. #define EXT4_ERR_ENOKEY 7
  1590. #define EXT4_ERR_EROFS 8
  1591. #define EXT4_ERR_EFBIG 9
  1592. #define EXT4_ERR_EEXIST 10
  1593. #define EXT4_ERR_ERANGE 11
  1594. #define EXT4_ERR_EOVERFLOW 12
  1595. #define EXT4_ERR_EBUSY 13
  1596. #define EXT4_ERR_ENOTDIR 14
  1597. #define EXT4_ERR_ENOTEMPTY 15
  1598. #define EXT4_ERR_ESHUTDOWN 16
  1599. #define EXT4_ERR_EFAULT 17
  1600. /*
  1601. * Inode dynamic state flags
  1602. */
  1603. enum {
  1604. EXT4_STATE_JDATA, /* journaled data exists */
  1605. EXT4_STATE_NEW, /* inode is newly created */
  1606. EXT4_STATE_XATTR, /* has in-inode xattrs */
  1607. EXT4_STATE_NO_EXPAND, /* No space for expansion */
  1608. EXT4_STATE_DA_ALLOC_CLOSE, /* Alloc DA blks on close */
  1609. EXT4_STATE_EXT_MIGRATE, /* Inode is migrating */
  1610. EXT4_STATE_NEWENTRY, /* File just added to dir */
  1611. EXT4_STATE_MAY_INLINE_DATA, /* may have in-inode data */
  1612. EXT4_STATE_EXT_PRECACHED, /* extents have been precached */
  1613. EXT4_STATE_LUSTRE_EA_INODE, /* Lustre-style ea_inode */
  1614. EXT4_STATE_VERITY_IN_PROGRESS, /* building fs-verity Merkle tree */
  1615. EXT4_STATE_FC_COMMITTING, /* Fast commit ongoing */
  1616. };
  1617. #define EXT4_INODE_BIT_FNS(name, field, offset) \
  1618. static inline int ext4_test_inode_##name(struct inode *inode, int bit) \
  1619. { \
  1620. return test_bit(bit + (offset), &EXT4_I(inode)->i_##field); \
  1621. } \
  1622. static inline void ext4_set_inode_##name(struct inode *inode, int bit) \
  1623. { \
  1624. set_bit(bit + (offset), &EXT4_I(inode)->i_##field); \
  1625. } \
  1626. static inline void ext4_clear_inode_##name(struct inode *inode, int bit) \
  1627. { \
  1628. clear_bit(bit + (offset), &EXT4_I(inode)->i_##field); \
  1629. }
  1630. /* Add these declarations here only so that these functions can be
  1631. * found by name. Otherwise, they are very hard to locate. */
  1632. static inline int ext4_test_inode_flag(struct inode *inode, int bit);
  1633. static inline void ext4_set_inode_flag(struct inode *inode, int bit);
  1634. static inline void ext4_clear_inode_flag(struct inode *inode, int bit);
  1635. EXT4_INODE_BIT_FNS(flag, flags, 0)
  1636. /* Add these declarations here only so that these functions can be
  1637. * found by name. Otherwise, they are very hard to locate. */
  1638. static inline int ext4_test_inode_state(struct inode *inode, int bit);
  1639. static inline void ext4_set_inode_state(struct inode *inode, int bit);
  1640. static inline void ext4_clear_inode_state(struct inode *inode, int bit);
  1641. #if (BITS_PER_LONG < 64)
  1642. EXT4_INODE_BIT_FNS(state, state_flags, 0)
  1643. static inline void ext4_clear_state_flags(struct ext4_inode_info *ei)
  1644. {
  1645. (ei)->i_state_flags = 0;
  1646. }
  1647. #else
  1648. EXT4_INODE_BIT_FNS(state, flags, 32)
  1649. static inline void ext4_clear_state_flags(struct ext4_inode_info *ei)
  1650. {
  1651. /* We depend on the fact that callers will set i_flags */
  1652. }
  1653. #endif
  1654. #else
  1655. /* Assume that user mode programs are passing in an ext4fs superblock, not
  1656. * a kernel struct super_block. This will allow us to call the feature-test
  1657. * macros from user land. */
  1658. #define EXT4_SB(sb) (sb)
  1659. #endif
  1660. static inline bool ext4_verity_in_progress(struct inode *inode)
  1661. {
  1662. return IS_ENABLED(CONFIG_FS_VERITY) &&
  1663. ext4_test_inode_state(inode, EXT4_STATE_VERITY_IN_PROGRESS);
  1664. }
  1665. #define NEXT_ORPHAN(inode) EXT4_I(inode)->i_dtime
  1666. /*
  1667. * Codes for operating systems
  1668. */
  1669. #define EXT4_OS_LINUX 0
  1670. #define EXT4_OS_HURD 1
  1671. #define EXT4_OS_MASIX 2
  1672. #define EXT4_OS_FREEBSD 3
  1673. #define EXT4_OS_LITES 4
  1674. /*
  1675. * Revision levels
  1676. */
  1677. #define EXT4_GOOD_OLD_REV 0 /* The good old (original) format */
  1678. #define EXT4_DYNAMIC_REV 1 /* V2 format w/ dynamic inode sizes */
  1679. #define EXT4_CURRENT_REV EXT4_GOOD_OLD_REV
  1680. #define EXT4_MAX_SUPP_REV EXT4_DYNAMIC_REV
  1681. #define EXT4_GOOD_OLD_INODE_SIZE 128
  1682. #define EXT4_EXTRA_TIMESTAMP_MAX (((s64)1 << 34) - 1 + S32_MIN)
  1683. #define EXT4_NON_EXTRA_TIMESTAMP_MAX S32_MAX
  1684. #define EXT4_TIMESTAMP_MIN S32_MIN
  1685. /*
  1686. * Feature set definitions
  1687. */
  1688. #define EXT4_FEATURE_COMPAT_DIR_PREALLOC 0x0001
  1689. #define EXT4_FEATURE_COMPAT_IMAGIC_INODES 0x0002
  1690. #define EXT4_FEATURE_COMPAT_HAS_JOURNAL 0x0004
  1691. #define EXT4_FEATURE_COMPAT_EXT_ATTR 0x0008
  1692. #define EXT4_FEATURE_COMPAT_RESIZE_INODE 0x0010
  1693. #define EXT4_FEATURE_COMPAT_DIR_INDEX 0x0020
  1694. #define EXT4_FEATURE_COMPAT_SPARSE_SUPER2 0x0200
  1695. /*
  1696. * The reason why "FAST_COMMIT" is a compat feature is that, FS becomes
  1697. * incompatible only if fast commit blocks are present in the FS. Since we
  1698. * clear the journal (and thus the fast commit blocks), we don't mark FS as
  1699. * incompatible. We also have a JBD2 incompat feature, which gets set when
  1700. * there are fast commit blocks present in the journal.
  1701. */
  1702. #define EXT4_FEATURE_COMPAT_FAST_COMMIT 0x0400
  1703. #define EXT4_FEATURE_COMPAT_STABLE_INODES 0x0800
  1704. #define EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER 0x0001
  1705. #define EXT4_FEATURE_RO_COMPAT_LARGE_FILE 0x0002
  1706. #define EXT4_FEATURE_RO_COMPAT_BTREE_DIR 0x0004
  1707. #define EXT4_FEATURE_RO_COMPAT_HUGE_FILE 0x0008
  1708. #define EXT4_FEATURE_RO_COMPAT_GDT_CSUM 0x0010
  1709. #define EXT4_FEATURE_RO_COMPAT_DIR_NLINK 0x0020
  1710. #define EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE 0x0040
  1711. #define EXT4_FEATURE_RO_COMPAT_QUOTA 0x0100
  1712. #define EXT4_FEATURE_RO_COMPAT_BIGALLOC 0x0200
  1713. /*
  1714. * METADATA_CSUM also enables group descriptor checksums (GDT_CSUM). When
  1715. * METADATA_CSUM is set, group descriptor checksums use the same algorithm as
  1716. * all other data structures' checksums. However, the METADATA_CSUM and
  1717. * GDT_CSUM bits are mutually exclusive.
  1718. */
  1719. #define EXT4_FEATURE_RO_COMPAT_METADATA_CSUM 0x0400
  1720. #define EXT4_FEATURE_RO_COMPAT_READONLY 0x1000
  1721. #define EXT4_FEATURE_RO_COMPAT_PROJECT 0x2000
  1722. #define EXT4_FEATURE_RO_COMPAT_VERITY 0x8000
  1723. #define EXT4_FEATURE_INCOMPAT_COMPRESSION 0x0001
  1724. #define EXT4_FEATURE_INCOMPAT_FILETYPE 0x0002
  1725. #define EXT4_FEATURE_INCOMPAT_RECOVER 0x0004 /* Needs recovery */
  1726. #define EXT4_FEATURE_INCOMPAT_JOURNAL_DEV 0x0008 /* Journal device */
  1727. #define EXT4_FEATURE_INCOMPAT_META_BG 0x0010
  1728. #define EXT4_FEATURE_INCOMPAT_EXTENTS 0x0040 /* extents support */
  1729. #define EXT4_FEATURE_INCOMPAT_64BIT 0x0080
  1730. #define EXT4_FEATURE_INCOMPAT_MMP 0x0100
  1731. #define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200
  1732. #define EXT4_FEATURE_INCOMPAT_EA_INODE 0x0400 /* EA in inode */
  1733. #define EXT4_FEATURE_INCOMPAT_DIRDATA 0x1000 /* data in dirent */
  1734. #define EXT4_FEATURE_INCOMPAT_CSUM_SEED 0x2000
  1735. #define EXT4_FEATURE_INCOMPAT_LARGEDIR 0x4000 /* >2GB or 3-lvl htree */
  1736. #define EXT4_FEATURE_INCOMPAT_INLINE_DATA 0x8000 /* data in inode */
  1737. #define EXT4_FEATURE_INCOMPAT_ENCRYPT 0x10000
  1738. #define EXT4_FEATURE_INCOMPAT_CASEFOLD 0x20000
  1739. extern void ext4_update_dynamic_rev(struct super_block *sb);
  1740. #define EXT4_FEATURE_COMPAT_FUNCS(name, flagname) \
  1741. static inline bool ext4_has_feature_##name(struct super_block *sb) \
  1742. { \
  1743. return ((EXT4_SB(sb)->s_es->s_feature_compat & \
  1744. cpu_to_le32(EXT4_FEATURE_COMPAT_##flagname)) != 0); \
  1745. } \
  1746. static inline void ext4_set_feature_##name(struct super_block *sb) \
  1747. { \
  1748. ext4_update_dynamic_rev(sb); \
  1749. EXT4_SB(sb)->s_es->s_feature_compat |= \
  1750. cpu_to_le32(EXT4_FEATURE_COMPAT_##flagname); \
  1751. } \
  1752. static inline void ext4_clear_feature_##name(struct super_block *sb) \
  1753. { \
  1754. EXT4_SB(sb)->s_es->s_feature_compat &= \
  1755. ~cpu_to_le32(EXT4_FEATURE_COMPAT_##flagname); \
  1756. }
  1757. #define EXT4_FEATURE_RO_COMPAT_FUNCS(name, flagname) \
  1758. static inline bool ext4_has_feature_##name(struct super_block *sb) \
  1759. { \
  1760. return ((EXT4_SB(sb)->s_es->s_feature_ro_compat & \
  1761. cpu_to_le32(EXT4_FEATURE_RO_COMPAT_##flagname)) != 0); \
  1762. } \
  1763. static inline void ext4_set_feature_##name(struct super_block *sb) \
  1764. { \
  1765. ext4_update_dynamic_rev(sb); \
  1766. EXT4_SB(sb)->s_es->s_feature_ro_compat |= \
  1767. cpu_to_le32(EXT4_FEATURE_RO_COMPAT_##flagname); \
  1768. } \
  1769. static inline void ext4_clear_feature_##name(struct super_block *sb) \
  1770. { \
  1771. EXT4_SB(sb)->s_es->s_feature_ro_compat &= \
  1772. ~cpu_to_le32(EXT4_FEATURE_RO_COMPAT_##flagname); \
  1773. }
  1774. #define EXT4_FEATURE_INCOMPAT_FUNCS(name, flagname) \
  1775. static inline bool ext4_has_feature_##name(struct super_block *sb) \
  1776. { \
  1777. return ((EXT4_SB(sb)->s_es->s_feature_incompat & \
  1778. cpu_to_le32(EXT4_FEATURE_INCOMPAT_##flagname)) != 0); \
  1779. } \
  1780. static inline void ext4_set_feature_##name(struct super_block *sb) \
  1781. { \
  1782. ext4_update_dynamic_rev(sb); \
  1783. EXT4_SB(sb)->s_es->s_feature_incompat |= \
  1784. cpu_to_le32(EXT4_FEATURE_INCOMPAT_##flagname); \
  1785. } \
  1786. static inline void ext4_clear_feature_##name(struct super_block *sb) \
  1787. { \
  1788. EXT4_SB(sb)->s_es->s_feature_incompat &= \
  1789. ~cpu_to_le32(EXT4_FEATURE_INCOMPAT_##flagname); \
  1790. }
  1791. EXT4_FEATURE_COMPAT_FUNCS(dir_prealloc, DIR_PREALLOC)
  1792. EXT4_FEATURE_COMPAT_FUNCS(imagic_inodes, IMAGIC_INODES)
  1793. EXT4_FEATURE_COMPAT_FUNCS(journal, HAS_JOURNAL)
  1794. EXT4_FEATURE_COMPAT_FUNCS(xattr, EXT_ATTR)
  1795. EXT4_FEATURE_COMPAT_FUNCS(resize_inode, RESIZE_INODE)
  1796. EXT4_FEATURE_COMPAT_FUNCS(dir_index, DIR_INDEX)
  1797. EXT4_FEATURE_COMPAT_FUNCS(sparse_super2, SPARSE_SUPER2)
  1798. EXT4_FEATURE_COMPAT_FUNCS(fast_commit, FAST_COMMIT)
  1799. EXT4_FEATURE_COMPAT_FUNCS(stable_inodes, STABLE_INODES)
  1800. EXT4_FEATURE_RO_COMPAT_FUNCS(sparse_super, SPARSE_SUPER)
  1801. EXT4_FEATURE_RO_COMPAT_FUNCS(large_file, LARGE_FILE)
  1802. EXT4_FEATURE_RO_COMPAT_FUNCS(btree_dir, BTREE_DIR)
  1803. EXT4_FEATURE_RO_COMPAT_FUNCS(huge_file, HUGE_FILE)
  1804. EXT4_FEATURE_RO_COMPAT_FUNCS(gdt_csum, GDT_CSUM)
  1805. EXT4_FEATURE_RO_COMPAT_FUNCS(dir_nlink, DIR_NLINK)
  1806. EXT4_FEATURE_RO_COMPAT_FUNCS(extra_isize, EXTRA_ISIZE)
  1807. EXT4_FEATURE_RO_COMPAT_FUNCS(quota, QUOTA)
  1808. EXT4_FEATURE_RO_COMPAT_FUNCS(bigalloc, BIGALLOC)
  1809. EXT4_FEATURE_RO_COMPAT_FUNCS(metadata_csum, METADATA_CSUM)
  1810. EXT4_FEATURE_RO_COMPAT_FUNCS(readonly, READONLY)
  1811. EXT4_FEATURE_RO_COMPAT_FUNCS(project, PROJECT)
  1812. EXT4_FEATURE_RO_COMPAT_FUNCS(verity, VERITY)
  1813. EXT4_FEATURE_INCOMPAT_FUNCS(compression, COMPRESSION)
  1814. EXT4_FEATURE_INCOMPAT_FUNCS(filetype, FILETYPE)
  1815. EXT4_FEATURE_INCOMPAT_FUNCS(journal_needs_recovery, RECOVER)
  1816. EXT4_FEATURE_INCOMPAT_FUNCS(journal_dev, JOURNAL_DEV)
  1817. EXT4_FEATURE_INCOMPAT_FUNCS(meta_bg, META_BG)
  1818. EXT4_FEATURE_INCOMPAT_FUNCS(extents, EXTENTS)
  1819. EXT4_FEATURE_INCOMPAT_FUNCS(64bit, 64BIT)
  1820. EXT4_FEATURE_INCOMPAT_FUNCS(mmp, MMP)
  1821. EXT4_FEATURE_INCOMPAT_FUNCS(flex_bg, FLEX_BG)
  1822. EXT4_FEATURE_INCOMPAT_FUNCS(ea_inode, EA_INODE)
  1823. EXT4_FEATURE_INCOMPAT_FUNCS(dirdata, DIRDATA)
  1824. EXT4_FEATURE_INCOMPAT_FUNCS(csum_seed, CSUM_SEED)
  1825. EXT4_FEATURE_INCOMPAT_FUNCS(largedir, LARGEDIR)
  1826. EXT4_FEATURE_INCOMPAT_FUNCS(inline_data, INLINE_DATA)
  1827. EXT4_FEATURE_INCOMPAT_FUNCS(encrypt, ENCRYPT)
  1828. EXT4_FEATURE_INCOMPAT_FUNCS(casefold, CASEFOLD)
  1829. #define EXT2_FEATURE_COMPAT_SUPP EXT4_FEATURE_COMPAT_EXT_ATTR
  1830. #define EXT2_FEATURE_INCOMPAT_SUPP (EXT4_FEATURE_INCOMPAT_FILETYPE| \
  1831. EXT4_FEATURE_INCOMPAT_META_BG)
  1832. #define EXT2_FEATURE_RO_COMPAT_SUPP (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER| \
  1833. EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \
  1834. EXT4_FEATURE_RO_COMPAT_BTREE_DIR)
  1835. #define EXT3_FEATURE_COMPAT_SUPP EXT4_FEATURE_COMPAT_EXT_ATTR
  1836. #define EXT3_FEATURE_INCOMPAT_SUPP (EXT4_FEATURE_INCOMPAT_FILETYPE| \
  1837. EXT4_FEATURE_INCOMPAT_RECOVER| \
  1838. EXT4_FEATURE_INCOMPAT_META_BG)
  1839. #define EXT3_FEATURE_RO_COMPAT_SUPP (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER| \
  1840. EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \
  1841. EXT4_FEATURE_RO_COMPAT_BTREE_DIR)
  1842. #define EXT4_FEATURE_COMPAT_SUPP EXT4_FEATURE_COMPAT_EXT_ATTR
  1843. #define EXT4_FEATURE_INCOMPAT_SUPP (EXT4_FEATURE_INCOMPAT_FILETYPE| \
  1844. EXT4_FEATURE_INCOMPAT_RECOVER| \
  1845. EXT4_FEATURE_INCOMPAT_META_BG| \
  1846. EXT4_FEATURE_INCOMPAT_EXTENTS| \
  1847. EXT4_FEATURE_INCOMPAT_64BIT| \
  1848. EXT4_FEATURE_INCOMPAT_FLEX_BG| \
  1849. EXT4_FEATURE_INCOMPAT_EA_INODE| \
  1850. EXT4_FEATURE_INCOMPAT_MMP | \
  1851. EXT4_FEATURE_INCOMPAT_INLINE_DATA | \
  1852. EXT4_FEATURE_INCOMPAT_ENCRYPT | \
  1853. EXT4_FEATURE_INCOMPAT_CASEFOLD | \
  1854. EXT4_FEATURE_INCOMPAT_CSUM_SEED | \
  1855. EXT4_FEATURE_INCOMPAT_LARGEDIR)
  1856. #define EXT4_FEATURE_RO_COMPAT_SUPP (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER| \
  1857. EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \
  1858. EXT4_FEATURE_RO_COMPAT_GDT_CSUM| \
  1859. EXT4_FEATURE_RO_COMPAT_DIR_NLINK | \
  1860. EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE | \
  1861. EXT4_FEATURE_RO_COMPAT_BTREE_DIR |\
  1862. EXT4_FEATURE_RO_COMPAT_HUGE_FILE |\
  1863. EXT4_FEATURE_RO_COMPAT_BIGALLOC |\
  1864. EXT4_FEATURE_RO_COMPAT_METADATA_CSUM|\
  1865. EXT4_FEATURE_RO_COMPAT_QUOTA |\
  1866. EXT4_FEATURE_RO_COMPAT_PROJECT |\
  1867. EXT4_FEATURE_RO_COMPAT_VERITY)
  1868. #define EXTN_FEATURE_FUNCS(ver) \
  1869. static inline bool ext4_has_unknown_ext##ver##_compat_features(struct super_block *sb) \
  1870. { \
  1871. return ((EXT4_SB(sb)->s_es->s_feature_compat & \
  1872. cpu_to_le32(~EXT##ver##_FEATURE_COMPAT_SUPP)) != 0); \
  1873. } \
  1874. static inline bool ext4_has_unknown_ext##ver##_ro_compat_features(struct super_block *sb) \
  1875. { \
  1876. return ((EXT4_SB(sb)->s_es->s_feature_ro_compat & \
  1877. cpu_to_le32(~EXT##ver##_FEATURE_RO_COMPAT_SUPP)) != 0); \
  1878. } \
  1879. static inline bool ext4_has_unknown_ext##ver##_incompat_features(struct super_block *sb) \
  1880. { \
  1881. return ((EXT4_SB(sb)->s_es->s_feature_incompat & \
  1882. cpu_to_le32(~EXT##ver##_FEATURE_INCOMPAT_SUPP)) != 0); \
  1883. }
  1884. EXTN_FEATURE_FUNCS(2)
  1885. EXTN_FEATURE_FUNCS(3)
  1886. EXTN_FEATURE_FUNCS(4)
  1887. static inline bool ext4_has_compat_features(struct super_block *sb)
  1888. {
  1889. return (EXT4_SB(sb)->s_es->s_feature_compat != 0);
  1890. }
  1891. static inline bool ext4_has_ro_compat_features(struct super_block *sb)
  1892. {
  1893. return (EXT4_SB(sb)->s_es->s_feature_ro_compat != 0);
  1894. }
  1895. static inline bool ext4_has_incompat_features(struct super_block *sb)
  1896. {
  1897. return (EXT4_SB(sb)->s_es->s_feature_incompat != 0);
  1898. }
  1899. /*
  1900. * Superblock flags
  1901. */
  1902. #define EXT4_FLAGS_RESIZING 0
  1903. #define EXT4_FLAGS_SHUTDOWN 1
  1904. #define EXT4_FLAGS_BDEV_IS_DAX 2
  1905. static inline int ext4_forced_shutdown(struct ext4_sb_info *sbi)
  1906. {
  1907. return test_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
  1908. }
  1909. /*
  1910. * Default values for user and/or group using reserved blocks
  1911. */
  1912. #define EXT4_DEF_RESUID 0
  1913. #define EXT4_DEF_RESGID 0
  1914. /*
  1915. * Default project ID
  1916. */
  1917. #define EXT4_DEF_PROJID 0
  1918. #define EXT4_DEF_INODE_READAHEAD_BLKS 32
  1919. /*
  1920. * Default mount options
  1921. */
  1922. #define EXT4_DEFM_DEBUG 0x0001
  1923. #define EXT4_DEFM_BSDGROUPS 0x0002
  1924. #define EXT4_DEFM_XATTR_USER 0x0004
  1925. #define EXT4_DEFM_ACL 0x0008
  1926. #define EXT4_DEFM_UID16 0x0010
  1927. #define EXT4_DEFM_JMODE 0x0060
  1928. #define EXT4_DEFM_JMODE_DATA 0x0020
  1929. #define EXT4_DEFM_JMODE_ORDERED 0x0040
  1930. #define EXT4_DEFM_JMODE_WBACK 0x0060
  1931. #define EXT4_DEFM_NOBARRIER 0x0100
  1932. #define EXT4_DEFM_BLOCK_VALIDITY 0x0200
  1933. #define EXT4_DEFM_DISCARD 0x0400
  1934. #define EXT4_DEFM_NODELALLOC 0x0800
  1935. /*
  1936. * Default journal batch times
  1937. */
  1938. #define EXT4_DEF_MIN_BATCH_TIME 0
  1939. #define EXT4_DEF_MAX_BATCH_TIME 15000 /* 15ms */
  1940. /*
  1941. * Minimum number of groups in a flexgroup before we separate out
  1942. * directories into the first block group of a flexgroup
  1943. */
  1944. #define EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME 4
  1945. /*
  1946. * Structure of a directory entry
  1947. */
  1948. #define EXT4_NAME_LEN 255
  1949. /*
  1950. * Base length of the ext4 directory entry excluding the name length
  1951. */
  1952. #define EXT4_BASE_DIR_LEN (sizeof(struct ext4_dir_entry_2) - EXT4_NAME_LEN)
  1953. struct ext4_dir_entry {
  1954. __le32 inode; /* Inode number */
  1955. __le16 rec_len; /* Directory entry length */
  1956. __le16 name_len; /* Name length */
  1957. char name[EXT4_NAME_LEN]; /* File name */
  1958. };
  1959. /*
  1960. * Encrypted Casefolded entries require saving the hash on disk. This structure
  1961. * followed ext4_dir_entry_2's name[name_len] at the next 4 byte aligned
  1962. * boundary.
  1963. */
  1964. struct ext4_dir_entry_hash {
  1965. __le32 hash;
  1966. __le32 minor_hash;
  1967. };
  1968. /*
  1969. * The new version of the directory entry. Since EXT4 structures are
  1970. * stored in intel byte order, and the name_len field could never be
  1971. * bigger than 255 chars, it's safe to reclaim the extra byte for the
  1972. * file_type field.
  1973. */
  1974. struct ext4_dir_entry_2 {
  1975. __le32 inode; /* Inode number */
  1976. __le16 rec_len; /* Directory entry length */
  1977. __u8 name_len; /* Name length */
  1978. __u8 file_type; /* See file type macros EXT4_FT_* below */
  1979. char name[EXT4_NAME_LEN]; /* File name */
  1980. };
  1981. /*
  1982. * Access the hashes at the end of ext4_dir_entry_2
  1983. */
  1984. #define EXT4_DIRENT_HASHES(entry) \
  1985. ((struct ext4_dir_entry_hash *) \
  1986. (((void *)(entry)) + \
  1987. ((8 + (entry)->name_len + EXT4_DIR_ROUND) & ~EXT4_DIR_ROUND)))
  1988. #define EXT4_DIRENT_HASH(entry) le32_to_cpu(EXT4_DIRENT_HASHES(de)->hash)
  1989. #define EXT4_DIRENT_MINOR_HASH(entry) \
  1990. le32_to_cpu(EXT4_DIRENT_HASHES(de)->minor_hash)
  1991. static inline bool ext4_hash_in_dirent(const struct inode *inode)
  1992. {
  1993. return IS_CASEFOLDED(inode) && IS_ENCRYPTED(inode);
  1994. }
  1995. /*
  1996. * This is a bogus directory entry at the end of each leaf block that
  1997. * records checksums.
  1998. */
  1999. struct ext4_dir_entry_tail {
  2000. __le32 det_reserved_zero1; /* Pretend to be unused */
  2001. __le16 det_rec_len; /* 12 */
  2002. __u8 det_reserved_zero2; /* Zero name length */
  2003. __u8 det_reserved_ft; /* 0xDE, fake file type */
  2004. __le32 det_checksum; /* crc32c(uuid+inum+dirblock) */
  2005. };
  2006. #define EXT4_DIRENT_TAIL(block, blocksize) \
  2007. ((struct ext4_dir_entry_tail *)(((void *)(block)) + \
  2008. ((blocksize) - \
  2009. sizeof(struct ext4_dir_entry_tail))))
  2010. /*
  2011. * Ext4 directory file types. Only the low 3 bits are used. The
  2012. * other bits are reserved for now.
  2013. */
  2014. #define EXT4_FT_UNKNOWN 0
  2015. #define EXT4_FT_REG_FILE 1
  2016. #define EXT4_FT_DIR 2
  2017. #define EXT4_FT_CHRDEV 3
  2018. #define EXT4_FT_BLKDEV 4
  2019. #define EXT4_FT_FIFO 5
  2020. #define EXT4_FT_SOCK 6
  2021. #define EXT4_FT_SYMLINK 7
  2022. #define EXT4_FT_MAX 8
  2023. #define EXT4_FT_DIR_CSUM 0xDE
  2024. /*
  2025. * EXT4_DIR_PAD defines the directory entries boundaries
  2026. *
  2027. * NOTE: It must be a multiple of 4
  2028. */
  2029. #define EXT4_DIR_PAD 4
  2030. #define EXT4_DIR_ROUND (EXT4_DIR_PAD - 1)
  2031. #define EXT4_MAX_REC_LEN ((1<<16)-1)
  2032. /*
  2033. * The rec_len is dependent on the type of directory. Directories that are
  2034. * casefolded and encrypted need to store the hash as well, so we add room for
  2035. * ext4_extended_dir_entry_2. For all entries related to '.' or '..' you should
  2036. * pass NULL for dir, as those entries do not use the extra fields.
  2037. */
  2038. static inline unsigned int ext4_dir_rec_len(__u8 name_len,
  2039. const struct inode *dir)
  2040. {
  2041. int rec_len = (name_len + 8 + EXT4_DIR_ROUND);
  2042. if (dir && ext4_hash_in_dirent(dir))
  2043. rec_len += sizeof(struct ext4_dir_entry_hash);
  2044. return (rec_len & ~EXT4_DIR_ROUND);
  2045. }
  2046. /*
  2047. * If we ever get support for fs block sizes > page_size, we'll need
  2048. * to remove the #if statements in the next two functions...
  2049. */
  2050. static inline unsigned int
  2051. ext4_rec_len_from_disk(__le16 dlen, unsigned blocksize)
  2052. {
  2053. unsigned len = le16_to_cpu(dlen);
  2054. #if (PAGE_SIZE >= 65536)
  2055. if (len == EXT4_MAX_REC_LEN || len == 0)
  2056. return blocksize;
  2057. return (len & 65532) | ((len & 3) << 16);
  2058. #else
  2059. return len;
  2060. #endif
  2061. }
  2062. static inline __le16 ext4_rec_len_to_disk(unsigned len, unsigned blocksize)
  2063. {
  2064. if ((len > blocksize) || (blocksize > (1 << 18)) || (len & 3))
  2065. BUG();
  2066. #if (PAGE_SIZE >= 65536)
  2067. if (len < 65536)
  2068. return cpu_to_le16(len);
  2069. if (len == blocksize) {
  2070. if (blocksize == 65536)
  2071. return cpu_to_le16(EXT4_MAX_REC_LEN);
  2072. else
  2073. return cpu_to_le16(0);
  2074. }
  2075. return cpu_to_le16((len & 65532) | ((len >> 16) & 3));
  2076. #else
  2077. return cpu_to_le16(len);
  2078. #endif
  2079. }
  2080. /*
  2081. * Hash Tree Directory indexing
  2082. * (c) Daniel Phillips, 2001
  2083. */
  2084. #define is_dx(dir) (ext4_has_feature_dir_index((dir)->i_sb) && \
  2085. ext4_test_inode_flag((dir), EXT4_INODE_INDEX))
  2086. #define EXT4_DIR_LINK_MAX(dir) unlikely((dir)->i_nlink >= EXT4_LINK_MAX && \
  2087. !(ext4_has_feature_dir_nlink((dir)->i_sb) && is_dx(dir)))
  2088. #define EXT4_DIR_LINK_EMPTY(dir) ((dir)->i_nlink == 2 || (dir)->i_nlink == 1)
  2089. /* Legal values for the dx_root hash_version field: */
  2090. #define DX_HASH_LEGACY 0
  2091. #define DX_HASH_HALF_MD4 1
  2092. #define DX_HASH_TEA 2
  2093. #define DX_HASH_LEGACY_UNSIGNED 3
  2094. #define DX_HASH_HALF_MD4_UNSIGNED 4
  2095. #define DX_HASH_TEA_UNSIGNED 5
  2096. #define DX_HASH_SIPHASH 6
  2097. static inline u32 ext4_chksum(struct ext4_sb_info *sbi, u32 crc,
  2098. const void *address, unsigned int length)
  2099. {
  2100. struct {
  2101. struct shash_desc shash;
  2102. char ctx[4];
  2103. } desc;
  2104. BUG_ON(crypto_shash_descsize(sbi->s_chksum_driver)!=sizeof(desc.ctx));
  2105. desc.shash.tfm = sbi->s_chksum_driver;
  2106. *(u32 *)desc.ctx = crc;
  2107. BUG_ON(crypto_shash_update(&desc.shash, address, length));
  2108. return *(u32 *)desc.ctx;
  2109. }
  2110. #ifdef __KERNEL__
  2111. /* hash info structure used by the directory hash */
  2112. struct dx_hash_info
  2113. {
  2114. u32 hash;
  2115. u32 minor_hash;
  2116. int hash_version;
  2117. u32 *seed;
  2118. };
  2119. /* 32 and 64 bit signed EOF for dx directories */
  2120. #define EXT4_HTREE_EOF_32BIT ((1UL << (32 - 1)) - 1)
  2121. #define EXT4_HTREE_EOF_64BIT ((1ULL << (64 - 1)) - 1)
  2122. /*
  2123. * Control parameters used by ext4_htree_next_block
  2124. */
  2125. #define HASH_NB_ALWAYS 1
  2126. struct ext4_filename {
  2127. const struct qstr *usr_fname;
  2128. struct fscrypt_str disk_name;
  2129. struct dx_hash_info hinfo;
  2130. #ifdef CONFIG_FS_ENCRYPTION
  2131. struct fscrypt_str crypto_buf;
  2132. #endif
  2133. #ifdef CONFIG_UNICODE
  2134. struct fscrypt_str cf_name;
  2135. #endif
  2136. };
  2137. #define fname_name(p) ((p)->disk_name.name)
  2138. #define fname_usr_name(p) ((p)->usr_fname->name)
  2139. #define fname_len(p) ((p)->disk_name.len)
  2140. /*
  2141. * Describe an inode's exact location on disk and in memory
  2142. */
  2143. struct ext4_iloc
  2144. {
  2145. struct buffer_head *bh;
  2146. unsigned long offset;
  2147. ext4_group_t block_group;
  2148. };
  2149. static inline struct ext4_inode *ext4_raw_inode(struct ext4_iloc *iloc)
  2150. {
  2151. return (struct ext4_inode *) (iloc->bh->b_data + iloc->offset);
  2152. }
  2153. static inline bool ext4_is_quota_file(struct inode *inode)
  2154. {
  2155. return IS_NOQUOTA(inode) &&
  2156. !(EXT4_I(inode)->i_flags & EXT4_EA_INODE_FL);
  2157. }
  2158. /*
  2159. * This structure is stuffed into the struct file's private_data field
  2160. * for directories. It is where we put information so that we can do
  2161. * readdir operations in hash tree order.
  2162. */
  2163. struct dir_private_info {
  2164. struct rb_root root;
  2165. struct rb_node *curr_node;
  2166. struct fname *extra_fname;
  2167. loff_t last_pos;
  2168. __u32 curr_hash;
  2169. __u32 curr_minor_hash;
  2170. __u32 next_hash;
  2171. };
  2172. /* calculate the first block number of the group */
  2173. static inline ext4_fsblk_t
  2174. ext4_group_first_block_no(struct super_block *sb, ext4_group_t group_no)
  2175. {
  2176. return group_no * (ext4_fsblk_t)EXT4_BLOCKS_PER_GROUP(sb) +
  2177. le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block);
  2178. }
  2179. /*
  2180. * Special error return code only used by dx_probe() and its callers.
  2181. */
  2182. #define ERR_BAD_DX_DIR (-(MAX_ERRNO - 1))
  2183. /* htree levels for ext4 */
  2184. #define EXT4_HTREE_LEVEL_COMPAT 2
  2185. #define EXT4_HTREE_LEVEL 3
  2186. static inline int ext4_dir_htree_level(struct super_block *sb)
  2187. {
  2188. return ext4_has_feature_largedir(sb) ?
  2189. EXT4_HTREE_LEVEL : EXT4_HTREE_LEVEL_COMPAT;
  2190. }
  2191. /*
  2192. * Timeout and state flag for lazy initialization inode thread.
  2193. */
  2194. #define EXT4_DEF_LI_WAIT_MULT 10
  2195. #define EXT4_DEF_LI_MAX_START_DELAY 5
  2196. #define EXT4_LAZYINIT_QUIT 0x0001
  2197. #define EXT4_LAZYINIT_RUNNING 0x0002
  2198. /*
  2199. * Lazy inode table initialization info
  2200. */
  2201. struct ext4_lazy_init {
  2202. unsigned long li_state;
  2203. struct list_head li_request_list;
  2204. struct mutex li_list_mtx;
  2205. };
  2206. enum ext4_li_mode {
  2207. EXT4_LI_MODE_PREFETCH_BBITMAP,
  2208. EXT4_LI_MODE_ITABLE,
  2209. };
  2210. struct ext4_li_request {
  2211. struct super_block *lr_super;
  2212. enum ext4_li_mode lr_mode;
  2213. ext4_group_t lr_first_not_zeroed;
  2214. ext4_group_t lr_next_group;
  2215. struct list_head lr_request;
  2216. unsigned long lr_next_sched;
  2217. unsigned long lr_timeout;
  2218. };
  2219. struct ext4_features {
  2220. struct kobject f_kobj;
  2221. struct completion f_kobj_unregister;
  2222. };
  2223. /*
  2224. * This structure will be used for multiple mount protection. It will be
  2225. * written into the block number saved in the s_mmp_block field in the
  2226. * superblock. Programs that check MMP should assume that if
  2227. * SEQ_FSCK (or any unknown code above SEQ_MAX) is present then it is NOT safe
  2228. * to use the filesystem, regardless of how old the timestamp is.
  2229. */
  2230. #define EXT4_MMP_MAGIC 0x004D4D50U /* ASCII for MMP */
  2231. #define EXT4_MMP_SEQ_CLEAN 0xFF4D4D50U /* mmp_seq value for clean unmount */
  2232. #define EXT4_MMP_SEQ_FSCK 0xE24D4D50U /* mmp_seq value when being fscked */
  2233. #define EXT4_MMP_SEQ_MAX 0xE24D4D4FU /* maximum valid mmp_seq value */
  2234. struct mmp_struct {
  2235. __le32 mmp_magic; /* Magic number for MMP */
  2236. __le32 mmp_seq; /* Sequence no. updated periodically */
  2237. /*
  2238. * mmp_time, mmp_nodename & mmp_bdevname are only used for information
  2239. * purposes and do not affect the correctness of the algorithm
  2240. */
  2241. __le64 mmp_time; /* Time last updated */
  2242. char mmp_nodename[64]; /* Node which last updated MMP block */
  2243. char mmp_bdevname[32]; /* Bdev which last updated MMP block */
  2244. /*
  2245. * mmp_check_interval is used to verify if the MMP block has been
  2246. * updated on the block device. The value is updated based on the
  2247. * maximum time to write the MMP block during an update cycle.
  2248. */
  2249. __le16 mmp_check_interval;
  2250. __le16 mmp_pad1;
  2251. __le32 mmp_pad2[226];
  2252. __le32 mmp_checksum; /* crc32c(uuid+mmp_block) */
  2253. };
  2254. /* arguments passed to the mmp thread */
  2255. struct mmpd_data {
  2256. struct buffer_head *bh; /* bh from initial read_mmp_block() */
  2257. struct super_block *sb; /* super block of the fs */
  2258. };
  2259. /*
  2260. * Check interval multiplier
  2261. * The MMP block is written every update interval and initially checked every
  2262. * update interval x the multiplier (the value is then adapted based on the
  2263. * write latency). The reason is that writes can be delayed under load and we
  2264. * don't want readers to incorrectly assume that the filesystem is no longer
  2265. * in use.
  2266. */
  2267. #define EXT4_MMP_CHECK_MULT 2UL
  2268. /*
  2269. * Minimum interval for MMP checking in seconds.
  2270. */
  2271. #define EXT4_MMP_MIN_CHECK_INTERVAL 5UL
  2272. /*
  2273. * Maximum interval for MMP checking in seconds.
  2274. */
  2275. #define EXT4_MMP_MAX_CHECK_INTERVAL 300UL
  2276. /*
  2277. * Function prototypes
  2278. */
  2279. /*
  2280. * Ok, these declarations are also in <linux/kernel.h> but none of the
  2281. * ext4 source programs needs to include it so they are duplicated here.
  2282. */
  2283. # define NORET_TYPE /**/
  2284. # define ATTRIB_NORET __attribute__((noreturn))
  2285. # define NORET_AND noreturn,
  2286. /* bitmap.c */
  2287. extern unsigned int ext4_count_free(char *bitmap, unsigned numchars);
  2288. void ext4_inode_bitmap_csum_set(struct super_block *sb, ext4_group_t group,
  2289. struct ext4_group_desc *gdp,
  2290. struct buffer_head *bh, int sz);
  2291. int ext4_inode_bitmap_csum_verify(struct super_block *sb, ext4_group_t group,
  2292. struct ext4_group_desc *gdp,
  2293. struct buffer_head *bh, int sz);
  2294. void ext4_block_bitmap_csum_set(struct super_block *sb, ext4_group_t group,
  2295. struct ext4_group_desc *gdp,
  2296. struct buffer_head *bh);
  2297. int ext4_block_bitmap_csum_verify(struct super_block *sb, ext4_group_t group,
  2298. struct ext4_group_desc *gdp,
  2299. struct buffer_head *bh);
  2300. /* balloc.c */
  2301. extern void ext4_get_group_no_and_offset(struct super_block *sb,
  2302. ext4_fsblk_t blocknr,
  2303. ext4_group_t *blockgrpp,
  2304. ext4_grpblk_t *offsetp);
  2305. extern ext4_group_t ext4_get_group_number(struct super_block *sb,
  2306. ext4_fsblk_t block);
  2307. extern unsigned int ext4_block_group(struct super_block *sb,
  2308. ext4_fsblk_t blocknr);
  2309. extern ext4_grpblk_t ext4_block_group_offset(struct super_block *sb,
  2310. ext4_fsblk_t blocknr);
  2311. extern int ext4_bg_has_super(struct super_block *sb, ext4_group_t group);
  2312. extern unsigned long ext4_bg_num_gdb(struct super_block *sb,
  2313. ext4_group_t group);
  2314. extern ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode,
  2315. ext4_fsblk_t goal,
  2316. unsigned int flags,
  2317. unsigned long *count,
  2318. int *errp);
  2319. extern int ext4_claim_free_clusters(struct ext4_sb_info *sbi,
  2320. s64 nclusters, unsigned int flags);
  2321. extern ext4_fsblk_t ext4_count_free_clusters(struct super_block *);
  2322. extern void ext4_check_blocks_bitmap(struct super_block *);
  2323. extern struct ext4_group_desc * ext4_get_group_desc(struct super_block * sb,
  2324. ext4_group_t block_group,
  2325. struct buffer_head ** bh);
  2326. extern int ext4_should_retry_alloc(struct super_block *sb, int *retries);
  2327. extern struct buffer_head *ext4_read_block_bitmap_nowait(struct super_block *sb,
  2328. ext4_group_t block_group,
  2329. bool ignore_locked);
  2330. extern int ext4_wait_block_bitmap(struct super_block *sb,
  2331. ext4_group_t block_group,
  2332. struct buffer_head *bh);
  2333. extern struct buffer_head *ext4_read_block_bitmap(struct super_block *sb,
  2334. ext4_group_t block_group);
  2335. extern unsigned ext4_free_clusters_after_init(struct super_block *sb,
  2336. ext4_group_t block_group,
  2337. struct ext4_group_desc *gdp);
  2338. ext4_fsblk_t ext4_inode_to_goal_block(struct inode *);
  2339. #ifdef CONFIG_UNICODE
  2340. extern int ext4_fname_setup_ci_filename(struct inode *dir,
  2341. const struct qstr *iname,
  2342. struct ext4_filename *fname);
  2343. #endif
  2344. #ifdef CONFIG_FS_ENCRYPTION
  2345. static inline void ext4_fname_from_fscrypt_name(struct ext4_filename *dst,
  2346. const struct fscrypt_name *src)
  2347. {
  2348. memset(dst, 0, sizeof(*dst));
  2349. dst->usr_fname = src->usr_fname;
  2350. dst->disk_name = src->disk_name;
  2351. dst->hinfo.hash = src->hash;
  2352. dst->hinfo.minor_hash = src->minor_hash;
  2353. dst->crypto_buf = src->crypto_buf;
  2354. }
  2355. static inline int ext4_fname_setup_filename(struct inode *dir,
  2356. const struct qstr *iname,
  2357. int lookup,
  2358. struct ext4_filename *fname)
  2359. {
  2360. struct fscrypt_name name;
  2361. int err;
  2362. err = fscrypt_setup_filename(dir, iname, lookup, &name);
  2363. if (err)
  2364. return err;
  2365. ext4_fname_from_fscrypt_name(fname, &name);
  2366. #ifdef CONFIG_UNICODE
  2367. err = ext4_fname_setup_ci_filename(dir, iname, fname);
  2368. #endif
  2369. return err;
  2370. }
  2371. static inline int ext4_fname_prepare_lookup(struct inode *dir,
  2372. struct dentry *dentry,
  2373. struct ext4_filename *fname)
  2374. {
  2375. struct fscrypt_name name;
  2376. int err;
  2377. err = fscrypt_prepare_lookup(dir, dentry, &name);
  2378. if (err)
  2379. return err;
  2380. ext4_fname_from_fscrypt_name(fname, &name);
  2381. #ifdef CONFIG_UNICODE
  2382. err = ext4_fname_setup_ci_filename(dir, &dentry->d_name, fname);
  2383. #endif
  2384. return err;
  2385. }
  2386. static inline void ext4_fname_free_filename(struct ext4_filename *fname)
  2387. {
  2388. struct fscrypt_name name;
  2389. name.crypto_buf = fname->crypto_buf;
  2390. fscrypt_free_filename(&name);
  2391. fname->crypto_buf.name = NULL;
  2392. fname->usr_fname = NULL;
  2393. fname->disk_name.name = NULL;
  2394. #ifdef CONFIG_UNICODE
  2395. kfree(fname->cf_name.name);
  2396. fname->cf_name.name = NULL;
  2397. #endif
  2398. }
  2399. #else /* !CONFIG_FS_ENCRYPTION */
  2400. static inline int ext4_fname_setup_filename(struct inode *dir,
  2401. const struct qstr *iname,
  2402. int lookup,
  2403. struct ext4_filename *fname)
  2404. {
  2405. int err = 0;
  2406. fname->usr_fname = iname;
  2407. fname->disk_name.name = (unsigned char *) iname->name;
  2408. fname->disk_name.len = iname->len;
  2409. #ifdef CONFIG_UNICODE
  2410. err = ext4_fname_setup_ci_filename(dir, iname, fname);
  2411. #endif
  2412. return err;
  2413. }
  2414. static inline int ext4_fname_prepare_lookup(struct inode *dir,
  2415. struct dentry *dentry,
  2416. struct ext4_filename *fname)
  2417. {
  2418. return ext4_fname_setup_filename(dir, &dentry->d_name, 1, fname);
  2419. }
  2420. static inline void ext4_fname_free_filename(struct ext4_filename *fname)
  2421. {
  2422. #ifdef CONFIG_UNICODE
  2423. kfree(fname->cf_name.name);
  2424. fname->cf_name.name = NULL;
  2425. #endif
  2426. }
  2427. #endif /* !CONFIG_FS_ENCRYPTION */
  2428. /* dir.c */
  2429. extern int __ext4_check_dir_entry(const char *, unsigned int, struct inode *,
  2430. struct file *,
  2431. struct ext4_dir_entry_2 *,
  2432. struct buffer_head *, char *, int,
  2433. ext4_lblk_t, unsigned int);
  2434. #define ext4_check_dir_entry(dir, filp, de, bh, buf, size, lblk, offset) \
  2435. unlikely(__ext4_check_dir_entry(__func__, __LINE__, (dir), (filp), \
  2436. (de), (bh), (buf), (size), (lblk), (offset)))
  2437. extern int ext4_htree_store_dirent(struct file *dir_file, __u32 hash,
  2438. __u32 minor_hash,
  2439. struct ext4_dir_entry_2 *dirent,
  2440. struct fscrypt_str *ent_name);
  2441. extern void ext4_htree_free_dir_info(struct dir_private_info *p);
  2442. extern int ext4_find_dest_de(struct inode *dir, struct inode *inode,
  2443. ext4_lblk_t lblk,
  2444. struct buffer_head *bh,
  2445. void *buf, int buf_size,
  2446. struct ext4_filename *fname,
  2447. struct ext4_dir_entry_2 **dest_de);
  2448. void ext4_insert_dentry(struct inode *dir, struct inode *inode,
  2449. struct ext4_dir_entry_2 *de,
  2450. int buf_size,
  2451. struct ext4_filename *fname);
  2452. static inline void ext4_update_dx_flag(struct inode *inode)
  2453. {
  2454. if (!ext4_has_feature_dir_index(inode->i_sb) &&
  2455. ext4_test_inode_flag(inode, EXT4_INODE_INDEX)) {
  2456. /* ext4_iget() should have caught this... */
  2457. WARN_ON_ONCE(ext4_has_feature_metadata_csum(inode->i_sb));
  2458. ext4_clear_inode_flag(inode, EXT4_INODE_INDEX);
  2459. }
  2460. }
  2461. static const unsigned char ext4_filetype_table[] = {
  2462. DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
  2463. };
  2464. static inline unsigned char get_dtype(struct super_block *sb, int filetype)
  2465. {
  2466. if (!ext4_has_feature_filetype(sb) || filetype >= EXT4_FT_MAX)
  2467. return DT_UNKNOWN;
  2468. return ext4_filetype_table[filetype];
  2469. }
  2470. extern int ext4_check_all_de(struct inode *dir, struct buffer_head *bh,
  2471. void *buf, int buf_size);
  2472. /* fsync.c */
  2473. extern int ext4_sync_file(struct file *, loff_t, loff_t, int);
  2474. /* hash.c */
  2475. extern int ext4fs_dirhash(const struct inode *dir, const char *name, int len,
  2476. struct dx_hash_info *hinfo);
  2477. /* ialloc.c */
  2478. extern int ext4_mark_inode_used(struct super_block *sb, int ino);
  2479. extern struct inode *__ext4_new_inode(handle_t *, struct inode *, umode_t,
  2480. const struct qstr *qstr, __u32 goal,
  2481. uid_t *owner, __u32 i_flags,
  2482. int handle_type, unsigned int line_no,
  2483. int nblocks);
  2484. #define ext4_new_inode(handle, dir, mode, qstr, goal, owner, i_flags) \
  2485. __ext4_new_inode((handle), (dir), (mode), (qstr), (goal), (owner), \
  2486. i_flags, 0, 0, 0)
  2487. #define ext4_new_inode_start_handle(dir, mode, qstr, goal, owner, \
  2488. type, nblocks) \
  2489. __ext4_new_inode(NULL, (dir), (mode), (qstr), (goal), (owner), \
  2490. 0, (type), __LINE__, (nblocks))
  2491. extern void ext4_free_inode(handle_t *, struct inode *);
  2492. extern struct inode * ext4_orphan_get(struct super_block *, unsigned long);
  2493. extern unsigned long ext4_count_free_inodes(struct super_block *);
  2494. extern unsigned long ext4_count_dirs(struct super_block *);
  2495. extern void ext4_check_inodes_bitmap(struct super_block *);
  2496. extern void ext4_mark_bitmap_end(int start_bit, int end_bit, char *bitmap);
  2497. extern int ext4_init_inode_table(struct super_block *sb,
  2498. ext4_group_t group, int barrier);
  2499. extern void ext4_end_bitmap_read(struct buffer_head *bh, int uptodate);
  2500. /* fast_commit.c */
  2501. int ext4_fc_info_show(struct seq_file *seq, void *v);
  2502. void ext4_fc_init(struct super_block *sb, journal_t *journal);
  2503. void ext4_fc_init_inode(struct inode *inode);
  2504. void ext4_fc_track_range(handle_t *handle, struct inode *inode, ext4_lblk_t start,
  2505. ext4_lblk_t end);
  2506. void __ext4_fc_track_unlink(handle_t *handle, struct inode *inode,
  2507. struct dentry *dentry);
  2508. void __ext4_fc_track_link(handle_t *handle, struct inode *inode,
  2509. struct dentry *dentry);
  2510. void ext4_fc_track_unlink(handle_t *handle, struct dentry *dentry);
  2511. void ext4_fc_track_link(handle_t *handle, struct dentry *dentry);
  2512. void __ext4_fc_track_create(handle_t *handle, struct inode *inode,
  2513. struct dentry *dentry);
  2514. void ext4_fc_track_create(handle_t *handle, struct dentry *dentry);
  2515. void ext4_fc_track_inode(handle_t *handle, struct inode *inode);
  2516. void ext4_fc_mark_ineligible(struct super_block *sb, int reason);
  2517. void ext4_fc_start_ineligible(struct super_block *sb, int reason);
  2518. void ext4_fc_stop_ineligible(struct super_block *sb);
  2519. void ext4_fc_start_update(struct inode *inode);
  2520. void ext4_fc_stop_update(struct inode *inode);
  2521. void ext4_fc_del(struct inode *inode);
  2522. bool ext4_fc_replay_check_excluded(struct super_block *sb, ext4_fsblk_t block);
  2523. void ext4_fc_replay_cleanup(struct super_block *sb);
  2524. int ext4_fc_commit(journal_t *journal, tid_t commit_tid);
  2525. int __init ext4_fc_init_dentry_cache(void);
  2526. void ext4_fc_destroy_dentry_cache(void);
  2527. int ext4_fc_record_regions(struct super_block *sb, int ino,
  2528. ext4_lblk_t lblk, ext4_fsblk_t pblk,
  2529. int len, int replay);
  2530. /* mballoc.c */
  2531. extern const struct seq_operations ext4_mb_seq_groups_ops;
  2532. extern long ext4_mb_stats;
  2533. extern long ext4_mb_max_to_scan;
  2534. extern int ext4_mb_init(struct super_block *);
  2535. extern int ext4_mb_release(struct super_block *);
  2536. extern ext4_fsblk_t ext4_mb_new_blocks(handle_t *,
  2537. struct ext4_allocation_request *, int *);
  2538. extern int ext4_mb_reserve_blocks(struct super_block *, int);
  2539. extern void ext4_discard_preallocations(struct inode *, unsigned int);
  2540. extern int __init ext4_init_mballoc(void);
  2541. extern void ext4_exit_mballoc(void);
  2542. extern ext4_group_t ext4_mb_prefetch(struct super_block *sb,
  2543. ext4_group_t group,
  2544. unsigned int nr, int *cnt);
  2545. extern void ext4_mb_prefetch_fini(struct super_block *sb, ext4_group_t group,
  2546. unsigned int nr);
  2547. extern void ext4_free_blocks(handle_t *handle, struct inode *inode,
  2548. struct buffer_head *bh, ext4_fsblk_t block,
  2549. unsigned long count, int flags);
  2550. extern int ext4_mb_alloc_groupinfo(struct super_block *sb,
  2551. ext4_group_t ngroups);
  2552. extern int ext4_mb_add_groupinfo(struct super_block *sb,
  2553. ext4_group_t i, struct ext4_group_desc *desc);
  2554. extern int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
  2555. ext4_fsblk_t block, unsigned long count);
  2556. extern int ext4_trim_fs(struct super_block *, struct fstrim_range *);
  2557. extern void ext4_process_freed_data(struct super_block *sb, tid_t commit_tid);
  2558. extern void ext4_mb_mark_bb(struct super_block *sb, ext4_fsblk_t block,
  2559. int len, int state);
  2560. /* inode.c */
  2561. void ext4_inode_csum_set(struct inode *inode, struct ext4_inode *raw,
  2562. struct ext4_inode_info *ei);
  2563. int ext4_inode_is_fast_symlink(struct inode *inode);
  2564. struct buffer_head *ext4_getblk(handle_t *, struct inode *, ext4_lblk_t, int);
  2565. struct buffer_head *ext4_bread(handle_t *, struct inode *, ext4_lblk_t, int);
  2566. int ext4_bread_batch(struct inode *inode, ext4_lblk_t block, int bh_count,
  2567. bool wait, struct buffer_head **bhs);
  2568. int ext4_get_block_unwritten(struct inode *inode, sector_t iblock,
  2569. struct buffer_head *bh_result, int create);
  2570. int ext4_get_block(struct inode *inode, sector_t iblock,
  2571. struct buffer_head *bh_result, int create);
  2572. int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
  2573. struct buffer_head *bh, int create);
  2574. int ext4_walk_page_buffers(handle_t *handle,
  2575. struct buffer_head *head,
  2576. unsigned from,
  2577. unsigned to,
  2578. int *partial,
  2579. int (*fn)(handle_t *handle,
  2580. struct buffer_head *bh));
  2581. int do_journal_get_write_access(handle_t *handle,
  2582. struct buffer_head *bh);
  2583. #define FALL_BACK_TO_NONDELALLOC 1
  2584. #define CONVERT_INLINE_DATA 2
  2585. typedef enum {
  2586. EXT4_IGET_NORMAL = 0,
  2587. EXT4_IGET_SPECIAL = 0x0001, /* OK to iget a system inode */
  2588. EXT4_IGET_HANDLE = 0x0002 /* Inode # is from a handle */
  2589. } ext4_iget_flags;
  2590. extern struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
  2591. ext4_iget_flags flags, const char *function,
  2592. unsigned int line);
  2593. #define ext4_iget(sb, ino, flags) \
  2594. __ext4_iget((sb), (ino), (flags), __func__, __LINE__)
  2595. extern int ext4_write_inode(struct inode *, struct writeback_control *);
  2596. extern int ext4_setattr(struct dentry *, struct iattr *);
  2597. extern int ext4_getattr(const struct path *, struct kstat *, u32, unsigned int);
  2598. extern void ext4_evict_inode(struct inode *);
  2599. extern void ext4_clear_inode(struct inode *);
  2600. extern int ext4_file_getattr(const struct path *, struct kstat *, u32, unsigned int);
  2601. extern int ext4_sync_inode(handle_t *, struct inode *);
  2602. extern void ext4_dirty_inode(struct inode *, int);
  2603. extern int ext4_change_inode_journal_flag(struct inode *, int);
  2604. extern int ext4_get_inode_loc(struct inode *, struct ext4_iloc *);
  2605. extern int ext4_get_fc_inode_loc(struct super_block *sb, unsigned long ino,
  2606. struct ext4_iloc *iloc);
  2607. extern int ext4_inode_attach_jinode(struct inode *inode);
  2608. extern int ext4_can_truncate(struct inode *inode);
  2609. extern int ext4_truncate(struct inode *);
  2610. extern int ext4_break_layouts(struct inode *);
  2611. extern int ext4_punch_hole(struct file *file, loff_t offset, loff_t length);
  2612. extern void ext4_set_inode_flags(struct inode *, bool init);
  2613. extern int ext4_alloc_da_blocks(struct inode *inode);
  2614. extern void ext4_set_aops(struct inode *inode);
  2615. extern int ext4_writepage_trans_blocks(struct inode *);
  2616. extern int ext4_chunk_trans_blocks(struct inode *, int nrblocks);
  2617. extern int ext4_zero_partial_blocks(handle_t *handle, struct inode *inode,
  2618. loff_t lstart, loff_t lend);
  2619. extern vm_fault_t ext4_page_mkwrite(struct vm_fault *vmf);
  2620. extern vm_fault_t ext4_filemap_fault(struct vm_fault *vmf);
  2621. extern qsize_t *ext4_get_reserved_space(struct inode *inode);
  2622. extern int ext4_get_projid(struct inode *inode, kprojid_t *projid);
  2623. extern void ext4_da_release_space(struct inode *inode, int to_free);
  2624. extern void ext4_da_update_reserve_space(struct inode *inode,
  2625. int used, int quota_claim);
  2626. extern int ext4_issue_zeroout(struct inode *inode, ext4_lblk_t lblk,
  2627. ext4_fsblk_t pblk, ext4_lblk_t len);
  2628. /* indirect.c */
  2629. extern int ext4_ind_map_blocks(handle_t *handle, struct inode *inode,
  2630. struct ext4_map_blocks *map, int flags);
  2631. extern int ext4_ind_trans_blocks(struct inode *inode, int nrblocks);
  2632. extern void ext4_ind_truncate(handle_t *, struct inode *inode);
  2633. extern int ext4_ind_remove_space(handle_t *handle, struct inode *inode,
  2634. ext4_lblk_t start, ext4_lblk_t end);
  2635. /* ioctl.c */
  2636. extern long ext4_ioctl(struct file *, unsigned int, unsigned long);
  2637. extern long ext4_compat_ioctl(struct file *, unsigned int, unsigned long);
  2638. extern void ext4_reset_inode_seed(struct inode *inode);
  2639. /* migrate.c */
  2640. extern int ext4_ext_migrate(struct inode *);
  2641. extern int ext4_ind_migrate(struct inode *inode);
  2642. /* namei.c */
  2643. extern int ext4_init_new_dir(handle_t *handle, struct inode *dir,
  2644. struct inode *inode);
  2645. extern int ext4_dirblock_csum_verify(struct inode *inode,
  2646. struct buffer_head *bh);
  2647. extern int ext4_orphan_add(handle_t *, struct inode *);
  2648. extern int ext4_orphan_del(handle_t *, struct inode *);
  2649. extern int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
  2650. __u32 start_minor_hash, __u32 *next_hash);
  2651. extern int ext4_search_dir(struct buffer_head *bh,
  2652. char *search_buf,
  2653. int buf_size,
  2654. struct inode *dir,
  2655. struct ext4_filename *fname,
  2656. ext4_lblk_t lblk, unsigned int offset,
  2657. struct ext4_dir_entry_2 **res_dir);
  2658. extern int ext4_generic_delete_entry(struct inode *dir,
  2659. struct ext4_dir_entry_2 *de_del,
  2660. ext4_lblk_t lblk,
  2661. struct buffer_head *bh,
  2662. void *entry_buf,
  2663. int buf_size,
  2664. int csum_size);
  2665. extern bool ext4_empty_dir(struct inode *inode);
  2666. /* resize.c */
  2667. extern void ext4_kvfree_array_rcu(void *to_free);
  2668. extern int ext4_group_add(struct super_block *sb,
  2669. struct ext4_new_group_data *input);
  2670. extern int ext4_group_extend(struct super_block *sb,
  2671. struct ext4_super_block *es,
  2672. ext4_fsblk_t n_blocks_count);
  2673. extern int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count);
  2674. /* super.c */
  2675. extern struct buffer_head *ext4_sb_bread(struct super_block *sb,
  2676. sector_t block, int op_flags);
  2677. extern struct buffer_head *ext4_sb_bread_unmovable(struct super_block *sb,
  2678. sector_t block);
  2679. extern void ext4_read_bh_nowait(struct buffer_head *bh, int op_flags,
  2680. bh_end_io_t *end_io);
  2681. extern int ext4_read_bh(struct buffer_head *bh, int op_flags,
  2682. bh_end_io_t *end_io);
  2683. extern int ext4_read_bh_lock(struct buffer_head *bh, int op_flags, bool wait);
  2684. extern void ext4_sb_breadahead_unmovable(struct super_block *sb, sector_t block);
  2685. extern int ext4_seq_options_show(struct seq_file *seq, void *offset);
  2686. extern int ext4_calculate_overhead(struct super_block *sb);
  2687. extern void ext4_superblock_csum_set(struct super_block *sb);
  2688. extern int ext4_alloc_flex_bg_array(struct super_block *sb,
  2689. ext4_group_t ngroup);
  2690. extern const char *ext4_decode_error(struct super_block *sb, int errno,
  2691. char nbuf[16]);
  2692. extern void ext4_mark_group_bitmap_corrupted(struct super_block *sb,
  2693. ext4_group_t block_group,
  2694. unsigned int flags);
  2695. extern __printf(6, 7)
  2696. void __ext4_error(struct super_block *, const char *, unsigned int, int, __u64,
  2697. const char *, ...);
  2698. extern __printf(6, 7)
  2699. void __ext4_error_inode(struct inode *, const char *, unsigned int,
  2700. ext4_fsblk_t, int, const char *, ...);
  2701. extern __printf(5, 6)
  2702. void __ext4_error_file(struct file *, const char *, unsigned int, ext4_fsblk_t,
  2703. const char *, ...);
  2704. extern void __ext4_std_error(struct super_block *, const char *,
  2705. unsigned int, int);
  2706. extern __printf(5, 6)
  2707. void __ext4_abort(struct super_block *, const char *, unsigned int, int,
  2708. const char *, ...);
  2709. extern __printf(4, 5)
  2710. void __ext4_warning(struct super_block *, const char *, unsigned int,
  2711. const char *, ...);
  2712. extern __printf(4, 5)
  2713. void __ext4_warning_inode(const struct inode *inode, const char *function,
  2714. unsigned int line, const char *fmt, ...);
  2715. extern __printf(3, 4)
  2716. void __ext4_msg(struct super_block *, const char *, const char *, ...);
  2717. extern void __dump_mmp_msg(struct super_block *, struct mmp_struct *mmp,
  2718. const char *, unsigned int, const char *);
  2719. extern __printf(7, 8)
  2720. void __ext4_grp_locked_error(const char *, unsigned int,
  2721. struct super_block *, ext4_group_t,
  2722. unsigned long, ext4_fsblk_t,
  2723. const char *, ...);
  2724. #define EXT4_ERROR_INODE(inode, fmt, a...) \
  2725. ext4_error_inode((inode), __func__, __LINE__, 0, (fmt), ## a)
  2726. #define EXT4_ERROR_INODE_ERR(inode, err, fmt, a...) \
  2727. __ext4_error_inode((inode), __func__, __LINE__, 0, (err), (fmt), ## a)
  2728. #define ext4_error_inode_block(inode, block, err, fmt, a...) \
  2729. __ext4_error_inode((inode), __func__, __LINE__, (block), (err), \
  2730. (fmt), ## a)
  2731. #define EXT4_ERROR_FILE(file, block, fmt, a...) \
  2732. ext4_error_file((file), __func__, __LINE__, (block), (fmt), ## a)
  2733. #ifdef CONFIG_PRINTK
  2734. #define ext4_error_inode(inode, func, line, block, fmt, ...) \
  2735. __ext4_error_inode(inode, func, line, block, 0, fmt, ##__VA_ARGS__)
  2736. #define ext4_error_inode_err(inode, func, line, block, err, fmt, ...) \
  2737. __ext4_error_inode((inode), (func), (line), (block), \
  2738. (err), (fmt), ##__VA_ARGS__)
  2739. #define ext4_error_file(file, func, line, block, fmt, ...) \
  2740. __ext4_error_file(file, func, line, block, fmt, ##__VA_ARGS__)
  2741. #define ext4_error(sb, fmt, ...) \
  2742. __ext4_error((sb), __func__, __LINE__, 0, 0, (fmt), ##__VA_ARGS__)
  2743. #define ext4_error_err(sb, err, fmt, ...) \
  2744. __ext4_error((sb), __func__, __LINE__, (err), 0, (fmt), ##__VA_ARGS__)
  2745. #define ext4_abort(sb, err, fmt, ...) \
  2746. __ext4_abort((sb), __func__, __LINE__, (err), (fmt), ##__VA_ARGS__)
  2747. #define ext4_warning(sb, fmt, ...) \
  2748. __ext4_warning(sb, __func__, __LINE__, fmt, ##__VA_ARGS__)
  2749. #define ext4_warning_inode(inode, fmt, ...) \
  2750. __ext4_warning_inode(inode, __func__, __LINE__, fmt, ##__VA_ARGS__)
  2751. #define ext4_msg(sb, level, fmt, ...) \
  2752. __ext4_msg(sb, level, fmt, ##__VA_ARGS__)
  2753. #define dump_mmp_msg(sb, mmp, msg) \
  2754. __dump_mmp_msg(sb, mmp, __func__, __LINE__, msg)
  2755. #define ext4_grp_locked_error(sb, grp, ino, block, fmt, ...) \
  2756. __ext4_grp_locked_error(__func__, __LINE__, sb, grp, ino, block, \
  2757. fmt, ##__VA_ARGS__)
  2758. #else
  2759. #define ext4_error_inode(inode, func, line, block, fmt, ...) \
  2760. do { \
  2761. no_printk(fmt, ##__VA_ARGS__); \
  2762. __ext4_error_inode(inode, "", 0, block, 0, " "); \
  2763. } while (0)
  2764. #define ext4_error_inode_err(inode, func, line, block, err, fmt, ...) \
  2765. do { \
  2766. no_printk(fmt, ##__VA_ARGS__); \
  2767. __ext4_error_inode(inode, "", 0, block, err, " "); \
  2768. } while (0)
  2769. #define ext4_error_file(file, func, line, block, fmt, ...) \
  2770. do { \
  2771. no_printk(fmt, ##__VA_ARGS__); \
  2772. __ext4_error_file(file, "", 0, block, " "); \
  2773. } while (0)
  2774. #define ext4_error(sb, fmt, ...) \
  2775. do { \
  2776. no_printk(fmt, ##__VA_ARGS__); \
  2777. __ext4_error(sb, "", 0, 0, 0, " "); \
  2778. } while (0)
  2779. #define ext4_error_err(sb, err, fmt, ...) \
  2780. do { \
  2781. no_printk(fmt, ##__VA_ARGS__); \
  2782. __ext4_error(sb, "", 0, err, 0, " "); \
  2783. } while (0)
  2784. #define ext4_abort(sb, err, fmt, ...) \
  2785. do { \
  2786. no_printk(fmt, ##__VA_ARGS__); \
  2787. __ext4_abort(sb, "", 0, err, " "); \
  2788. } while (0)
  2789. #define ext4_warning(sb, fmt, ...) \
  2790. do { \
  2791. no_printk(fmt, ##__VA_ARGS__); \
  2792. __ext4_warning(sb, "", 0, " "); \
  2793. } while (0)
  2794. #define ext4_warning_inode(inode, fmt, ...) \
  2795. do { \
  2796. no_printk(fmt, ##__VA_ARGS__); \
  2797. __ext4_warning_inode(inode, "", 0, " "); \
  2798. } while (0)
  2799. #define ext4_msg(sb, level, fmt, ...) \
  2800. do { \
  2801. no_printk(fmt, ##__VA_ARGS__); \
  2802. __ext4_msg(sb, "", " "); \
  2803. } while (0)
  2804. #define dump_mmp_msg(sb, mmp, msg) \
  2805. __dump_mmp_msg(sb, mmp, "", 0, "")
  2806. #define ext4_grp_locked_error(sb, grp, ino, block, fmt, ...) \
  2807. do { \
  2808. no_printk(fmt, ##__VA_ARGS__); \
  2809. __ext4_grp_locked_error("", 0, sb, grp, ino, block, " "); \
  2810. } while (0)
  2811. #endif
  2812. extern ext4_fsblk_t ext4_block_bitmap(struct super_block *sb,
  2813. struct ext4_group_desc *bg);
  2814. extern ext4_fsblk_t ext4_inode_bitmap(struct super_block *sb,
  2815. struct ext4_group_desc *bg);
  2816. extern ext4_fsblk_t ext4_inode_table(struct super_block *sb,
  2817. struct ext4_group_desc *bg);
  2818. extern __u32 ext4_free_group_clusters(struct super_block *sb,
  2819. struct ext4_group_desc *bg);
  2820. extern __u32 ext4_free_inodes_count(struct super_block *sb,
  2821. struct ext4_group_desc *bg);
  2822. extern __u32 ext4_used_dirs_count(struct super_block *sb,
  2823. struct ext4_group_desc *bg);
  2824. extern __u32 ext4_itable_unused_count(struct super_block *sb,
  2825. struct ext4_group_desc *bg);
  2826. extern void ext4_block_bitmap_set(struct super_block *sb,
  2827. struct ext4_group_desc *bg, ext4_fsblk_t blk);
  2828. extern void ext4_inode_bitmap_set(struct super_block *sb,
  2829. struct ext4_group_desc *bg, ext4_fsblk_t blk);
  2830. extern void ext4_inode_table_set(struct super_block *sb,
  2831. struct ext4_group_desc *bg, ext4_fsblk_t blk);
  2832. extern void ext4_free_group_clusters_set(struct super_block *sb,
  2833. struct ext4_group_desc *bg,
  2834. __u32 count);
  2835. extern void ext4_free_inodes_set(struct super_block *sb,
  2836. struct ext4_group_desc *bg, __u32 count);
  2837. extern void ext4_used_dirs_set(struct super_block *sb,
  2838. struct ext4_group_desc *bg, __u32 count);
  2839. extern void ext4_itable_unused_set(struct super_block *sb,
  2840. struct ext4_group_desc *bg, __u32 count);
  2841. extern int ext4_group_desc_csum_verify(struct super_block *sb, __u32 group,
  2842. struct ext4_group_desc *gdp);
  2843. extern void ext4_group_desc_csum_set(struct super_block *sb, __u32 group,
  2844. struct ext4_group_desc *gdp);
  2845. extern int ext4_register_li_request(struct super_block *sb,
  2846. ext4_group_t first_not_zeroed);
  2847. static inline int ext4_has_metadata_csum(struct super_block *sb)
  2848. {
  2849. WARN_ON_ONCE(ext4_has_feature_metadata_csum(sb) &&
  2850. !EXT4_SB(sb)->s_chksum_driver);
  2851. return ext4_has_feature_metadata_csum(sb) &&
  2852. (EXT4_SB(sb)->s_chksum_driver != NULL);
  2853. }
  2854. static inline int ext4_has_group_desc_csum(struct super_block *sb)
  2855. {
  2856. return ext4_has_feature_gdt_csum(sb) || ext4_has_metadata_csum(sb);
  2857. }
  2858. #define ext4_read_incompat_64bit_val(es, name) \
  2859. (((es)->s_feature_incompat & cpu_to_le32(EXT4_FEATURE_INCOMPAT_64BIT) \
  2860. ? (ext4_fsblk_t)le32_to_cpu(es->name##_hi) << 32 : 0) | \
  2861. le32_to_cpu(es->name##_lo))
  2862. static inline ext4_fsblk_t ext4_blocks_count(struct ext4_super_block *es)
  2863. {
  2864. return ext4_read_incompat_64bit_val(es, s_blocks_count);
  2865. }
  2866. static inline ext4_fsblk_t ext4_r_blocks_count(struct ext4_super_block *es)
  2867. {
  2868. return ext4_read_incompat_64bit_val(es, s_r_blocks_count);
  2869. }
  2870. static inline ext4_fsblk_t ext4_free_blocks_count(struct ext4_super_block *es)
  2871. {
  2872. return ext4_read_incompat_64bit_val(es, s_free_blocks_count);
  2873. }
  2874. static inline void ext4_blocks_count_set(struct ext4_super_block *es,
  2875. ext4_fsblk_t blk)
  2876. {
  2877. es->s_blocks_count_lo = cpu_to_le32((u32)blk);
  2878. es->s_blocks_count_hi = cpu_to_le32(blk >> 32);
  2879. }
  2880. static inline void ext4_free_blocks_count_set(struct ext4_super_block *es,
  2881. ext4_fsblk_t blk)
  2882. {
  2883. es->s_free_blocks_count_lo = cpu_to_le32((u32)blk);
  2884. es->s_free_blocks_count_hi = cpu_to_le32(blk >> 32);
  2885. }
  2886. static inline void ext4_r_blocks_count_set(struct ext4_super_block *es,
  2887. ext4_fsblk_t blk)
  2888. {
  2889. es->s_r_blocks_count_lo = cpu_to_le32((u32)blk);
  2890. es->s_r_blocks_count_hi = cpu_to_le32(blk >> 32);
  2891. }
  2892. static inline loff_t ext4_isize(struct super_block *sb,
  2893. struct ext4_inode *raw_inode)
  2894. {
  2895. if (ext4_has_feature_largedir(sb) ||
  2896. S_ISREG(le16_to_cpu(raw_inode->i_mode)))
  2897. return ((loff_t)le32_to_cpu(raw_inode->i_size_high) << 32) |
  2898. le32_to_cpu(raw_inode->i_size_lo);
  2899. return (loff_t) le32_to_cpu(raw_inode->i_size_lo);
  2900. }
  2901. static inline void ext4_isize_set(struct ext4_inode *raw_inode, loff_t i_size)
  2902. {
  2903. raw_inode->i_size_lo = cpu_to_le32(i_size);
  2904. raw_inode->i_size_high = cpu_to_le32(i_size >> 32);
  2905. }
  2906. static inline
  2907. struct ext4_group_info *ext4_get_group_info(struct super_block *sb,
  2908. ext4_group_t group)
  2909. {
  2910. struct ext4_group_info **grp_info;
  2911. long indexv, indexh;
  2912. BUG_ON(group >= EXT4_SB(sb)->s_groups_count);
  2913. indexv = group >> (EXT4_DESC_PER_BLOCK_BITS(sb));
  2914. indexh = group & ((EXT4_DESC_PER_BLOCK(sb)) - 1);
  2915. grp_info = sbi_array_rcu_deref(EXT4_SB(sb), s_group_info, indexv);
  2916. return grp_info[indexh];
  2917. }
  2918. /*
  2919. * Reading s_groups_count requires using smp_rmb() afterwards. See
  2920. * the locking protocol documented in the comments of ext4_group_add()
  2921. * in resize.c
  2922. */
  2923. static inline ext4_group_t ext4_get_groups_count(struct super_block *sb)
  2924. {
  2925. ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
  2926. smp_rmb();
  2927. return ngroups;
  2928. }
  2929. static inline ext4_group_t ext4_flex_group(struct ext4_sb_info *sbi,
  2930. ext4_group_t block_group)
  2931. {
  2932. return block_group >> sbi->s_log_groups_per_flex;
  2933. }
  2934. static inline unsigned int ext4_flex_bg_size(struct ext4_sb_info *sbi)
  2935. {
  2936. return 1 << sbi->s_log_groups_per_flex;
  2937. }
  2938. #define ext4_std_error(sb, errno) \
  2939. do { \
  2940. if ((errno)) \
  2941. __ext4_std_error((sb), __func__, __LINE__, (errno)); \
  2942. } while (0)
  2943. #ifdef CONFIG_SMP
  2944. /* Each CPU can accumulate percpu_counter_batch clusters in their local
  2945. * counters. So we need to make sure we have free clusters more
  2946. * than percpu_counter_batch * nr_cpu_ids. Also add a window of 4 times.
  2947. */
  2948. #define EXT4_FREECLUSTERS_WATERMARK (4 * (percpu_counter_batch * nr_cpu_ids))
  2949. #else
  2950. #define EXT4_FREECLUSTERS_WATERMARK 0
  2951. #endif
  2952. /* Update i_disksize. Requires i_mutex to avoid races with truncate */
  2953. static inline void ext4_update_i_disksize(struct inode *inode, loff_t newsize)
  2954. {
  2955. WARN_ON_ONCE(S_ISREG(inode->i_mode) &&
  2956. !inode_is_locked(inode));
  2957. down_write(&EXT4_I(inode)->i_data_sem);
  2958. if (newsize > EXT4_I(inode)->i_disksize)
  2959. WRITE_ONCE(EXT4_I(inode)->i_disksize, newsize);
  2960. up_write(&EXT4_I(inode)->i_data_sem);
  2961. }
  2962. /* Update i_size, i_disksize. Requires i_mutex to avoid races with truncate */
  2963. static inline int ext4_update_inode_size(struct inode *inode, loff_t newsize)
  2964. {
  2965. int changed = 0;
  2966. if (newsize > inode->i_size) {
  2967. i_size_write(inode, newsize);
  2968. changed = 1;
  2969. }
  2970. if (newsize > EXT4_I(inode)->i_disksize) {
  2971. ext4_update_i_disksize(inode, newsize);
  2972. changed |= 2;
  2973. }
  2974. return changed;
  2975. }
  2976. int ext4_update_disksize_before_punch(struct inode *inode, loff_t offset,
  2977. loff_t len);
  2978. struct ext4_group_info {
  2979. unsigned long bb_state;
  2980. #ifdef AGGRESSIVE_CHECK
  2981. unsigned long bb_check_counter;
  2982. #endif
  2983. struct rb_root bb_free_root;
  2984. ext4_grpblk_t bb_first_free; /* first free block */
  2985. ext4_grpblk_t bb_free; /* total free blocks */
  2986. ext4_grpblk_t bb_fragments; /* nr of freespace fragments */
  2987. ext4_grpblk_t bb_largest_free_order;/* order of largest frag in BG */
  2988. struct list_head bb_prealloc_list;
  2989. #ifdef DOUBLE_CHECK
  2990. void *bb_bitmap;
  2991. #endif
  2992. struct rw_semaphore alloc_sem;
  2993. ext4_grpblk_t bb_counters[]; /* Nr of free power-of-two-block
  2994. * regions, index is order.
  2995. * bb_counters[3] = 5 means
  2996. * 5 free 8-block regions. */
  2997. };
  2998. #define EXT4_GROUP_INFO_NEED_INIT_BIT 0
  2999. #define EXT4_GROUP_INFO_WAS_TRIMMED_BIT 1
  3000. #define EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT 2
  3001. #define EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT 3
  3002. #define EXT4_GROUP_INFO_BBITMAP_CORRUPT \
  3003. (1 << EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT)
  3004. #define EXT4_GROUP_INFO_IBITMAP_CORRUPT \
  3005. (1 << EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT)
  3006. #define EXT4_GROUP_INFO_BBITMAP_READ_BIT 4
  3007. #define EXT4_MB_GRP_NEED_INIT(grp) \
  3008. (test_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &((grp)->bb_state)))
  3009. #define EXT4_MB_GRP_BBITMAP_CORRUPT(grp) \
  3010. (test_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &((grp)->bb_state)))
  3011. #define EXT4_MB_GRP_IBITMAP_CORRUPT(grp) \
  3012. (test_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &((grp)->bb_state)))
  3013. #define EXT4_MB_GRP_WAS_TRIMMED(grp) \
  3014. (test_bit(EXT4_GROUP_INFO_WAS_TRIMMED_BIT, &((grp)->bb_state)))
  3015. #define EXT4_MB_GRP_SET_TRIMMED(grp) \
  3016. (set_bit(EXT4_GROUP_INFO_WAS_TRIMMED_BIT, &((grp)->bb_state)))
  3017. #define EXT4_MB_GRP_CLEAR_TRIMMED(grp) \
  3018. (clear_bit(EXT4_GROUP_INFO_WAS_TRIMMED_BIT, &((grp)->bb_state)))
  3019. #define EXT4_MB_GRP_TEST_AND_SET_READ(grp) \
  3020. (test_and_set_bit(EXT4_GROUP_INFO_BBITMAP_READ_BIT, &((grp)->bb_state)))
  3021. #define EXT4_MAX_CONTENTION 8
  3022. #define EXT4_CONTENTION_THRESHOLD 2
  3023. static inline spinlock_t *ext4_group_lock_ptr(struct super_block *sb,
  3024. ext4_group_t group)
  3025. {
  3026. return bgl_lock_ptr(EXT4_SB(sb)->s_blockgroup_lock, group);
  3027. }
  3028. /*
  3029. * Returns true if the filesystem is busy enough that attempts to
  3030. * access the block group locks has run into contention.
  3031. */
  3032. static inline int ext4_fs_is_busy(struct ext4_sb_info *sbi)
  3033. {
  3034. return (atomic_read(&sbi->s_lock_busy) > EXT4_CONTENTION_THRESHOLD);
  3035. }
  3036. static inline void ext4_lock_group(struct super_block *sb, ext4_group_t group)
  3037. {
  3038. spinlock_t *lock = ext4_group_lock_ptr(sb, group);
  3039. if (spin_trylock(lock))
  3040. /*
  3041. * We're able to grab the lock right away, so drop the
  3042. * lock contention counter.
  3043. */
  3044. atomic_add_unless(&EXT4_SB(sb)->s_lock_busy, -1, 0);
  3045. else {
  3046. /*
  3047. * The lock is busy, so bump the contention counter,
  3048. * and then wait on the spin lock.
  3049. */
  3050. atomic_add_unless(&EXT4_SB(sb)->s_lock_busy, 1,
  3051. EXT4_MAX_CONTENTION);
  3052. spin_lock(lock);
  3053. }
  3054. }
  3055. static inline void ext4_unlock_group(struct super_block *sb,
  3056. ext4_group_t group)
  3057. {
  3058. spin_unlock(ext4_group_lock_ptr(sb, group));
  3059. }
  3060. /*
  3061. * Block validity checking
  3062. */
  3063. #define ext4_check_indirect_blockref(inode, bh) \
  3064. ext4_check_blockref(__func__, __LINE__, inode, \
  3065. (__le32 *)(bh)->b_data, \
  3066. EXT4_ADDR_PER_BLOCK((inode)->i_sb))
  3067. #define ext4_ind_check_inode(inode) \
  3068. ext4_check_blockref(__func__, __LINE__, inode, \
  3069. EXT4_I(inode)->i_data, \
  3070. EXT4_NDIR_BLOCKS)
  3071. /*
  3072. * Inodes and files operations
  3073. */
  3074. /* dir.c */
  3075. extern const struct file_operations ext4_dir_operations;
  3076. /* file.c */
  3077. extern const struct inode_operations ext4_file_inode_operations;
  3078. extern const struct file_operations ext4_file_operations;
  3079. extern loff_t ext4_llseek(struct file *file, loff_t offset, int origin);
  3080. /* inline.c */
  3081. extern int ext4_get_max_inline_size(struct inode *inode);
  3082. extern int ext4_find_inline_data_nolock(struct inode *inode);
  3083. extern int ext4_init_inline_data(handle_t *handle, struct inode *inode,
  3084. unsigned int len);
  3085. extern int ext4_destroy_inline_data(handle_t *handle, struct inode *inode);
  3086. extern int ext4_readpage_inline(struct inode *inode, struct page *page);
  3087. extern int ext4_try_to_write_inline_data(struct address_space *mapping,
  3088. struct inode *inode,
  3089. loff_t pos, unsigned len,
  3090. unsigned flags,
  3091. struct page **pagep);
  3092. extern int ext4_write_inline_data_end(struct inode *inode,
  3093. loff_t pos, unsigned len,
  3094. unsigned copied,
  3095. struct page *page);
  3096. extern struct buffer_head *
  3097. ext4_journalled_write_inline_data(struct inode *inode,
  3098. unsigned len,
  3099. struct page *page);
  3100. extern int ext4_da_write_inline_data_begin(struct address_space *mapping,
  3101. struct inode *inode,
  3102. loff_t pos, unsigned len,
  3103. unsigned flags,
  3104. struct page **pagep,
  3105. void **fsdata);
  3106. extern int ext4_da_write_inline_data_end(struct inode *inode, loff_t pos,
  3107. unsigned len, unsigned copied,
  3108. struct page *page);
  3109. extern int ext4_try_add_inline_entry(handle_t *handle,
  3110. struct ext4_filename *fname,
  3111. struct inode *dir, struct inode *inode);
  3112. extern int ext4_try_create_inline_dir(handle_t *handle,
  3113. struct inode *parent,
  3114. struct inode *inode);
  3115. extern int ext4_read_inline_dir(struct file *filp,
  3116. struct dir_context *ctx,
  3117. int *has_inline_data);
  3118. extern int ext4_inlinedir_to_tree(struct file *dir_file,
  3119. struct inode *dir, ext4_lblk_t block,
  3120. struct dx_hash_info *hinfo,
  3121. __u32 start_hash, __u32 start_minor_hash,
  3122. int *has_inline_data);
  3123. extern struct buffer_head *ext4_find_inline_entry(struct inode *dir,
  3124. struct ext4_filename *fname,
  3125. struct ext4_dir_entry_2 **res_dir,
  3126. int *has_inline_data);
  3127. extern int ext4_delete_inline_entry(handle_t *handle,
  3128. struct inode *dir,
  3129. struct ext4_dir_entry_2 *de_del,
  3130. struct buffer_head *bh,
  3131. int *has_inline_data);
  3132. extern bool empty_inline_dir(struct inode *dir, int *has_inline_data);
  3133. extern struct buffer_head *ext4_get_first_inline_block(struct inode *inode,
  3134. struct ext4_dir_entry_2 **parent_de,
  3135. int *retval);
  3136. extern int ext4_inline_data_fiemap(struct inode *inode,
  3137. struct fiemap_extent_info *fieinfo,
  3138. int *has_inline, __u64 start, __u64 len);
  3139. struct iomap;
  3140. extern int ext4_inline_data_iomap(struct inode *inode, struct iomap *iomap);
  3141. extern int ext4_inline_data_truncate(struct inode *inode, int *has_inline);
  3142. extern int ext4_convert_inline_data(struct inode *inode);
  3143. static inline int ext4_has_inline_data(struct inode *inode)
  3144. {
  3145. return ext4_test_inode_flag(inode, EXT4_INODE_INLINE_DATA) &&
  3146. EXT4_I(inode)->i_inline_off;
  3147. }
  3148. /* namei.c */
  3149. extern const struct inode_operations ext4_dir_inode_operations;
  3150. extern const struct inode_operations ext4_special_inode_operations;
  3151. extern struct dentry *ext4_get_parent(struct dentry *child);
  3152. extern struct ext4_dir_entry_2 *ext4_init_dot_dotdot(struct inode *inode,
  3153. struct ext4_dir_entry_2 *de,
  3154. int blocksize, int csum_size,
  3155. unsigned int parent_ino, int dotdot_real_len);
  3156. extern void ext4_initialize_dirent_tail(struct buffer_head *bh,
  3157. unsigned int blocksize);
  3158. extern int ext4_handle_dirty_dirblock(handle_t *handle, struct inode *inode,
  3159. struct buffer_head *bh);
  3160. extern int __ext4_unlink(handle_t *handle, struct inode *dir, const struct qstr *d_name,
  3161. struct inode *inode);
  3162. extern int __ext4_link(struct inode *dir, struct inode *inode,
  3163. struct dentry *dentry);
  3164. #define S_SHIFT 12
  3165. static const unsigned char ext4_type_by_mode[(S_IFMT >> S_SHIFT) + 1] = {
  3166. [S_IFREG >> S_SHIFT] = EXT4_FT_REG_FILE,
  3167. [S_IFDIR >> S_SHIFT] = EXT4_FT_DIR,
  3168. [S_IFCHR >> S_SHIFT] = EXT4_FT_CHRDEV,
  3169. [S_IFBLK >> S_SHIFT] = EXT4_FT_BLKDEV,
  3170. [S_IFIFO >> S_SHIFT] = EXT4_FT_FIFO,
  3171. [S_IFSOCK >> S_SHIFT] = EXT4_FT_SOCK,
  3172. [S_IFLNK >> S_SHIFT] = EXT4_FT_SYMLINK,
  3173. };
  3174. static inline void ext4_set_de_type(struct super_block *sb,
  3175. struct ext4_dir_entry_2 *de,
  3176. umode_t mode) {
  3177. if (ext4_has_feature_filetype(sb))
  3178. de->file_type = ext4_type_by_mode[(mode & S_IFMT)>>S_SHIFT];
  3179. }
  3180. /* readpages.c */
  3181. extern int ext4_mpage_readpages(struct inode *inode,
  3182. struct readahead_control *rac, struct page *page);
  3183. extern int __init ext4_init_post_read_processing(void);
  3184. extern void ext4_exit_post_read_processing(void);
  3185. /* symlink.c */
  3186. extern const struct inode_operations ext4_encrypted_symlink_inode_operations;
  3187. extern const struct inode_operations ext4_symlink_inode_operations;
  3188. extern const struct inode_operations ext4_fast_symlink_inode_operations;
  3189. /* sysfs.c */
  3190. extern int ext4_register_sysfs(struct super_block *sb);
  3191. extern void ext4_unregister_sysfs(struct super_block *sb);
  3192. extern int __init ext4_init_sysfs(void);
  3193. extern void ext4_exit_sysfs(void);
  3194. /* block_validity */
  3195. extern void ext4_release_system_zone(struct super_block *sb);
  3196. extern int ext4_setup_system_zone(struct super_block *sb);
  3197. extern int __init ext4_init_system_zone(void);
  3198. extern void ext4_exit_system_zone(void);
  3199. extern int ext4_inode_block_valid(struct inode *inode,
  3200. ext4_fsblk_t start_blk,
  3201. unsigned int count);
  3202. extern int ext4_check_blockref(const char *, unsigned int,
  3203. struct inode *, __le32 *, unsigned int);
  3204. /* extents.c */
  3205. struct ext4_ext_path;
  3206. struct ext4_extent;
  3207. /*
  3208. * Maximum number of logical blocks in a file; ext4_extent's ee_block is
  3209. * __le32.
  3210. */
  3211. #define EXT_MAX_BLOCKS 0xffffffff
  3212. extern void ext4_ext_tree_init(handle_t *handle, struct inode *inode);
  3213. extern int ext4_ext_index_trans_blocks(struct inode *inode, int extents);
  3214. extern int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
  3215. struct ext4_map_blocks *map, int flags);
  3216. extern int ext4_ext_truncate(handle_t *, struct inode *);
  3217. extern int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start,
  3218. ext4_lblk_t end);
  3219. extern void ext4_ext_init(struct super_block *);
  3220. extern void ext4_ext_release(struct super_block *);
  3221. extern long ext4_fallocate(struct file *file, int mode, loff_t offset,
  3222. loff_t len);
  3223. extern int ext4_convert_unwritten_extents(handle_t *handle, struct inode *inode,
  3224. loff_t offset, ssize_t len);
  3225. extern int ext4_convert_unwritten_io_end_vec(handle_t *handle,
  3226. ext4_io_end_t *io_end);
  3227. extern int ext4_map_blocks(handle_t *handle, struct inode *inode,
  3228. struct ext4_map_blocks *map, int flags);
  3229. extern int ext4_ext_calc_credits_for_single_extent(struct inode *inode,
  3230. int num,
  3231. struct ext4_ext_path *path);
  3232. extern int ext4_ext_insert_extent(handle_t *, struct inode *,
  3233. struct ext4_ext_path **,
  3234. struct ext4_extent *, int);
  3235. extern struct ext4_ext_path *ext4_find_extent(struct inode *, ext4_lblk_t,
  3236. struct ext4_ext_path **,
  3237. int flags);
  3238. extern void ext4_ext_drop_refs(struct ext4_ext_path *);
  3239. extern int ext4_ext_check_inode(struct inode *inode);
  3240. extern ext4_lblk_t ext4_ext_next_allocated_block(struct ext4_ext_path *path);
  3241. extern int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
  3242. __u64 start, __u64 len);
  3243. extern int ext4_get_es_cache(struct inode *inode,
  3244. struct fiemap_extent_info *fieinfo,
  3245. __u64 start, __u64 len);
  3246. extern int ext4_ext_precache(struct inode *inode);
  3247. extern int ext4_swap_extents(handle_t *handle, struct inode *inode1,
  3248. struct inode *inode2, ext4_lblk_t lblk1,
  3249. ext4_lblk_t lblk2, ext4_lblk_t count,
  3250. int mark_unwritten,int *err);
  3251. extern int ext4_clu_mapped(struct inode *inode, ext4_lblk_t lclu);
  3252. extern int ext4_datasem_ensure_credits(handle_t *handle, struct inode *inode,
  3253. int check_cred, int restart_cred,
  3254. int revoke_cred);
  3255. extern void ext4_ext_replay_shrink_inode(struct inode *inode, ext4_lblk_t end);
  3256. extern int ext4_ext_replay_set_iblocks(struct inode *inode);
  3257. extern int ext4_ext_replay_update_ex(struct inode *inode, ext4_lblk_t start,
  3258. int len, int unwritten, ext4_fsblk_t pblk);
  3259. extern int ext4_ext_clear_bb(struct inode *inode);
  3260. /* move_extent.c */
  3261. extern void ext4_double_down_write_data_sem(struct inode *first,
  3262. struct inode *second);
  3263. extern void ext4_double_up_write_data_sem(struct inode *orig_inode,
  3264. struct inode *donor_inode);
  3265. extern int ext4_move_extents(struct file *o_filp, struct file *d_filp,
  3266. __u64 start_orig, __u64 start_donor,
  3267. __u64 len, __u64 *moved_len);
  3268. /* page-io.c */
  3269. extern int __init ext4_init_pageio(void);
  3270. extern void ext4_exit_pageio(void);
  3271. extern ext4_io_end_t *ext4_init_io_end(struct inode *inode, gfp_t flags);
  3272. extern ext4_io_end_t *ext4_get_io_end(ext4_io_end_t *io_end);
  3273. extern int ext4_put_io_end(ext4_io_end_t *io_end);
  3274. extern void ext4_put_io_end_defer(ext4_io_end_t *io_end);
  3275. extern void ext4_io_submit_init(struct ext4_io_submit *io,
  3276. struct writeback_control *wbc);
  3277. extern void ext4_end_io_rsv_work(struct work_struct *work);
  3278. extern void ext4_io_submit(struct ext4_io_submit *io);
  3279. extern int ext4_bio_write_page(struct ext4_io_submit *io,
  3280. struct page *page,
  3281. int len,
  3282. struct writeback_control *wbc,
  3283. bool keep_towrite);
  3284. extern struct ext4_io_end_vec *ext4_alloc_io_end_vec(ext4_io_end_t *io_end);
  3285. extern struct ext4_io_end_vec *ext4_last_io_end_vec(ext4_io_end_t *io_end);
  3286. /* mmp.c */
  3287. extern int ext4_multi_mount_protect(struct super_block *, ext4_fsblk_t);
  3288. /* mmp.c */
  3289. extern void ext4_stop_mmpd(struct ext4_sb_info *sbi);
  3290. /* verity.c */
  3291. extern const struct fsverity_operations ext4_verityops;
  3292. /*
  3293. * Add new method to test whether block and inode bitmaps are properly
  3294. * initialized. With uninit_bg reading the block from disk is not enough
  3295. * to mark the bitmap uptodate. We need to also zero-out the bitmap
  3296. */
  3297. #define BH_BITMAP_UPTODATE BH_JBDPrivateStart
  3298. static inline int bitmap_uptodate(struct buffer_head *bh)
  3299. {
  3300. return (buffer_uptodate(bh) &&
  3301. test_bit(BH_BITMAP_UPTODATE, &(bh)->b_state));
  3302. }
  3303. static inline void set_bitmap_uptodate(struct buffer_head *bh)
  3304. {
  3305. set_bit(BH_BITMAP_UPTODATE, &(bh)->b_state);
  3306. }
  3307. #define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1)
  3308. /* For ioend & aio unwritten conversion wait queues */
  3309. #define EXT4_WQ_HASH_SZ 37
  3310. #define ext4_ioend_wq(v) (&ext4__ioend_wq[((unsigned long)(v)) %\
  3311. EXT4_WQ_HASH_SZ])
  3312. extern wait_queue_head_t ext4__ioend_wq[EXT4_WQ_HASH_SZ];
  3313. extern int ext4_resize_begin(struct super_block *sb);
  3314. extern void ext4_resize_end(struct super_block *sb);
  3315. static inline void ext4_set_io_unwritten_flag(struct inode *inode,
  3316. struct ext4_io_end *io_end)
  3317. {
  3318. if (!(io_end->flag & EXT4_IO_END_UNWRITTEN)) {
  3319. io_end->flag |= EXT4_IO_END_UNWRITTEN;
  3320. atomic_inc(&EXT4_I(inode)->i_unwritten);
  3321. }
  3322. }
  3323. static inline void ext4_clear_io_unwritten_flag(ext4_io_end_t *io_end)
  3324. {
  3325. struct inode *inode = io_end->inode;
  3326. if (io_end->flag & EXT4_IO_END_UNWRITTEN) {
  3327. io_end->flag &= ~EXT4_IO_END_UNWRITTEN;
  3328. /* Wake up anyone waiting on unwritten extent conversion */
  3329. if (atomic_dec_and_test(&EXT4_I(inode)->i_unwritten))
  3330. wake_up_all(ext4_ioend_wq(inode));
  3331. }
  3332. }
  3333. extern const struct iomap_ops ext4_iomap_ops;
  3334. extern const struct iomap_ops ext4_iomap_overwrite_ops;
  3335. extern const struct iomap_ops ext4_iomap_report_ops;
  3336. static inline int ext4_buffer_uptodate(struct buffer_head *bh)
  3337. {
  3338. /*
  3339. * If the buffer has the write error flag, we have failed
  3340. * to write out data in the block. In this case, we don't
  3341. * have to read the block because we may read the old data
  3342. * successfully.
  3343. */
  3344. if (!buffer_uptodate(bh) && buffer_write_io_error(bh))
  3345. set_buffer_uptodate(bh);
  3346. return buffer_uptodate(bh);
  3347. }
  3348. #endif /* __KERNEL__ */
  3349. #define EFSBADCRC EBADMSG /* Bad CRC detected */
  3350. #define EFSCORRUPTED EUCLEAN /* Filesystem is corrupted */
  3351. #endif /* _EXT4_H */