reiserfs.h 117 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413
  1. /* SPDX-License-Identifier: GPL-2.0 */
  2. /*
  3. * Copyright 1996, 1997, 1998 Hans Reiser, see reiserfs/README for
  4. * licensing and copyright details
  5. */
  6. #include <linux/reiserfs_fs.h>
  7. #include <linux/slab.h>
  8. #include <linux/interrupt.h>
  9. #include <linux/sched.h>
  10. #include <linux/bug.h>
  11. #include <linux/workqueue.h>
  12. #include <asm/unaligned.h>
  13. #include <linux/bitops.h>
  14. #include <linux/proc_fs.h>
  15. #include <linux/buffer_head.h>
  16. /* the 32 bit compat definitions with int argument */
  17. #define REISERFS_IOC32_UNPACK _IOW(0xCD, 1, int)
  18. #define REISERFS_IOC32_GETFLAGS FS_IOC32_GETFLAGS
  19. #define REISERFS_IOC32_SETFLAGS FS_IOC32_SETFLAGS
  20. #define REISERFS_IOC32_GETVERSION FS_IOC32_GETVERSION
  21. #define REISERFS_IOC32_SETVERSION FS_IOC32_SETVERSION
  22. struct reiserfs_journal_list;
  23. /* bitmasks for i_flags field in reiserfs-specific part of inode */
  24. typedef enum {
  25. /*
  26. * this says what format of key do all items (but stat data) of
  27. * an object have. If this is set, that format is 3.6 otherwise - 3.5
  28. */
  29. i_item_key_version_mask = 0x0001,
  30. /*
  31. * If this is unset, object has 3.5 stat data, otherwise,
  32. * it has 3.6 stat data with 64bit size, 32bit nlink etc.
  33. */
  34. i_stat_data_version_mask = 0x0002,
  35. /* file might need tail packing on close */
  36. i_pack_on_close_mask = 0x0004,
  37. /* don't pack tail of file */
  38. i_nopack_mask = 0x0008,
  39. /*
  40. * If either of these are set, "safe link" was created for this
  41. * file during truncate or unlink. Safe link is used to avoid
  42. * leakage of disk space on crash with some files open, but unlinked.
  43. */
  44. i_link_saved_unlink_mask = 0x0010,
  45. i_link_saved_truncate_mask = 0x0020,
  46. i_has_xattr_dir = 0x0040,
  47. i_data_log = 0x0080,
  48. } reiserfs_inode_flags;
  49. struct reiserfs_inode_info {
  50. __u32 i_key[4]; /* key is still 4 32 bit integers */
  51. /*
  52. * transient inode flags that are never stored on disk. Bitmasks
  53. * for this field are defined above.
  54. */
  55. __u32 i_flags;
  56. /* offset of first byte stored in direct item. */
  57. __u32 i_first_direct_byte;
  58. /* copy of persistent inode flags read from sd_attrs. */
  59. __u32 i_attrs;
  60. /* first unused block of a sequence of unused blocks */
  61. int i_prealloc_block;
  62. int i_prealloc_count; /* length of that sequence */
  63. /* per-transaction list of inodes which have preallocated blocks */
  64. struct list_head i_prealloc_list;
  65. /*
  66. * new_packing_locality is created; new blocks for the contents
  67. * of this directory should be displaced
  68. */
  69. unsigned new_packing_locality:1;
  70. /*
  71. * we use these for fsync or O_SYNC to decide which transaction
  72. * needs to be committed in order for this inode to be properly
  73. * flushed
  74. */
  75. unsigned int i_trans_id;
  76. struct reiserfs_journal_list *i_jl;
  77. atomic_t openers;
  78. struct mutex tailpack;
  79. #ifdef CONFIG_REISERFS_FS_XATTR
  80. struct rw_semaphore i_xattr_sem;
  81. #endif
  82. #ifdef CONFIG_QUOTA
  83. struct dquot *i_dquot[MAXQUOTAS];
  84. #endif
  85. struct inode vfs_inode;
  86. };
  87. typedef enum {
  88. reiserfs_attrs_cleared = 0x00000001,
  89. } reiserfs_super_block_flags;
  90. /*
  91. * struct reiserfs_super_block accessors/mutators since this is a disk
  92. * structure, it will always be in little endian format.
  93. */
  94. #define sb_block_count(sbp) (le32_to_cpu((sbp)->s_v1.s_block_count))
  95. #define set_sb_block_count(sbp,v) ((sbp)->s_v1.s_block_count = cpu_to_le32(v))
  96. #define sb_free_blocks(sbp) (le32_to_cpu((sbp)->s_v1.s_free_blocks))
  97. #define set_sb_free_blocks(sbp,v) ((sbp)->s_v1.s_free_blocks = cpu_to_le32(v))
  98. #define sb_root_block(sbp) (le32_to_cpu((sbp)->s_v1.s_root_block))
  99. #define set_sb_root_block(sbp,v) ((sbp)->s_v1.s_root_block = cpu_to_le32(v))
  100. #define sb_jp_journal_1st_block(sbp) \
  101. (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_1st_block))
  102. #define set_sb_jp_journal_1st_block(sbp,v) \
  103. ((sbp)->s_v1.s_journal.jp_journal_1st_block = cpu_to_le32(v))
  104. #define sb_jp_journal_dev(sbp) \
  105. (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_dev))
  106. #define set_sb_jp_journal_dev(sbp,v) \
  107. ((sbp)->s_v1.s_journal.jp_journal_dev = cpu_to_le32(v))
  108. #define sb_jp_journal_size(sbp) \
  109. (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_size))
  110. #define set_sb_jp_journal_size(sbp,v) \
  111. ((sbp)->s_v1.s_journal.jp_journal_size = cpu_to_le32(v))
  112. #define sb_jp_journal_trans_max(sbp) \
  113. (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_trans_max))
  114. #define set_sb_jp_journal_trans_max(sbp,v) \
  115. ((sbp)->s_v1.s_journal.jp_journal_trans_max = cpu_to_le32(v))
  116. #define sb_jp_journal_magic(sbp) \
  117. (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_magic))
  118. #define set_sb_jp_journal_magic(sbp,v) \
  119. ((sbp)->s_v1.s_journal.jp_journal_magic = cpu_to_le32(v))
  120. #define sb_jp_journal_max_batch(sbp) \
  121. (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_max_batch))
  122. #define set_sb_jp_journal_max_batch(sbp,v) \
  123. ((sbp)->s_v1.s_journal.jp_journal_max_batch = cpu_to_le32(v))
  124. #define sb_jp_jourmal_max_commit_age(sbp) \
  125. (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_max_commit_age))
  126. #define set_sb_jp_journal_max_commit_age(sbp,v) \
  127. ((sbp)->s_v1.s_journal.jp_journal_max_commit_age = cpu_to_le32(v))
  128. #define sb_blocksize(sbp) (le16_to_cpu((sbp)->s_v1.s_blocksize))
  129. #define set_sb_blocksize(sbp,v) ((sbp)->s_v1.s_blocksize = cpu_to_le16(v))
  130. #define sb_oid_maxsize(sbp) (le16_to_cpu((sbp)->s_v1.s_oid_maxsize))
  131. #define set_sb_oid_maxsize(sbp,v) ((sbp)->s_v1.s_oid_maxsize = cpu_to_le16(v))
  132. #define sb_oid_cursize(sbp) (le16_to_cpu((sbp)->s_v1.s_oid_cursize))
  133. #define set_sb_oid_cursize(sbp,v) ((sbp)->s_v1.s_oid_cursize = cpu_to_le16(v))
  134. #define sb_umount_state(sbp) (le16_to_cpu((sbp)->s_v1.s_umount_state))
  135. #define set_sb_umount_state(sbp,v) ((sbp)->s_v1.s_umount_state = cpu_to_le16(v))
  136. #define sb_fs_state(sbp) (le16_to_cpu((sbp)->s_v1.s_fs_state))
  137. #define set_sb_fs_state(sbp,v) ((sbp)->s_v1.s_fs_state = cpu_to_le16(v))
  138. #define sb_hash_function_code(sbp) \
  139. (le32_to_cpu((sbp)->s_v1.s_hash_function_code))
  140. #define set_sb_hash_function_code(sbp,v) \
  141. ((sbp)->s_v1.s_hash_function_code = cpu_to_le32(v))
  142. #define sb_tree_height(sbp) (le16_to_cpu((sbp)->s_v1.s_tree_height))
  143. #define set_sb_tree_height(sbp,v) ((sbp)->s_v1.s_tree_height = cpu_to_le16(v))
  144. #define sb_bmap_nr(sbp) (le16_to_cpu((sbp)->s_v1.s_bmap_nr))
  145. #define set_sb_bmap_nr(sbp,v) ((sbp)->s_v1.s_bmap_nr = cpu_to_le16(v))
  146. #define sb_version(sbp) (le16_to_cpu((sbp)->s_v1.s_version))
  147. #define set_sb_version(sbp,v) ((sbp)->s_v1.s_version = cpu_to_le16(v))
  148. #define sb_mnt_count(sbp) (le16_to_cpu((sbp)->s_mnt_count))
  149. #define set_sb_mnt_count(sbp, v) ((sbp)->s_mnt_count = cpu_to_le16(v))
  150. #define sb_reserved_for_journal(sbp) \
  151. (le16_to_cpu((sbp)->s_v1.s_reserved_for_journal))
  152. #define set_sb_reserved_for_journal(sbp,v) \
  153. ((sbp)->s_v1.s_reserved_for_journal = cpu_to_le16(v))
  154. /* LOGGING -- */
  155. /*
  156. * These all interelate for performance.
  157. *
  158. * If the journal block count is smaller than n transactions, you lose speed.
  159. * I don't know what n is yet, I'm guessing 8-16.
  160. *
  161. * typical transaction size depends on the application, how often fsync is
  162. * called, and how many metadata blocks you dirty in a 30 second period.
  163. * The more small files (<16k) you use, the larger your transactions will
  164. * be.
  165. *
  166. * If your journal fills faster than dirty buffers get flushed to disk, it
  167. * must flush them before allowing the journal to wrap, which slows things
  168. * down. If you need high speed meta data updates, the journal should be
  169. * big enough to prevent wrapping before dirty meta blocks get to disk.
  170. *
  171. * If the batch max is smaller than the transaction max, you'll waste space
  172. * at the end of the journal because journal_end sets the next transaction
  173. * to start at 0 if the next transaction has any chance of wrapping.
  174. *
  175. * The large the batch max age, the better the speed, and the more meta
  176. * data changes you'll lose after a crash.
  177. */
  178. /* don't mess with these for a while */
  179. /* we have a node size define somewhere in reiserfs_fs.h. -Hans */
  180. #define JOURNAL_BLOCK_SIZE 4096 /* BUG gotta get rid of this */
  181. #define JOURNAL_MAX_CNODE 1500 /* max cnodes to allocate. */
  182. #define JOURNAL_HASH_SIZE 8192
  183. /* number of copies of the bitmaps to have floating. Must be >= 2 */
  184. #define JOURNAL_NUM_BITMAPS 5
  185. /*
  186. * One of these for every block in every transaction
  187. * Each one is in two hash tables. First, a hash of the current transaction,
  188. * and after journal_end, a hash of all the in memory transactions.
  189. * next and prev are used by the current transaction (journal_hash).
  190. * hnext and hprev are used by journal_list_hash. If a block is in more
  191. * than one transaction, the journal_list_hash links it in multiple times.
  192. * This allows flush_journal_list to remove just the cnode belonging to a
  193. * given transaction.
  194. */
  195. struct reiserfs_journal_cnode {
  196. struct buffer_head *bh; /* real buffer head */
  197. struct super_block *sb; /* dev of real buffer head */
  198. /* block number of real buffer head, == 0 when buffer on disk */
  199. __u32 blocknr;
  200. unsigned long state;
  201. /* journal list this cnode lives in */
  202. struct reiserfs_journal_list *jlist;
  203. struct reiserfs_journal_cnode *next; /* next in transaction list */
  204. struct reiserfs_journal_cnode *prev; /* prev in transaction list */
  205. struct reiserfs_journal_cnode *hprev; /* prev in hash list */
  206. struct reiserfs_journal_cnode *hnext; /* next in hash list */
  207. };
  208. struct reiserfs_bitmap_node {
  209. int id;
  210. char *data;
  211. struct list_head list;
  212. };
  213. struct reiserfs_list_bitmap {
  214. struct reiserfs_journal_list *journal_list;
  215. struct reiserfs_bitmap_node **bitmaps;
  216. };
  217. /*
  218. * one of these for each transaction. The most important part here is the
  219. * j_realblock. this list of cnodes is used to hash all the blocks in all
  220. * the commits, to mark all the real buffer heads dirty once all the commits
  221. * hit the disk, and to make sure every real block in a transaction is on
  222. * disk before allowing the log area to be overwritten
  223. */
  224. struct reiserfs_journal_list {
  225. unsigned long j_start;
  226. unsigned long j_state;
  227. unsigned long j_len;
  228. atomic_t j_nonzerolen;
  229. atomic_t j_commit_left;
  230. /* all commits older than this on disk */
  231. atomic_t j_older_commits_done;
  232. struct mutex j_commit_mutex;
  233. unsigned int j_trans_id;
  234. time64_t j_timestamp; /* write-only but useful for crash dump analysis */
  235. struct reiserfs_list_bitmap *j_list_bitmap;
  236. struct buffer_head *j_commit_bh; /* commit buffer head */
  237. struct reiserfs_journal_cnode *j_realblock;
  238. struct reiserfs_journal_cnode *j_freedlist; /* list of buffers that were freed during this trans. free each of these on flush */
  239. /* time ordered list of all active transactions */
  240. struct list_head j_list;
  241. /*
  242. * time ordered list of all transactions we haven't tried
  243. * to flush yet
  244. */
  245. struct list_head j_working_list;
  246. /* list of tail conversion targets in need of flush before commit */
  247. struct list_head j_tail_bh_list;
  248. /* list of data=ordered buffers in need of flush before commit */
  249. struct list_head j_bh_list;
  250. int j_refcount;
  251. };
  252. struct reiserfs_journal {
  253. struct buffer_head **j_ap_blocks; /* journal blocks on disk */
  254. /* newest journal block */
  255. struct reiserfs_journal_cnode *j_last;
  256. /* oldest journal block. start here for traverse */
  257. struct reiserfs_journal_cnode *j_first;
  258. struct block_device *j_dev_bd;
  259. fmode_t j_dev_mode;
  260. /* first block on s_dev of reserved area journal */
  261. int j_1st_reserved_block;
  262. unsigned long j_state;
  263. unsigned int j_trans_id;
  264. unsigned long j_mount_id;
  265. /* start of current waiting commit (index into j_ap_blocks) */
  266. unsigned long j_start;
  267. unsigned long j_len; /* length of current waiting commit */
  268. /* number of buffers requested by journal_begin() */
  269. unsigned long j_len_alloc;
  270. atomic_t j_wcount; /* count of writers for current commit */
  271. /* batch count. allows turning X transactions into 1 */
  272. unsigned long j_bcount;
  273. /* first unflushed transactions offset */
  274. unsigned long j_first_unflushed_offset;
  275. /* last fully flushed journal timestamp */
  276. unsigned j_last_flush_trans_id;
  277. struct buffer_head *j_header_bh;
  278. time64_t j_trans_start_time; /* time this transaction started */
  279. struct mutex j_mutex;
  280. struct mutex j_flush_mutex;
  281. /* wait for current transaction to finish before starting new one */
  282. wait_queue_head_t j_join_wait;
  283. atomic_t j_jlock; /* lock for j_join_wait */
  284. int j_list_bitmap_index; /* number of next list bitmap to use */
  285. /* no more journal begins allowed. MUST sleep on j_join_wait */
  286. int j_must_wait;
  287. /* next journal_end will flush all journal list */
  288. int j_next_full_flush;
  289. /* next journal_end will flush all async commits */
  290. int j_next_async_flush;
  291. int j_cnode_used; /* number of cnodes on the used list */
  292. int j_cnode_free; /* number of cnodes on the free list */
  293. /* max number of blocks in a transaction. */
  294. unsigned int j_trans_max;
  295. /* max number of blocks to batch into a trans */
  296. unsigned int j_max_batch;
  297. /* in seconds, how old can an async commit be */
  298. unsigned int j_max_commit_age;
  299. /* in seconds, how old can a transaction be */
  300. unsigned int j_max_trans_age;
  301. /* the default for the max commit age */
  302. unsigned int j_default_max_commit_age;
  303. struct reiserfs_journal_cnode *j_cnode_free_list;
  304. /* orig pointer returned from vmalloc */
  305. struct reiserfs_journal_cnode *j_cnode_free_orig;
  306. struct reiserfs_journal_list *j_current_jl;
  307. int j_free_bitmap_nodes;
  308. int j_used_bitmap_nodes;
  309. int j_num_lists; /* total number of active transactions */
  310. int j_num_work_lists; /* number that need attention from kreiserfsd */
  311. /* debugging to make sure things are flushed in order */
  312. unsigned int j_last_flush_id;
  313. /* debugging to make sure things are committed in order */
  314. unsigned int j_last_commit_id;
  315. struct list_head j_bitmap_nodes;
  316. struct list_head j_dirty_buffers;
  317. spinlock_t j_dirty_buffers_lock; /* protects j_dirty_buffers */
  318. /* list of all active transactions */
  319. struct list_head j_journal_list;
  320. /* lists that haven't been touched by writeback attempts */
  321. struct list_head j_working_list;
  322. /* hash table for real buffer heads in current trans */
  323. struct reiserfs_journal_cnode *j_hash_table[JOURNAL_HASH_SIZE];
  324. /* hash table for all the real buffer heads in all the transactions */
  325. struct reiserfs_journal_cnode *j_list_hash_table[JOURNAL_HASH_SIZE];
  326. /* array of bitmaps to record the deleted blocks */
  327. struct reiserfs_list_bitmap j_list_bitmap[JOURNAL_NUM_BITMAPS];
  328. /* list of inodes which have preallocated blocks */
  329. struct list_head j_prealloc_list;
  330. int j_persistent_trans;
  331. unsigned long j_max_trans_size;
  332. unsigned long j_max_batch_size;
  333. int j_errno;
  334. /* when flushing ordered buffers, throttle new ordered writers */
  335. struct delayed_work j_work;
  336. struct super_block *j_work_sb;
  337. atomic_t j_async_throttle;
  338. };
  339. enum journal_state_bits {
  340. J_WRITERS_BLOCKED = 1, /* set when new writers not allowed */
  341. J_WRITERS_QUEUED, /* set when log is full due to too many writers */
  342. J_ABORTED, /* set when log is aborted */
  343. };
  344. /* ick. magic string to find desc blocks in the journal */
  345. #define JOURNAL_DESC_MAGIC "ReIsErLB"
  346. typedef __u32(*hashf_t) (const signed char *, int);
  347. struct reiserfs_bitmap_info {
  348. __u32 free_count;
  349. };
  350. struct proc_dir_entry;
  351. #if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO )
  352. typedef unsigned long int stat_cnt_t;
  353. typedef struct reiserfs_proc_info_data {
  354. spinlock_t lock;
  355. int exiting;
  356. int max_hash_collisions;
  357. stat_cnt_t breads;
  358. stat_cnt_t bread_miss;
  359. stat_cnt_t search_by_key;
  360. stat_cnt_t search_by_key_fs_changed;
  361. stat_cnt_t search_by_key_restarted;
  362. stat_cnt_t insert_item_restarted;
  363. stat_cnt_t paste_into_item_restarted;
  364. stat_cnt_t cut_from_item_restarted;
  365. stat_cnt_t delete_solid_item_restarted;
  366. stat_cnt_t delete_item_restarted;
  367. stat_cnt_t leaked_oid;
  368. stat_cnt_t leaves_removable;
  369. /*
  370. * balances per level.
  371. * Use explicit 5 as MAX_HEIGHT is not visible yet.
  372. */
  373. stat_cnt_t balance_at[5]; /* XXX */
  374. /* sbk == search_by_key */
  375. stat_cnt_t sbk_read_at[5]; /* XXX */
  376. stat_cnt_t sbk_fs_changed[5];
  377. stat_cnt_t sbk_restarted[5];
  378. stat_cnt_t items_at[5]; /* XXX */
  379. stat_cnt_t free_at[5]; /* XXX */
  380. stat_cnt_t can_node_be_removed[5]; /* XXX */
  381. long int lnum[5]; /* XXX */
  382. long int rnum[5]; /* XXX */
  383. long int lbytes[5]; /* XXX */
  384. long int rbytes[5]; /* XXX */
  385. stat_cnt_t get_neighbors[5];
  386. stat_cnt_t get_neighbors_restart[5];
  387. stat_cnt_t need_l_neighbor[5];
  388. stat_cnt_t need_r_neighbor[5];
  389. stat_cnt_t free_block;
  390. struct __scan_bitmap_stats {
  391. stat_cnt_t call;
  392. stat_cnt_t wait;
  393. stat_cnt_t bmap;
  394. stat_cnt_t retry;
  395. stat_cnt_t in_journal_hint;
  396. stat_cnt_t in_journal_nohint;
  397. stat_cnt_t stolen;
  398. } scan_bitmap;
  399. struct __journal_stats {
  400. stat_cnt_t in_journal;
  401. stat_cnt_t in_journal_bitmap;
  402. stat_cnt_t in_journal_reusable;
  403. stat_cnt_t lock_journal;
  404. stat_cnt_t lock_journal_wait;
  405. stat_cnt_t journal_being;
  406. stat_cnt_t journal_relock_writers;
  407. stat_cnt_t journal_relock_wcount;
  408. stat_cnt_t mark_dirty;
  409. stat_cnt_t mark_dirty_already;
  410. stat_cnt_t mark_dirty_notjournal;
  411. stat_cnt_t restore_prepared;
  412. stat_cnt_t prepare;
  413. stat_cnt_t prepare_retry;
  414. } journal;
  415. } reiserfs_proc_info_data_t;
  416. #else
  417. typedef struct reiserfs_proc_info_data {
  418. } reiserfs_proc_info_data_t;
  419. #endif
  420. /* Number of quota types we support */
  421. #define REISERFS_MAXQUOTAS 2
  422. /* reiserfs union of in-core super block data */
  423. struct reiserfs_sb_info {
  424. /* Buffer containing the super block */
  425. struct buffer_head *s_sbh;
  426. /* Pointer to the on-disk super block in the buffer */
  427. struct reiserfs_super_block *s_rs;
  428. struct reiserfs_bitmap_info *s_ap_bitmap;
  429. /* pointer to journal information */
  430. struct reiserfs_journal *s_journal;
  431. unsigned short s_mount_state; /* reiserfs state (valid, invalid) */
  432. /* Serialize writers access, replace the old bkl */
  433. struct mutex lock;
  434. /* Owner of the lock (can be recursive) */
  435. struct task_struct *lock_owner;
  436. /* Depth of the lock, start from -1 like the bkl */
  437. int lock_depth;
  438. struct workqueue_struct *commit_wq;
  439. /* Comment? -Hans */
  440. void (*end_io_handler) (struct buffer_head *, int);
  441. /*
  442. * pointer to function which is used to sort names in directory.
  443. * Set on mount
  444. */
  445. hashf_t s_hash_function;
  446. /* reiserfs's mount options are set here */
  447. unsigned long s_mount_opt;
  448. /* This is a structure that describes block allocator options */
  449. struct {
  450. /* Bitfield for enable/disable kind of options */
  451. unsigned long bits;
  452. /*
  453. * size started from which we consider file
  454. * to be a large one (in blocks)
  455. */
  456. unsigned long large_file_size;
  457. int border; /* percentage of disk, border takes */
  458. /*
  459. * Minimal file size (in blocks) starting
  460. * from which we do preallocations
  461. */
  462. int preallocmin;
  463. /*
  464. * Number of blocks we try to prealloc when file
  465. * reaches preallocmin size (in blocks) or prealloc_list
  466. is empty.
  467. */
  468. int preallocsize;
  469. } s_alloc_options;
  470. /* Comment? -Hans */
  471. wait_queue_head_t s_wait;
  472. /* increased by one every time the tree gets re-balanced */
  473. atomic_t s_generation_counter;
  474. /* File system properties. Currently holds on-disk FS format */
  475. unsigned long s_properties;
  476. /* session statistics */
  477. int s_disk_reads;
  478. int s_disk_writes;
  479. int s_fix_nodes;
  480. int s_do_balance;
  481. int s_unneeded_left_neighbor;
  482. int s_good_search_by_key_reada;
  483. int s_bmaps;
  484. int s_bmaps_without_search;
  485. int s_direct2indirect;
  486. int s_indirect2direct;
  487. /*
  488. * set up when it's ok for reiserfs_read_inode2() to read from
  489. * disk inode with nlink==0. Currently this is only used during
  490. * finish_unfinished() processing at mount time
  491. */
  492. int s_is_unlinked_ok;
  493. reiserfs_proc_info_data_t s_proc_info_data;
  494. struct proc_dir_entry *procdir;
  495. /* amount of blocks reserved for further allocations */
  496. int reserved_blocks;
  497. /* this lock on now only used to protect reserved_blocks variable */
  498. spinlock_t bitmap_lock;
  499. struct dentry *priv_root; /* root of /.reiserfs_priv */
  500. struct dentry *xattr_root; /* root of /.reiserfs_priv/xattrs */
  501. int j_errno;
  502. int work_queued; /* non-zero delayed work is queued */
  503. struct delayed_work old_work; /* old transactions flush delayed work */
  504. spinlock_t old_work_lock; /* protects old_work and work_queued */
  505. #ifdef CONFIG_QUOTA
  506. char *s_qf_names[REISERFS_MAXQUOTAS];
  507. int s_jquota_fmt;
  508. #endif
  509. char *s_jdev; /* Stored jdev for mount option showing */
  510. #ifdef CONFIG_REISERFS_CHECK
  511. /*
  512. * Detects whether more than one copy of tb exists per superblock
  513. * as a means of checking whether do_balance is executing
  514. * concurrently against another tree reader/writer on a same
  515. * mount point.
  516. */
  517. struct tree_balance *cur_tb;
  518. #endif
  519. };
  520. /* Definitions of reiserfs on-disk properties: */
  521. #define REISERFS_3_5 0
  522. #define REISERFS_3_6 1
  523. #define REISERFS_OLD_FORMAT 2
  524. /* Mount options */
  525. enum reiserfs_mount_options {
  526. /* large tails will be created in a session */
  527. REISERFS_LARGETAIL,
  528. /*
  529. * small (for files less than block size) tails will
  530. * be created in a session
  531. */
  532. REISERFS_SMALLTAIL,
  533. /* replay journal and return 0. Use by fsck */
  534. REPLAYONLY,
  535. /*
  536. * -o conv: causes conversion of old format super block to the
  537. * new format. If not specified - old partition will be dealt
  538. * with in a manner of 3.5.x
  539. */
  540. REISERFS_CONVERT,
  541. /*
  542. * -o hash={tea, rupasov, r5, detect} is meant for properly mounting
  543. * reiserfs disks from 3.5.19 or earlier. 99% of the time, this
  544. * option is not required. If the normal autodection code can't
  545. * determine which hash to use (because both hashes had the same
  546. * value for a file) use this option to force a specific hash.
  547. * It won't allow you to override the existing hash on the FS, so
  548. * if you have a tea hash disk, and mount with -o hash=rupasov,
  549. * the mount will fail.
  550. */
  551. FORCE_TEA_HASH, /* try to force tea hash on mount */
  552. FORCE_RUPASOV_HASH, /* try to force rupasov hash on mount */
  553. FORCE_R5_HASH, /* try to force rupasov hash on mount */
  554. FORCE_HASH_DETECT, /* try to detect hash function on mount */
  555. REISERFS_DATA_LOG,
  556. REISERFS_DATA_ORDERED,
  557. REISERFS_DATA_WRITEBACK,
  558. /*
  559. * used for testing experimental features, makes benchmarking new
  560. * features with and without more convenient, should never be used by
  561. * users in any code shipped to users (ideally)
  562. */
  563. REISERFS_NO_BORDER,
  564. REISERFS_NO_UNHASHED_RELOCATION,
  565. REISERFS_HASHED_RELOCATION,
  566. REISERFS_ATTRS,
  567. REISERFS_XATTRS_USER,
  568. REISERFS_POSIXACL,
  569. REISERFS_EXPOSE_PRIVROOT,
  570. REISERFS_BARRIER_NONE,
  571. REISERFS_BARRIER_FLUSH,
  572. /* Actions on error */
  573. REISERFS_ERROR_PANIC,
  574. REISERFS_ERROR_RO,
  575. REISERFS_ERROR_CONTINUE,
  576. REISERFS_USRQUOTA, /* User quota option specified */
  577. REISERFS_GRPQUOTA, /* Group quota option specified */
  578. REISERFS_TEST1,
  579. REISERFS_TEST2,
  580. REISERFS_TEST3,
  581. REISERFS_TEST4,
  582. REISERFS_UNSUPPORTED_OPT,
  583. };
  584. #define reiserfs_r5_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_R5_HASH))
  585. #define reiserfs_rupasov_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_RUPASOV_HASH))
  586. #define reiserfs_tea_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_TEA_HASH))
  587. #define reiserfs_hash_detect(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_HASH_DETECT))
  588. #define reiserfs_no_border(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_NO_BORDER))
  589. #define reiserfs_no_unhashed_relocation(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_NO_UNHASHED_RELOCATION))
  590. #define reiserfs_hashed_relocation(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_HASHED_RELOCATION))
  591. #define reiserfs_test4(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_TEST4))
  592. #define have_large_tails(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_LARGETAIL))
  593. #define have_small_tails(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_SMALLTAIL))
  594. #define replay_only(s) (REISERFS_SB(s)->s_mount_opt & (1 << REPLAYONLY))
  595. #define reiserfs_attrs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ATTRS))
  596. #define old_format_only(s) (REISERFS_SB(s)->s_properties & (1 << REISERFS_3_5))
  597. #define convert_reiserfs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_CONVERT))
  598. #define reiserfs_data_log(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_LOG))
  599. #define reiserfs_data_ordered(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_ORDERED))
  600. #define reiserfs_data_writeback(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_WRITEBACK))
  601. #define reiserfs_xattrs_user(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_XATTRS_USER))
  602. #define reiserfs_posixacl(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_POSIXACL))
  603. #define reiserfs_expose_privroot(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_EXPOSE_PRIVROOT))
  604. #define reiserfs_xattrs_optional(s) (reiserfs_xattrs_user(s) || reiserfs_posixacl(s))
  605. #define reiserfs_barrier_none(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_NONE))
  606. #define reiserfs_barrier_flush(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_FLUSH))
  607. #define reiserfs_error_panic(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_PANIC))
  608. #define reiserfs_error_ro(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_RO))
  609. void reiserfs_file_buffer(struct buffer_head *bh, int list);
  610. extern struct file_system_type reiserfs_fs_type;
  611. int reiserfs_resize(struct super_block *, unsigned long);
  612. #define CARRY_ON 0
  613. #define SCHEDULE_OCCURRED 1
  614. #define SB_BUFFER_WITH_SB(s) (REISERFS_SB(s)->s_sbh)
  615. #define SB_JOURNAL(s) (REISERFS_SB(s)->s_journal)
  616. #define SB_JOURNAL_1st_RESERVED_BLOCK(s) (SB_JOURNAL(s)->j_1st_reserved_block)
  617. #define SB_JOURNAL_LEN_FREE(s) (SB_JOURNAL(s)->j_journal_len_free)
  618. #define SB_AP_BITMAP(s) (REISERFS_SB(s)->s_ap_bitmap)
  619. #define SB_DISK_JOURNAL_HEAD(s) (SB_JOURNAL(s)->j_header_bh->)
  620. #define reiserfs_is_journal_aborted(journal) (unlikely (__reiserfs_is_journal_aborted (journal)))
  621. static inline int __reiserfs_is_journal_aborted(struct reiserfs_journal
  622. *journal)
  623. {
  624. return test_bit(J_ABORTED, &journal->j_state);
  625. }
  626. /*
  627. * Locking primitives. The write lock is a per superblock
  628. * special mutex that has properties close to the Big Kernel Lock
  629. * which was used in the previous locking scheme.
  630. */
  631. void reiserfs_write_lock(struct super_block *s);
  632. void reiserfs_write_unlock(struct super_block *s);
  633. int __must_check reiserfs_write_unlock_nested(struct super_block *s);
  634. void reiserfs_write_lock_nested(struct super_block *s, int depth);
  635. #ifdef CONFIG_REISERFS_CHECK
  636. void reiserfs_lock_check_recursive(struct super_block *s);
  637. #else
  638. static inline void reiserfs_lock_check_recursive(struct super_block *s) { }
  639. #endif
  640. /*
  641. * Several mutexes depend on the write lock.
  642. * However sometimes we want to relax the write lock while we hold
  643. * these mutexes, according to the release/reacquire on schedule()
  644. * properties of the Bkl that were used.
  645. * Reiserfs performances and locking were based on this scheme.
  646. * Now that the write lock is a mutex and not the bkl anymore, doing so
  647. * may result in a deadlock:
  648. *
  649. * A acquire write_lock
  650. * A acquire j_commit_mutex
  651. * A release write_lock and wait for something
  652. * B acquire write_lock
  653. * B can't acquire j_commit_mutex and sleep
  654. * A can't acquire write lock anymore
  655. * deadlock
  656. *
  657. * What we do here is avoiding such deadlock by playing the same game
  658. * than the Bkl: if we can't acquire a mutex that depends on the write lock,
  659. * we release the write lock, wait a bit and then retry.
  660. *
  661. * The mutexes concerned by this hack are:
  662. * - The commit mutex of a journal list
  663. * - The flush mutex
  664. * - The journal lock
  665. * - The inode mutex
  666. */
  667. static inline void reiserfs_mutex_lock_safe(struct mutex *m,
  668. struct super_block *s)
  669. {
  670. int depth;
  671. depth = reiserfs_write_unlock_nested(s);
  672. mutex_lock(m);
  673. reiserfs_write_lock_nested(s, depth);
  674. }
  675. static inline void
  676. reiserfs_mutex_lock_nested_safe(struct mutex *m, unsigned int subclass,
  677. struct super_block *s)
  678. {
  679. int depth;
  680. depth = reiserfs_write_unlock_nested(s);
  681. mutex_lock_nested(m, subclass);
  682. reiserfs_write_lock_nested(s, depth);
  683. }
  684. static inline void
  685. reiserfs_down_read_safe(struct rw_semaphore *sem, struct super_block *s)
  686. {
  687. int depth;
  688. depth = reiserfs_write_unlock_nested(s);
  689. down_read(sem);
  690. reiserfs_write_lock_nested(s, depth);
  691. }
  692. /*
  693. * When we schedule, we usually want to also release the write lock,
  694. * according to the previous bkl based locking scheme of reiserfs.
  695. */
  696. static inline void reiserfs_cond_resched(struct super_block *s)
  697. {
  698. if (need_resched()) {
  699. int depth;
  700. depth = reiserfs_write_unlock_nested(s);
  701. schedule();
  702. reiserfs_write_lock_nested(s, depth);
  703. }
  704. }
  705. struct fid;
  706. /*
  707. * in reading the #defines, it may help to understand that they employ
  708. * the following abbreviations:
  709. *
  710. * B = Buffer
  711. * I = Item header
  712. * H = Height within the tree (should be changed to LEV)
  713. * N = Number of the item in the node
  714. * STAT = stat data
  715. * DEH = Directory Entry Header
  716. * EC = Entry Count
  717. * E = Entry number
  718. * UL = Unsigned Long
  719. * BLKH = BLocK Header
  720. * UNFM = UNForMatted node
  721. * DC = Disk Child
  722. * P = Path
  723. *
  724. * These #defines are named by concatenating these abbreviations,
  725. * where first comes the arguments, and last comes the return value,
  726. * of the macro.
  727. */
  728. #define USE_INODE_GENERATION_COUNTER
  729. #define REISERFS_PREALLOCATE
  730. #define DISPLACE_NEW_PACKING_LOCALITIES
  731. #define PREALLOCATION_SIZE 9
  732. /* n must be power of 2 */
  733. #define _ROUND_UP(x,n) (((x)+(n)-1u) & ~((n)-1u))
  734. /*
  735. * to be ok for alpha and others we have to align structures to 8 byte
  736. * boundary.
  737. * FIXME: do not change 4 by anything else: there is code which relies on that
  738. */
  739. #define ROUND_UP(x) _ROUND_UP(x,8LL)
  740. /*
  741. * debug levels. Right now, CONFIG_REISERFS_CHECK means print all debug
  742. * messages.
  743. */
  744. #define REISERFS_DEBUG_CODE 5 /* extra messages to help find/debug errors */
  745. void __reiserfs_warning(struct super_block *s, const char *id,
  746. const char *func, const char *fmt, ...);
  747. #define reiserfs_warning(s, id, fmt, args...) \
  748. __reiserfs_warning(s, id, __func__, fmt, ##args)
  749. /* assertions handling */
  750. /* always check a condition and panic if it's false. */
  751. #define __RASSERT(cond, scond, format, args...) \
  752. do { \
  753. if (!(cond)) \
  754. reiserfs_panic(NULL, "assertion failure", "(" #cond ") at " \
  755. __FILE__ ":%i:%s: " format "\n", \
  756. __LINE__, __func__ , ##args); \
  757. } while (0)
  758. #define RASSERT(cond, format, args...) __RASSERT(cond, #cond, format, ##args)
  759. #if defined( CONFIG_REISERFS_CHECK )
  760. #define RFALSE(cond, format, args...) __RASSERT(!(cond), "!(" #cond ")", format, ##args)
  761. #else
  762. #define RFALSE( cond, format, args... ) do {;} while( 0 )
  763. #endif
  764. #define CONSTF __attribute_const__
  765. /*
  766. * Disk Data Structures
  767. */
  768. /***************************************************************************
  769. * SUPER BLOCK *
  770. ***************************************************************************/
  771. /*
  772. * Structure of super block on disk, a version of which in RAM is often
  773. * accessed as REISERFS_SB(s)->s_rs. The version in RAM is part of a larger
  774. * structure containing fields never written to disk.
  775. */
  776. #define UNSET_HASH 0 /* Detect hash on disk */
  777. #define TEA_HASH 1
  778. #define YURA_HASH 2
  779. #define R5_HASH 3
  780. #define DEFAULT_HASH R5_HASH
  781. struct journal_params {
  782. /* where does journal start from on its * device */
  783. __le32 jp_journal_1st_block;
  784. /* journal device st_rdev */
  785. __le32 jp_journal_dev;
  786. /* size of the journal */
  787. __le32 jp_journal_size;
  788. /* max number of blocks in a transaction. */
  789. __le32 jp_journal_trans_max;
  790. /*
  791. * random value made on fs creation
  792. * (this was sb_journal_block_count)
  793. */
  794. __le32 jp_journal_magic;
  795. /* max number of blocks to batch into a trans */
  796. __le32 jp_journal_max_batch;
  797. /* in seconds, how old can an async commit be */
  798. __le32 jp_journal_max_commit_age;
  799. /* in seconds, how old can a transaction be */
  800. __le32 jp_journal_max_trans_age;
  801. };
  802. /* this is the super from 3.5.X, where X >= 10 */
  803. struct reiserfs_super_block_v1 {
  804. __le32 s_block_count; /* blocks count */
  805. __le32 s_free_blocks; /* free blocks count */
  806. __le32 s_root_block; /* root block number */
  807. struct journal_params s_journal;
  808. __le16 s_blocksize; /* block size */
  809. /* max size of object id array, see get_objectid() commentary */
  810. __le16 s_oid_maxsize;
  811. __le16 s_oid_cursize; /* current size of object id array */
  812. /* this is set to 1 when filesystem was umounted, to 2 - when not */
  813. __le16 s_umount_state;
  814. /*
  815. * reiserfs magic string indicates that file system is reiserfs:
  816. * "ReIsErFs" or "ReIsEr2Fs" or "ReIsEr3Fs"
  817. */
  818. char s_magic[10];
  819. /*
  820. * it is set to used by fsck to mark which
  821. * phase of rebuilding is done
  822. */
  823. __le16 s_fs_state;
  824. /*
  825. * indicate, what hash function is being use
  826. * to sort names in a directory
  827. */
  828. __le32 s_hash_function_code;
  829. __le16 s_tree_height; /* height of disk tree */
  830. /*
  831. * amount of bitmap blocks needed to address
  832. * each block of file system
  833. */
  834. __le16 s_bmap_nr;
  835. /*
  836. * this field is only reliable on filesystem with non-standard journal
  837. */
  838. __le16 s_version;
  839. /*
  840. * size in blocks of journal area on main device, we need to
  841. * keep after making fs with non-standard journal
  842. */
  843. __le16 s_reserved_for_journal;
  844. } __attribute__ ((__packed__));
  845. #define SB_SIZE_V1 (sizeof(struct reiserfs_super_block_v1))
  846. /* this is the on disk super block */
  847. struct reiserfs_super_block {
  848. struct reiserfs_super_block_v1 s_v1;
  849. __le32 s_inode_generation;
  850. /* Right now used only by inode-attributes, if enabled */
  851. __le32 s_flags;
  852. unsigned char s_uuid[16]; /* filesystem unique identifier */
  853. unsigned char s_label[16]; /* filesystem volume label */
  854. __le16 s_mnt_count; /* Count of mounts since last fsck */
  855. __le16 s_max_mnt_count; /* Maximum mounts before check */
  856. __le32 s_lastcheck; /* Timestamp of last fsck */
  857. __le32 s_check_interval; /* Interval between checks */
  858. /*
  859. * zero filled by mkreiserfs and reiserfs_convert_objectid_map_v1()
  860. * so any additions must be updated there as well. */
  861. char s_unused[76];
  862. } __attribute__ ((__packed__));
  863. #define SB_SIZE (sizeof(struct reiserfs_super_block))
  864. #define REISERFS_VERSION_1 0
  865. #define REISERFS_VERSION_2 2
  866. /* on-disk super block fields converted to cpu form */
  867. #define SB_DISK_SUPER_BLOCK(s) (REISERFS_SB(s)->s_rs)
  868. #define SB_V1_DISK_SUPER_BLOCK(s) (&(SB_DISK_SUPER_BLOCK(s)->s_v1))
  869. #define SB_BLOCKSIZE(s) \
  870. le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_blocksize))
  871. #define SB_BLOCK_COUNT(s) \
  872. le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_block_count))
  873. #define SB_FREE_BLOCKS(s) \
  874. le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_free_blocks))
  875. #define SB_REISERFS_MAGIC(s) \
  876. (SB_V1_DISK_SUPER_BLOCK(s)->s_magic)
  877. #define SB_ROOT_BLOCK(s) \
  878. le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_root_block))
  879. #define SB_TREE_HEIGHT(s) \
  880. le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_tree_height))
  881. #define SB_REISERFS_STATE(s) \
  882. le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_umount_state))
  883. #define SB_VERSION(s) le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_version))
  884. #define SB_BMAP_NR(s) le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_bmap_nr))
  885. #define PUT_SB_BLOCK_COUNT(s, val) \
  886. do { SB_V1_DISK_SUPER_BLOCK(s)->s_block_count = cpu_to_le32(val); } while (0)
  887. #define PUT_SB_FREE_BLOCKS(s, val) \
  888. do { SB_V1_DISK_SUPER_BLOCK(s)->s_free_blocks = cpu_to_le32(val); } while (0)
  889. #define PUT_SB_ROOT_BLOCK(s, val) \
  890. do { SB_V1_DISK_SUPER_BLOCK(s)->s_root_block = cpu_to_le32(val); } while (0)
  891. #define PUT_SB_TREE_HEIGHT(s, val) \
  892. do { SB_V1_DISK_SUPER_BLOCK(s)->s_tree_height = cpu_to_le16(val); } while (0)
  893. #define PUT_SB_REISERFS_STATE(s, val) \
  894. do { SB_V1_DISK_SUPER_BLOCK(s)->s_umount_state = cpu_to_le16(val); } while (0)
  895. #define PUT_SB_VERSION(s, val) \
  896. do { SB_V1_DISK_SUPER_BLOCK(s)->s_version = cpu_to_le16(val); } while (0)
  897. #define PUT_SB_BMAP_NR(s, val) \
  898. do { SB_V1_DISK_SUPER_BLOCK(s)->s_bmap_nr = cpu_to_le16 (val); } while (0)
  899. #define SB_ONDISK_JP(s) (&SB_V1_DISK_SUPER_BLOCK(s)->s_journal)
  900. #define SB_ONDISK_JOURNAL_SIZE(s) \
  901. le32_to_cpu ((SB_ONDISK_JP(s)->jp_journal_size))
  902. #define SB_ONDISK_JOURNAL_1st_BLOCK(s) \
  903. le32_to_cpu ((SB_ONDISK_JP(s)->jp_journal_1st_block))
  904. #define SB_ONDISK_JOURNAL_DEVICE(s) \
  905. le32_to_cpu ((SB_ONDISK_JP(s)->jp_journal_dev))
  906. #define SB_ONDISK_RESERVED_FOR_JOURNAL(s) \
  907. le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_reserved_for_journal))
  908. #define is_block_in_log_or_reserved_area(s, block) \
  909. block >= SB_JOURNAL_1st_RESERVED_BLOCK(s) \
  910. && block < SB_JOURNAL_1st_RESERVED_BLOCK(s) + \
  911. ((!is_reiserfs_jr(SB_DISK_SUPER_BLOCK(s)) ? \
  912. SB_ONDISK_JOURNAL_SIZE(s) + 1 : SB_ONDISK_RESERVED_FOR_JOURNAL(s)))
  913. int is_reiserfs_3_5(struct reiserfs_super_block *rs);
  914. int is_reiserfs_3_6(struct reiserfs_super_block *rs);
  915. int is_reiserfs_jr(struct reiserfs_super_block *rs);
  916. /*
  917. * ReiserFS leaves the first 64k unused, so that partition labels have
  918. * enough space. If someone wants to write a fancy bootloader that
  919. * needs more than 64k, let us know, and this will be increased in size.
  920. * This number must be larger than the largest block size on any
  921. * platform, or code will break. -Hans
  922. */
  923. #define REISERFS_DISK_OFFSET_IN_BYTES (64 * 1024)
  924. #define REISERFS_FIRST_BLOCK unused_define
  925. #define REISERFS_JOURNAL_OFFSET_IN_BYTES REISERFS_DISK_OFFSET_IN_BYTES
  926. /* the spot for the super in versions 3.5 - 3.5.10 (inclusive) */
  927. #define REISERFS_OLD_DISK_OFFSET_IN_BYTES (8 * 1024)
  928. /* reiserfs internal error code (used by search_by_key and fix_nodes)) */
  929. #define CARRY_ON 0
  930. #define REPEAT_SEARCH -1
  931. #define IO_ERROR -2
  932. #define NO_DISK_SPACE -3
  933. #define NO_BALANCING_NEEDED (-4)
  934. #define NO_MORE_UNUSED_CONTIGUOUS_BLOCKS (-5)
  935. #define QUOTA_EXCEEDED -6
  936. typedef __u32 b_blocknr_t;
  937. typedef __le32 unp_t;
  938. struct unfm_nodeinfo {
  939. unp_t unfm_nodenum;
  940. unsigned short unfm_freespace;
  941. };
  942. /* there are two formats of keys: 3.5 and 3.6 */
  943. #define KEY_FORMAT_3_5 0
  944. #define KEY_FORMAT_3_6 1
  945. /* there are two stat datas */
  946. #define STAT_DATA_V1 0
  947. #define STAT_DATA_V2 1
  948. static inline struct reiserfs_inode_info *REISERFS_I(const struct inode *inode)
  949. {
  950. return container_of(inode, struct reiserfs_inode_info, vfs_inode);
  951. }
  952. static inline struct reiserfs_sb_info *REISERFS_SB(const struct super_block *sb)
  953. {
  954. return sb->s_fs_info;
  955. }
  956. /*
  957. * Don't trust REISERFS_SB(sb)->s_bmap_nr, it's a u16
  958. * which overflows on large file systems.
  959. */
  960. static inline __u32 reiserfs_bmap_count(struct super_block *sb)
  961. {
  962. return (SB_BLOCK_COUNT(sb) - 1) / (sb->s_blocksize * 8) + 1;
  963. }
  964. static inline int bmap_would_wrap(unsigned bmap_nr)
  965. {
  966. return bmap_nr > ((1LL << 16) - 1);
  967. }
  968. extern const struct xattr_handler *reiserfs_xattr_handlers[];
  969. /*
  970. * this says about version of key of all items (but stat data) the
  971. * object consists of
  972. */
  973. #define get_inode_item_key_version( inode ) \
  974. ((REISERFS_I(inode)->i_flags & i_item_key_version_mask) ? KEY_FORMAT_3_6 : KEY_FORMAT_3_5)
  975. #define set_inode_item_key_version( inode, version ) \
  976. ({ if((version)==KEY_FORMAT_3_6) \
  977. REISERFS_I(inode)->i_flags |= i_item_key_version_mask; \
  978. else \
  979. REISERFS_I(inode)->i_flags &= ~i_item_key_version_mask; })
  980. #define get_inode_sd_version(inode) \
  981. ((REISERFS_I(inode)->i_flags & i_stat_data_version_mask) ? STAT_DATA_V2 : STAT_DATA_V1)
  982. #define set_inode_sd_version(inode, version) \
  983. ({ if((version)==STAT_DATA_V2) \
  984. REISERFS_I(inode)->i_flags |= i_stat_data_version_mask; \
  985. else \
  986. REISERFS_I(inode)->i_flags &= ~i_stat_data_version_mask; })
  987. /*
  988. * This is an aggressive tail suppression policy, I am hoping it
  989. * improves our benchmarks. The principle behind it is that percentage
  990. * space saving is what matters, not absolute space saving. This is
  991. * non-intuitive, but it helps to understand it if you consider that the
  992. * cost to access 4 blocks is not much more than the cost to access 1
  993. * block, if you have to do a seek and rotate. A tail risks a
  994. * non-linear disk access that is significant as a percentage of total
  995. * time cost for a 4 block file and saves an amount of space that is
  996. * less significant as a percentage of space, or so goes the hypothesis.
  997. * -Hans
  998. */
  999. #define STORE_TAIL_IN_UNFM_S1(n_file_size,n_tail_size,n_block_size) \
  1000. (\
  1001. (!(n_tail_size)) || \
  1002. (((n_tail_size) > MAX_DIRECT_ITEM_LEN(n_block_size)) || \
  1003. ( (n_file_size) >= (n_block_size) * 4 ) || \
  1004. ( ( (n_file_size) >= (n_block_size) * 3 ) && \
  1005. ( (n_tail_size) >= (MAX_DIRECT_ITEM_LEN(n_block_size))/4) ) || \
  1006. ( ( (n_file_size) >= (n_block_size) * 2 ) && \
  1007. ( (n_tail_size) >= (MAX_DIRECT_ITEM_LEN(n_block_size))/2) ) || \
  1008. ( ( (n_file_size) >= (n_block_size) ) && \
  1009. ( (n_tail_size) >= (MAX_DIRECT_ITEM_LEN(n_block_size) * 3)/4) ) ) \
  1010. )
  1011. /*
  1012. * Another strategy for tails, this one means only create a tail if all the
  1013. * file would fit into one DIRECT item.
  1014. * Primary intention for this one is to increase performance by decreasing
  1015. * seeking.
  1016. */
  1017. #define STORE_TAIL_IN_UNFM_S2(n_file_size,n_tail_size,n_block_size) \
  1018. (\
  1019. (!(n_tail_size)) || \
  1020. (((n_file_size) > MAX_DIRECT_ITEM_LEN(n_block_size)) ) \
  1021. )
  1022. /*
  1023. * values for s_umount_state field
  1024. */
  1025. #define REISERFS_VALID_FS 1
  1026. #define REISERFS_ERROR_FS 2
  1027. /*
  1028. * there are 5 item types currently
  1029. */
  1030. #define TYPE_STAT_DATA 0
  1031. #define TYPE_INDIRECT 1
  1032. #define TYPE_DIRECT 2
  1033. #define TYPE_DIRENTRY 3
  1034. #define TYPE_MAXTYPE 3
  1035. #define TYPE_ANY 15 /* FIXME: comment is required */
  1036. /***************************************************************************
  1037. * KEY & ITEM HEAD *
  1038. ***************************************************************************/
  1039. /* * directories use this key as well as old files */
  1040. struct offset_v1 {
  1041. __le32 k_offset;
  1042. __le32 k_uniqueness;
  1043. } __attribute__ ((__packed__));
  1044. struct offset_v2 {
  1045. __le64 v;
  1046. } __attribute__ ((__packed__));
  1047. static inline __u16 offset_v2_k_type(const struct offset_v2 *v2)
  1048. {
  1049. __u8 type = le64_to_cpu(v2->v) >> 60;
  1050. return (type <= TYPE_MAXTYPE) ? type : TYPE_ANY;
  1051. }
  1052. static inline void set_offset_v2_k_type(struct offset_v2 *v2, int type)
  1053. {
  1054. v2->v =
  1055. (v2->v & cpu_to_le64(~0ULL >> 4)) | cpu_to_le64((__u64) type << 60);
  1056. }
  1057. static inline loff_t offset_v2_k_offset(const struct offset_v2 *v2)
  1058. {
  1059. return le64_to_cpu(v2->v) & (~0ULL >> 4);
  1060. }
  1061. static inline void set_offset_v2_k_offset(struct offset_v2 *v2, loff_t offset)
  1062. {
  1063. offset &= (~0ULL >> 4);
  1064. v2->v = (v2->v & cpu_to_le64(15ULL << 60)) | cpu_to_le64(offset);
  1065. }
  1066. /*
  1067. * Key of an item determines its location in the S+tree, and
  1068. * is composed of 4 components
  1069. */
  1070. struct reiserfs_key {
  1071. /* packing locality: by default parent directory object id */
  1072. __le32 k_dir_id;
  1073. __le32 k_objectid; /* object identifier */
  1074. union {
  1075. struct offset_v1 k_offset_v1;
  1076. struct offset_v2 k_offset_v2;
  1077. } __attribute__ ((__packed__)) u;
  1078. } __attribute__ ((__packed__));
  1079. struct in_core_key {
  1080. /* packing locality: by default parent directory object id */
  1081. __u32 k_dir_id;
  1082. __u32 k_objectid; /* object identifier */
  1083. __u64 k_offset;
  1084. __u8 k_type;
  1085. };
  1086. struct cpu_key {
  1087. struct in_core_key on_disk_key;
  1088. int version;
  1089. /* 3 in all cases but direct2indirect and indirect2direct conversion */
  1090. int key_length;
  1091. };
  1092. /*
  1093. * Our function for comparing keys can compare keys of different
  1094. * lengths. It takes as a parameter the length of the keys it is to
  1095. * compare. These defines are used in determining what is to be passed
  1096. * to it as that parameter.
  1097. */
  1098. #define REISERFS_FULL_KEY_LEN 4
  1099. #define REISERFS_SHORT_KEY_LEN 2
  1100. /* The result of the key compare */
  1101. #define FIRST_GREATER 1
  1102. #define SECOND_GREATER -1
  1103. #define KEYS_IDENTICAL 0
  1104. #define KEY_FOUND 1
  1105. #define KEY_NOT_FOUND 0
  1106. #define KEY_SIZE (sizeof(struct reiserfs_key))
  1107. /* return values for search_by_key and clones */
  1108. #define ITEM_FOUND 1
  1109. #define ITEM_NOT_FOUND 0
  1110. #define ENTRY_FOUND 1
  1111. #define ENTRY_NOT_FOUND 0
  1112. #define DIRECTORY_NOT_FOUND -1
  1113. #define REGULAR_FILE_FOUND -2
  1114. #define DIRECTORY_FOUND -3
  1115. #define BYTE_FOUND 1
  1116. #define BYTE_NOT_FOUND 0
  1117. #define FILE_NOT_FOUND -1
  1118. #define POSITION_FOUND 1
  1119. #define POSITION_NOT_FOUND 0
  1120. /* return values for reiserfs_find_entry and search_by_entry_key */
  1121. #define NAME_FOUND 1
  1122. #define NAME_NOT_FOUND 0
  1123. #define GOTO_PREVIOUS_ITEM 2
  1124. #define NAME_FOUND_INVISIBLE 3
  1125. /*
  1126. * Everything in the filesystem is stored as a set of items. The
  1127. * item head contains the key of the item, its free space (for
  1128. * indirect items) and specifies the location of the item itself
  1129. * within the block.
  1130. */
  1131. struct item_head {
  1132. /*
  1133. * Everything in the tree is found by searching for it based on
  1134. * its key.
  1135. */
  1136. struct reiserfs_key ih_key;
  1137. union {
  1138. /*
  1139. * The free space in the last unformatted node of an
  1140. * indirect item if this is an indirect item. This
  1141. * equals 0xFFFF iff this is a direct item or stat data
  1142. * item. Note that the key, not this field, is used to
  1143. * determine the item type, and thus which field this
  1144. * union contains.
  1145. */
  1146. __le16 ih_free_space_reserved;
  1147. /*
  1148. * Iff this is a directory item, this field equals the
  1149. * number of directory entries in the directory item.
  1150. */
  1151. __le16 ih_entry_count;
  1152. } __attribute__ ((__packed__)) u;
  1153. __le16 ih_item_len; /* total size of the item body */
  1154. /* an offset to the item body within the block */
  1155. __le16 ih_item_location;
  1156. /*
  1157. * 0 for all old items, 2 for new ones. Highest bit is set by fsck
  1158. * temporary, cleaned after all done
  1159. */
  1160. __le16 ih_version;
  1161. } __attribute__ ((__packed__));
  1162. /* size of item header */
  1163. #define IH_SIZE (sizeof(struct item_head))
  1164. #define ih_free_space(ih) le16_to_cpu((ih)->u.ih_free_space_reserved)
  1165. #define ih_version(ih) le16_to_cpu((ih)->ih_version)
  1166. #define ih_entry_count(ih) le16_to_cpu((ih)->u.ih_entry_count)
  1167. #define ih_location(ih) le16_to_cpu((ih)->ih_item_location)
  1168. #define ih_item_len(ih) le16_to_cpu((ih)->ih_item_len)
  1169. #define put_ih_free_space(ih, val) do { (ih)->u.ih_free_space_reserved = cpu_to_le16(val); } while(0)
  1170. #define put_ih_version(ih, val) do { (ih)->ih_version = cpu_to_le16(val); } while (0)
  1171. #define put_ih_entry_count(ih, val) do { (ih)->u.ih_entry_count = cpu_to_le16(val); } while (0)
  1172. #define put_ih_location(ih, val) do { (ih)->ih_item_location = cpu_to_le16(val); } while (0)
  1173. #define put_ih_item_len(ih, val) do { (ih)->ih_item_len = cpu_to_le16(val); } while (0)
  1174. #define unreachable_item(ih) (ih_version(ih) & (1 << 15))
  1175. #define get_ih_free_space(ih) (ih_version (ih) == KEY_FORMAT_3_6 ? 0 : ih_free_space (ih))
  1176. #define set_ih_free_space(ih,val) put_ih_free_space((ih), ((ih_version(ih) == KEY_FORMAT_3_6) ? 0 : (val)))
  1177. /*
  1178. * these operate on indirect items, where you've got an array of ints
  1179. * at a possibly unaligned location. These are a noop on ia32
  1180. *
  1181. * p is the array of __u32, i is the index into the array, v is the value
  1182. * to store there.
  1183. */
  1184. #define get_block_num(p, i) get_unaligned_le32((p) + (i))
  1185. #define put_block_num(p, i, v) put_unaligned_le32((v), (p) + (i))
  1186. /* * in old version uniqueness field shows key type */
  1187. #define V1_SD_UNIQUENESS 0
  1188. #define V1_INDIRECT_UNIQUENESS 0xfffffffe
  1189. #define V1_DIRECT_UNIQUENESS 0xffffffff
  1190. #define V1_DIRENTRY_UNIQUENESS 500
  1191. #define V1_ANY_UNIQUENESS 555 /* FIXME: comment is required */
  1192. /* here are conversion routines */
  1193. static inline int uniqueness2type(__u32 uniqueness) CONSTF;
  1194. static inline int uniqueness2type(__u32 uniqueness)
  1195. {
  1196. switch ((int)uniqueness) {
  1197. case V1_SD_UNIQUENESS:
  1198. return TYPE_STAT_DATA;
  1199. case V1_INDIRECT_UNIQUENESS:
  1200. return TYPE_INDIRECT;
  1201. case V1_DIRECT_UNIQUENESS:
  1202. return TYPE_DIRECT;
  1203. case V1_DIRENTRY_UNIQUENESS:
  1204. return TYPE_DIRENTRY;
  1205. case V1_ANY_UNIQUENESS:
  1206. default:
  1207. return TYPE_ANY;
  1208. }
  1209. }
  1210. static inline __u32 type2uniqueness(int type) CONSTF;
  1211. static inline __u32 type2uniqueness(int type)
  1212. {
  1213. switch (type) {
  1214. case TYPE_STAT_DATA:
  1215. return V1_SD_UNIQUENESS;
  1216. case TYPE_INDIRECT:
  1217. return V1_INDIRECT_UNIQUENESS;
  1218. case TYPE_DIRECT:
  1219. return V1_DIRECT_UNIQUENESS;
  1220. case TYPE_DIRENTRY:
  1221. return V1_DIRENTRY_UNIQUENESS;
  1222. case TYPE_ANY:
  1223. default:
  1224. return V1_ANY_UNIQUENESS;
  1225. }
  1226. }
  1227. /*
  1228. * key is pointer to on disk key which is stored in le, result is cpu,
  1229. * there is no way to get version of object from key, so, provide
  1230. * version to these defines
  1231. */
  1232. static inline loff_t le_key_k_offset(int version,
  1233. const struct reiserfs_key *key)
  1234. {
  1235. return (version == KEY_FORMAT_3_5) ?
  1236. le32_to_cpu(key->u.k_offset_v1.k_offset) :
  1237. offset_v2_k_offset(&(key->u.k_offset_v2));
  1238. }
  1239. static inline loff_t le_ih_k_offset(const struct item_head *ih)
  1240. {
  1241. return le_key_k_offset(ih_version(ih), &(ih->ih_key));
  1242. }
  1243. static inline loff_t le_key_k_type(int version, const struct reiserfs_key *key)
  1244. {
  1245. if (version == KEY_FORMAT_3_5) {
  1246. loff_t val = le32_to_cpu(key->u.k_offset_v1.k_uniqueness);
  1247. return uniqueness2type(val);
  1248. } else
  1249. return offset_v2_k_type(&(key->u.k_offset_v2));
  1250. }
  1251. static inline loff_t le_ih_k_type(const struct item_head *ih)
  1252. {
  1253. return le_key_k_type(ih_version(ih), &(ih->ih_key));
  1254. }
  1255. static inline void set_le_key_k_offset(int version, struct reiserfs_key *key,
  1256. loff_t offset)
  1257. {
  1258. if (version == KEY_FORMAT_3_5)
  1259. key->u.k_offset_v1.k_offset = cpu_to_le32(offset);
  1260. else
  1261. set_offset_v2_k_offset(&key->u.k_offset_v2, offset);
  1262. }
  1263. static inline void add_le_key_k_offset(int version, struct reiserfs_key *key,
  1264. loff_t offset)
  1265. {
  1266. set_le_key_k_offset(version, key,
  1267. le_key_k_offset(version, key) + offset);
  1268. }
  1269. static inline void add_le_ih_k_offset(struct item_head *ih, loff_t offset)
  1270. {
  1271. add_le_key_k_offset(ih_version(ih), &(ih->ih_key), offset);
  1272. }
  1273. static inline void set_le_ih_k_offset(struct item_head *ih, loff_t offset)
  1274. {
  1275. set_le_key_k_offset(ih_version(ih), &(ih->ih_key), offset);
  1276. }
  1277. static inline void set_le_key_k_type(int version, struct reiserfs_key *key,
  1278. int type)
  1279. {
  1280. if (version == KEY_FORMAT_3_5) {
  1281. type = type2uniqueness(type);
  1282. key->u.k_offset_v1.k_uniqueness = cpu_to_le32(type);
  1283. } else
  1284. set_offset_v2_k_type(&key->u.k_offset_v2, type);
  1285. }
  1286. static inline void set_le_ih_k_type(struct item_head *ih, int type)
  1287. {
  1288. set_le_key_k_type(ih_version(ih), &(ih->ih_key), type);
  1289. }
  1290. static inline int is_direntry_le_key(int version, struct reiserfs_key *key)
  1291. {
  1292. return le_key_k_type(version, key) == TYPE_DIRENTRY;
  1293. }
  1294. static inline int is_direct_le_key(int version, struct reiserfs_key *key)
  1295. {
  1296. return le_key_k_type(version, key) == TYPE_DIRECT;
  1297. }
  1298. static inline int is_indirect_le_key(int version, struct reiserfs_key *key)
  1299. {
  1300. return le_key_k_type(version, key) == TYPE_INDIRECT;
  1301. }
  1302. static inline int is_statdata_le_key(int version, struct reiserfs_key *key)
  1303. {
  1304. return le_key_k_type(version, key) == TYPE_STAT_DATA;
  1305. }
  1306. /* item header has version. */
  1307. static inline int is_direntry_le_ih(struct item_head *ih)
  1308. {
  1309. return is_direntry_le_key(ih_version(ih), &ih->ih_key);
  1310. }
  1311. static inline int is_direct_le_ih(struct item_head *ih)
  1312. {
  1313. return is_direct_le_key(ih_version(ih), &ih->ih_key);
  1314. }
  1315. static inline int is_indirect_le_ih(struct item_head *ih)
  1316. {
  1317. return is_indirect_le_key(ih_version(ih), &ih->ih_key);
  1318. }
  1319. static inline int is_statdata_le_ih(struct item_head *ih)
  1320. {
  1321. return is_statdata_le_key(ih_version(ih), &ih->ih_key);
  1322. }
  1323. /* key is pointer to cpu key, result is cpu */
  1324. static inline loff_t cpu_key_k_offset(const struct cpu_key *key)
  1325. {
  1326. return key->on_disk_key.k_offset;
  1327. }
  1328. static inline loff_t cpu_key_k_type(const struct cpu_key *key)
  1329. {
  1330. return key->on_disk_key.k_type;
  1331. }
  1332. static inline void set_cpu_key_k_offset(struct cpu_key *key, loff_t offset)
  1333. {
  1334. key->on_disk_key.k_offset = offset;
  1335. }
  1336. static inline void set_cpu_key_k_type(struct cpu_key *key, int type)
  1337. {
  1338. key->on_disk_key.k_type = type;
  1339. }
  1340. static inline void cpu_key_k_offset_dec(struct cpu_key *key)
  1341. {
  1342. key->on_disk_key.k_offset--;
  1343. }
  1344. #define is_direntry_cpu_key(key) (cpu_key_k_type (key) == TYPE_DIRENTRY)
  1345. #define is_direct_cpu_key(key) (cpu_key_k_type (key) == TYPE_DIRECT)
  1346. #define is_indirect_cpu_key(key) (cpu_key_k_type (key) == TYPE_INDIRECT)
  1347. #define is_statdata_cpu_key(key) (cpu_key_k_type (key) == TYPE_STAT_DATA)
  1348. /* are these used ? */
  1349. #define is_direntry_cpu_ih(ih) (is_direntry_cpu_key (&((ih)->ih_key)))
  1350. #define is_direct_cpu_ih(ih) (is_direct_cpu_key (&((ih)->ih_key)))
  1351. #define is_indirect_cpu_ih(ih) (is_indirect_cpu_key (&((ih)->ih_key)))
  1352. #define is_statdata_cpu_ih(ih) (is_statdata_cpu_key (&((ih)->ih_key)))
  1353. #define I_K_KEY_IN_ITEM(ih, key, n_blocksize) \
  1354. (!COMP_SHORT_KEYS(ih, key) && \
  1355. I_OFF_BYTE_IN_ITEM(ih, k_offset(key), n_blocksize))
  1356. /* maximal length of item */
  1357. #define MAX_ITEM_LEN(block_size) (block_size - BLKH_SIZE - IH_SIZE)
  1358. #define MIN_ITEM_LEN 1
  1359. /* object identifier for root dir */
  1360. #define REISERFS_ROOT_OBJECTID 2
  1361. #define REISERFS_ROOT_PARENT_OBJECTID 1
  1362. extern struct reiserfs_key root_key;
  1363. /*
  1364. * Picture represents a leaf of the S+tree
  1365. * ______________________________________________________
  1366. * | | Array of | | |
  1367. * |Block | Object-Item | F r e e | Objects- |
  1368. * | head | Headers | S p a c e | Items |
  1369. * |______|_______________|___________________|___________|
  1370. */
  1371. /*
  1372. * Header of a disk block. More precisely, header of a formatted leaf
  1373. * or internal node, and not the header of an unformatted node.
  1374. */
  1375. struct block_head {
  1376. __le16 blk_level; /* Level of a block in the tree. */
  1377. __le16 blk_nr_item; /* Number of keys/items in a block. */
  1378. __le16 blk_free_space; /* Block free space in bytes. */
  1379. __le16 blk_reserved;
  1380. /* dump this in v4/planA */
  1381. /* kept only for compatibility */
  1382. struct reiserfs_key blk_right_delim_key;
  1383. };
  1384. #define BLKH_SIZE (sizeof(struct block_head))
  1385. #define blkh_level(p_blkh) (le16_to_cpu((p_blkh)->blk_level))
  1386. #define blkh_nr_item(p_blkh) (le16_to_cpu((p_blkh)->blk_nr_item))
  1387. #define blkh_free_space(p_blkh) (le16_to_cpu((p_blkh)->blk_free_space))
  1388. #define blkh_reserved(p_blkh) (le16_to_cpu((p_blkh)->blk_reserved))
  1389. #define set_blkh_level(p_blkh,val) ((p_blkh)->blk_level = cpu_to_le16(val))
  1390. #define set_blkh_nr_item(p_blkh,val) ((p_blkh)->blk_nr_item = cpu_to_le16(val))
  1391. #define set_blkh_free_space(p_blkh,val) ((p_blkh)->blk_free_space = cpu_to_le16(val))
  1392. #define set_blkh_reserved(p_blkh,val) ((p_blkh)->blk_reserved = cpu_to_le16(val))
  1393. #define blkh_right_delim_key(p_blkh) ((p_blkh)->blk_right_delim_key)
  1394. #define set_blkh_right_delim_key(p_blkh,val) ((p_blkh)->blk_right_delim_key = val)
  1395. /* values for blk_level field of the struct block_head */
  1396. /*
  1397. * When node gets removed from the tree its blk_level is set to FREE_LEVEL.
  1398. * It is then used to see whether the node is still in the tree
  1399. */
  1400. #define FREE_LEVEL 0
  1401. #define DISK_LEAF_NODE_LEVEL 1 /* Leaf node level. */
  1402. /*
  1403. * Given the buffer head of a formatted node, resolve to the
  1404. * block head of that node.
  1405. */
  1406. #define B_BLK_HEAD(bh) ((struct block_head *)((bh)->b_data))
  1407. /* Number of items that are in buffer. */
  1408. #define B_NR_ITEMS(bh) (blkh_nr_item(B_BLK_HEAD(bh)))
  1409. #define B_LEVEL(bh) (blkh_level(B_BLK_HEAD(bh)))
  1410. #define B_FREE_SPACE(bh) (blkh_free_space(B_BLK_HEAD(bh)))
  1411. #define PUT_B_NR_ITEMS(bh, val) do { set_blkh_nr_item(B_BLK_HEAD(bh), val); } while (0)
  1412. #define PUT_B_LEVEL(bh, val) do { set_blkh_level(B_BLK_HEAD(bh), val); } while (0)
  1413. #define PUT_B_FREE_SPACE(bh, val) do { set_blkh_free_space(B_BLK_HEAD(bh), val); } while (0)
  1414. /* Get right delimiting key. -- little endian */
  1415. #define B_PRIGHT_DELIM_KEY(bh) (&(blk_right_delim_key(B_BLK_HEAD(bh))))
  1416. /* Does the buffer contain a disk leaf. */
  1417. #define B_IS_ITEMS_LEVEL(bh) (B_LEVEL(bh) == DISK_LEAF_NODE_LEVEL)
  1418. /* Does the buffer contain a disk internal node */
  1419. #define B_IS_KEYS_LEVEL(bh) (B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL \
  1420. && B_LEVEL(bh) <= MAX_HEIGHT)
  1421. /***************************************************************************
  1422. * STAT DATA *
  1423. ***************************************************************************/
  1424. /*
  1425. * old stat data is 32 bytes long. We are going to distinguish new one by
  1426. * different size
  1427. */
  1428. struct stat_data_v1 {
  1429. __le16 sd_mode; /* file type, permissions */
  1430. __le16 sd_nlink; /* number of hard links */
  1431. __le16 sd_uid; /* owner */
  1432. __le16 sd_gid; /* group */
  1433. __le32 sd_size; /* file size */
  1434. __le32 sd_atime; /* time of last access */
  1435. __le32 sd_mtime; /* time file was last modified */
  1436. /*
  1437. * time inode (stat data) was last changed
  1438. * (except changes to sd_atime and sd_mtime)
  1439. */
  1440. __le32 sd_ctime;
  1441. union {
  1442. __le32 sd_rdev;
  1443. __le32 sd_blocks; /* number of blocks file uses */
  1444. } __attribute__ ((__packed__)) u;
  1445. /*
  1446. * first byte of file which is stored in a direct item: except that if
  1447. * it equals 1 it is a symlink and if it equals ~(__u32)0 there is no
  1448. * direct item. The existence of this field really grates on me.
  1449. * Let's replace it with a macro based on sd_size and our tail
  1450. * suppression policy. Someday. -Hans
  1451. */
  1452. __le32 sd_first_direct_byte;
  1453. } __attribute__ ((__packed__));
  1454. #define SD_V1_SIZE (sizeof(struct stat_data_v1))
  1455. #define stat_data_v1(ih) (ih_version (ih) == KEY_FORMAT_3_5)
  1456. #define sd_v1_mode(sdp) (le16_to_cpu((sdp)->sd_mode))
  1457. #define set_sd_v1_mode(sdp,v) ((sdp)->sd_mode = cpu_to_le16(v))
  1458. #define sd_v1_nlink(sdp) (le16_to_cpu((sdp)->sd_nlink))
  1459. #define set_sd_v1_nlink(sdp,v) ((sdp)->sd_nlink = cpu_to_le16(v))
  1460. #define sd_v1_uid(sdp) (le16_to_cpu((sdp)->sd_uid))
  1461. #define set_sd_v1_uid(sdp,v) ((sdp)->sd_uid = cpu_to_le16(v))
  1462. #define sd_v1_gid(sdp) (le16_to_cpu((sdp)->sd_gid))
  1463. #define set_sd_v1_gid(sdp,v) ((sdp)->sd_gid = cpu_to_le16(v))
  1464. #define sd_v1_size(sdp) (le32_to_cpu((sdp)->sd_size))
  1465. #define set_sd_v1_size(sdp,v) ((sdp)->sd_size = cpu_to_le32(v))
  1466. #define sd_v1_atime(sdp) (le32_to_cpu((sdp)->sd_atime))
  1467. #define set_sd_v1_atime(sdp,v) ((sdp)->sd_atime = cpu_to_le32(v))
  1468. #define sd_v1_mtime(sdp) (le32_to_cpu((sdp)->sd_mtime))
  1469. #define set_sd_v1_mtime(sdp,v) ((sdp)->sd_mtime = cpu_to_le32(v))
  1470. #define sd_v1_ctime(sdp) (le32_to_cpu((sdp)->sd_ctime))
  1471. #define set_sd_v1_ctime(sdp,v) ((sdp)->sd_ctime = cpu_to_le32(v))
  1472. #define sd_v1_rdev(sdp) (le32_to_cpu((sdp)->u.sd_rdev))
  1473. #define set_sd_v1_rdev(sdp,v) ((sdp)->u.sd_rdev = cpu_to_le32(v))
  1474. #define sd_v1_blocks(sdp) (le32_to_cpu((sdp)->u.sd_blocks))
  1475. #define set_sd_v1_blocks(sdp,v) ((sdp)->u.sd_blocks = cpu_to_le32(v))
  1476. #define sd_v1_first_direct_byte(sdp) \
  1477. (le32_to_cpu((sdp)->sd_first_direct_byte))
  1478. #define set_sd_v1_first_direct_byte(sdp,v) \
  1479. ((sdp)->sd_first_direct_byte = cpu_to_le32(v))
  1480. /* inode flags stored in sd_attrs (nee sd_reserved) */
  1481. /*
  1482. * we want common flags to have the same values as in ext2,
  1483. * so chattr(1) will work without problems
  1484. */
  1485. #define REISERFS_IMMUTABLE_FL FS_IMMUTABLE_FL
  1486. #define REISERFS_APPEND_FL FS_APPEND_FL
  1487. #define REISERFS_SYNC_FL FS_SYNC_FL
  1488. #define REISERFS_NOATIME_FL FS_NOATIME_FL
  1489. #define REISERFS_NODUMP_FL FS_NODUMP_FL
  1490. #define REISERFS_SECRM_FL FS_SECRM_FL
  1491. #define REISERFS_UNRM_FL FS_UNRM_FL
  1492. #define REISERFS_COMPR_FL FS_COMPR_FL
  1493. #define REISERFS_NOTAIL_FL FS_NOTAIL_FL
  1494. /* persistent flags that file inherits from the parent directory */
  1495. #define REISERFS_INHERIT_MASK ( REISERFS_IMMUTABLE_FL | \
  1496. REISERFS_SYNC_FL | \
  1497. REISERFS_NOATIME_FL | \
  1498. REISERFS_NODUMP_FL | \
  1499. REISERFS_SECRM_FL | \
  1500. REISERFS_COMPR_FL | \
  1501. REISERFS_NOTAIL_FL )
  1502. /*
  1503. * Stat Data on disk (reiserfs version of UFS disk inode minus the
  1504. * address blocks)
  1505. */
  1506. struct stat_data {
  1507. __le16 sd_mode; /* file type, permissions */
  1508. __le16 sd_attrs; /* persistent inode flags */
  1509. __le32 sd_nlink; /* number of hard links */
  1510. __le64 sd_size; /* file size */
  1511. __le32 sd_uid; /* owner */
  1512. __le32 sd_gid; /* group */
  1513. __le32 sd_atime; /* time of last access */
  1514. __le32 sd_mtime; /* time file was last modified */
  1515. /*
  1516. * time inode (stat data) was last changed
  1517. * (except changes to sd_atime and sd_mtime)
  1518. */
  1519. __le32 sd_ctime;
  1520. __le32 sd_blocks;
  1521. union {
  1522. __le32 sd_rdev;
  1523. __le32 sd_generation;
  1524. } __attribute__ ((__packed__)) u;
  1525. } __attribute__ ((__packed__));
  1526. /* this is 44 bytes long */
  1527. #define SD_SIZE (sizeof(struct stat_data))
  1528. #define SD_V2_SIZE SD_SIZE
  1529. #define stat_data_v2(ih) (ih_version (ih) == KEY_FORMAT_3_6)
  1530. #define sd_v2_mode(sdp) (le16_to_cpu((sdp)->sd_mode))
  1531. #define set_sd_v2_mode(sdp,v) ((sdp)->sd_mode = cpu_to_le16(v))
  1532. /* sd_reserved */
  1533. /* set_sd_reserved */
  1534. #define sd_v2_nlink(sdp) (le32_to_cpu((sdp)->sd_nlink))
  1535. #define set_sd_v2_nlink(sdp,v) ((sdp)->sd_nlink = cpu_to_le32(v))
  1536. #define sd_v2_size(sdp) (le64_to_cpu((sdp)->sd_size))
  1537. #define set_sd_v2_size(sdp,v) ((sdp)->sd_size = cpu_to_le64(v))
  1538. #define sd_v2_uid(sdp) (le32_to_cpu((sdp)->sd_uid))
  1539. #define set_sd_v2_uid(sdp,v) ((sdp)->sd_uid = cpu_to_le32(v))
  1540. #define sd_v2_gid(sdp) (le32_to_cpu((sdp)->sd_gid))
  1541. #define set_sd_v2_gid(sdp,v) ((sdp)->sd_gid = cpu_to_le32(v))
  1542. #define sd_v2_atime(sdp) (le32_to_cpu((sdp)->sd_atime))
  1543. #define set_sd_v2_atime(sdp,v) ((sdp)->sd_atime = cpu_to_le32(v))
  1544. #define sd_v2_mtime(sdp) (le32_to_cpu((sdp)->sd_mtime))
  1545. #define set_sd_v2_mtime(sdp,v) ((sdp)->sd_mtime = cpu_to_le32(v))
  1546. #define sd_v2_ctime(sdp) (le32_to_cpu((sdp)->sd_ctime))
  1547. #define set_sd_v2_ctime(sdp,v) ((sdp)->sd_ctime = cpu_to_le32(v))
  1548. #define sd_v2_blocks(sdp) (le32_to_cpu((sdp)->sd_blocks))
  1549. #define set_sd_v2_blocks(sdp,v) ((sdp)->sd_blocks = cpu_to_le32(v))
  1550. #define sd_v2_rdev(sdp) (le32_to_cpu((sdp)->u.sd_rdev))
  1551. #define set_sd_v2_rdev(sdp,v) ((sdp)->u.sd_rdev = cpu_to_le32(v))
  1552. #define sd_v2_generation(sdp) (le32_to_cpu((sdp)->u.sd_generation))
  1553. #define set_sd_v2_generation(sdp,v) ((sdp)->u.sd_generation = cpu_to_le32(v))
  1554. #define sd_v2_attrs(sdp) (le16_to_cpu((sdp)->sd_attrs))
  1555. #define set_sd_v2_attrs(sdp,v) ((sdp)->sd_attrs = cpu_to_le16(v))
  1556. /***************************************************************************
  1557. * DIRECTORY STRUCTURE *
  1558. ***************************************************************************/
  1559. /*
  1560. * Picture represents the structure of directory items
  1561. * ________________________________________________
  1562. * | Array of | | | | | |
  1563. * | directory |N-1| N-2 | .... | 1st |0th|
  1564. * | entry headers | | | | | |
  1565. * |_______________|___|_____|________|_______|___|
  1566. * <---- directory entries ------>
  1567. *
  1568. * First directory item has k_offset component 1. We store "." and ".."
  1569. * in one item, always, we never split "." and ".." into differing
  1570. * items. This makes, among other things, the code for removing
  1571. * directories simpler.
  1572. */
  1573. #define SD_OFFSET 0
  1574. #define SD_UNIQUENESS 0
  1575. #define DOT_OFFSET 1
  1576. #define DOT_DOT_OFFSET 2
  1577. #define DIRENTRY_UNIQUENESS 500
  1578. #define FIRST_ITEM_OFFSET 1
  1579. /*
  1580. * Q: How to get key of object pointed to by entry from entry?
  1581. *
  1582. * A: Each directory entry has its header. This header has deh_dir_id
  1583. * and deh_objectid fields, those are key of object, entry points to
  1584. */
  1585. /*
  1586. * NOT IMPLEMENTED:
  1587. * Directory will someday contain stat data of object
  1588. */
  1589. struct reiserfs_de_head {
  1590. __le32 deh_offset; /* third component of the directory entry key */
  1591. /*
  1592. * objectid of the parent directory of the object, that is referenced
  1593. * by directory entry
  1594. */
  1595. __le32 deh_dir_id;
  1596. /* objectid of the object, that is referenced by directory entry */
  1597. __le32 deh_objectid;
  1598. __le16 deh_location; /* offset of name in the whole item */
  1599. /*
  1600. * whether 1) entry contains stat data (for future), and
  1601. * 2) whether entry is hidden (unlinked)
  1602. */
  1603. __le16 deh_state;
  1604. } __attribute__ ((__packed__));
  1605. #define DEH_SIZE sizeof(struct reiserfs_de_head)
  1606. #define deh_offset(p_deh) (le32_to_cpu((p_deh)->deh_offset))
  1607. #define deh_dir_id(p_deh) (le32_to_cpu((p_deh)->deh_dir_id))
  1608. #define deh_objectid(p_deh) (le32_to_cpu((p_deh)->deh_objectid))
  1609. #define deh_location(p_deh) (le16_to_cpu((p_deh)->deh_location))
  1610. #define deh_state(p_deh) (le16_to_cpu((p_deh)->deh_state))
  1611. #define put_deh_offset(p_deh,v) ((p_deh)->deh_offset = cpu_to_le32((v)))
  1612. #define put_deh_dir_id(p_deh,v) ((p_deh)->deh_dir_id = cpu_to_le32((v)))
  1613. #define put_deh_objectid(p_deh,v) ((p_deh)->deh_objectid = cpu_to_le32((v)))
  1614. #define put_deh_location(p_deh,v) ((p_deh)->deh_location = cpu_to_le16((v)))
  1615. #define put_deh_state(p_deh,v) ((p_deh)->deh_state = cpu_to_le16((v)))
  1616. /* empty directory contains two entries "." and ".." and their headers */
  1617. #define EMPTY_DIR_SIZE \
  1618. (DEH_SIZE * 2 + ROUND_UP (sizeof(".") - 1) + ROUND_UP (sizeof("..") - 1))
  1619. /* old format directories have this size when empty */
  1620. #define EMPTY_DIR_SIZE_V1 (DEH_SIZE * 2 + 3)
  1621. #define DEH_Statdata 0 /* not used now */
  1622. #define DEH_Visible 2
  1623. /* 64 bit systems (and the S/390) need to be aligned explicitly -jdm */
  1624. #if BITS_PER_LONG == 64 || defined(__s390__) || defined(__hppa__)
  1625. # define ADDR_UNALIGNED_BITS (3)
  1626. #endif
  1627. /*
  1628. * These are only used to manipulate deh_state.
  1629. * Because of this, we'll use the ext2_ bit routines,
  1630. * since they are little endian
  1631. */
  1632. #ifdef ADDR_UNALIGNED_BITS
  1633. # define aligned_address(addr) ((void *)((long)(addr) & ~((1UL << ADDR_UNALIGNED_BITS) - 1)))
  1634. # define unaligned_offset(addr) (((int)((long)(addr) & ((1 << ADDR_UNALIGNED_BITS) - 1))) << 3)
  1635. # define set_bit_unaligned(nr, addr) \
  1636. __test_and_set_bit_le((nr) + unaligned_offset(addr), aligned_address(addr))
  1637. # define clear_bit_unaligned(nr, addr) \
  1638. __test_and_clear_bit_le((nr) + unaligned_offset(addr), aligned_address(addr))
  1639. # define test_bit_unaligned(nr, addr) \
  1640. test_bit_le((nr) + unaligned_offset(addr), aligned_address(addr))
  1641. #else
  1642. # define set_bit_unaligned(nr, addr) __test_and_set_bit_le(nr, addr)
  1643. # define clear_bit_unaligned(nr, addr) __test_and_clear_bit_le(nr, addr)
  1644. # define test_bit_unaligned(nr, addr) test_bit_le(nr, addr)
  1645. #endif
  1646. #define mark_de_with_sd(deh) set_bit_unaligned (DEH_Statdata, &((deh)->deh_state))
  1647. #define mark_de_without_sd(deh) clear_bit_unaligned (DEH_Statdata, &((deh)->deh_state))
  1648. #define mark_de_visible(deh) set_bit_unaligned (DEH_Visible, &((deh)->deh_state))
  1649. #define mark_de_hidden(deh) clear_bit_unaligned (DEH_Visible, &((deh)->deh_state))
  1650. #define de_with_sd(deh) test_bit_unaligned (DEH_Statdata, &((deh)->deh_state))
  1651. #define de_visible(deh) test_bit_unaligned (DEH_Visible, &((deh)->deh_state))
  1652. #define de_hidden(deh) !test_bit_unaligned (DEH_Visible, &((deh)->deh_state))
  1653. extern void make_empty_dir_item_v1(char *body, __le32 dirid, __le32 objid,
  1654. __le32 par_dirid, __le32 par_objid);
  1655. extern void make_empty_dir_item(char *body, __le32 dirid, __le32 objid,
  1656. __le32 par_dirid, __le32 par_objid);
  1657. /* two entries per block (at least) */
  1658. #define REISERFS_MAX_NAME(block_size) 255
  1659. /*
  1660. * this structure is used for operations on directory entries. It is
  1661. * not a disk structure.
  1662. *
  1663. * When reiserfs_find_entry or search_by_entry_key find directory
  1664. * entry, they return filled reiserfs_dir_entry structure
  1665. */
  1666. struct reiserfs_dir_entry {
  1667. struct buffer_head *de_bh;
  1668. int de_item_num;
  1669. struct item_head *de_ih;
  1670. int de_entry_num;
  1671. struct reiserfs_de_head *de_deh;
  1672. int de_entrylen;
  1673. int de_namelen;
  1674. char *de_name;
  1675. unsigned long *de_gen_number_bit_string;
  1676. __u32 de_dir_id;
  1677. __u32 de_objectid;
  1678. struct cpu_key de_entry_key;
  1679. };
  1680. /*
  1681. * these defines are useful when a particular member of
  1682. * a reiserfs_dir_entry is needed
  1683. */
  1684. /* pointer to file name, stored in entry */
  1685. #define B_I_DEH_ENTRY_FILE_NAME(bh, ih, deh) \
  1686. (ih_item_body(bh, ih) + deh_location(deh))
  1687. /* length of name */
  1688. #define I_DEH_N_ENTRY_FILE_NAME_LENGTH(ih,deh,entry_num) \
  1689. (I_DEH_N_ENTRY_LENGTH (ih, deh, entry_num) - (de_with_sd (deh) ? SD_SIZE : 0))
  1690. /* hash value occupies bits from 7 up to 30 */
  1691. #define GET_HASH_VALUE(offset) ((offset) & 0x7fffff80LL)
  1692. /* generation number occupies 7 bits starting from 0 up to 6 */
  1693. #define GET_GENERATION_NUMBER(offset) ((offset) & 0x7fLL)
  1694. #define MAX_GENERATION_NUMBER 127
  1695. #define SET_GENERATION_NUMBER(offset,gen_number) (GET_HASH_VALUE(offset)|(gen_number))
  1696. /*
  1697. * Picture represents an internal node of the reiserfs tree
  1698. * ______________________________________________________
  1699. * | | Array of | Array of | Free |
  1700. * |block | keys | pointers | space |
  1701. * | head | N | N+1 | |
  1702. * |______|_______________|___________________|___________|
  1703. */
  1704. /***************************************************************************
  1705. * DISK CHILD *
  1706. ***************************************************************************/
  1707. /*
  1708. * Disk child pointer:
  1709. * The pointer from an internal node of the tree to a node that is on disk.
  1710. */
  1711. struct disk_child {
  1712. __le32 dc_block_number; /* Disk child's block number. */
  1713. __le16 dc_size; /* Disk child's used space. */
  1714. __le16 dc_reserved;
  1715. };
  1716. #define DC_SIZE (sizeof(struct disk_child))
  1717. #define dc_block_number(dc_p) (le32_to_cpu((dc_p)->dc_block_number))
  1718. #define dc_size(dc_p) (le16_to_cpu((dc_p)->dc_size))
  1719. #define put_dc_block_number(dc_p, val) do { (dc_p)->dc_block_number = cpu_to_le32(val); } while(0)
  1720. #define put_dc_size(dc_p, val) do { (dc_p)->dc_size = cpu_to_le16(val); } while(0)
  1721. /* Get disk child by buffer header and position in the tree node. */
  1722. #define B_N_CHILD(bh, n_pos) ((struct disk_child *)\
  1723. ((bh)->b_data + BLKH_SIZE + B_NR_ITEMS(bh) * KEY_SIZE + DC_SIZE * (n_pos)))
  1724. /* Get disk child number by buffer header and position in the tree node. */
  1725. #define B_N_CHILD_NUM(bh, n_pos) (dc_block_number(B_N_CHILD(bh, n_pos)))
  1726. #define PUT_B_N_CHILD_NUM(bh, n_pos, val) \
  1727. (put_dc_block_number(B_N_CHILD(bh, n_pos), val))
  1728. /* maximal value of field child_size in structure disk_child */
  1729. /* child size is the combined size of all items and their headers */
  1730. #define MAX_CHILD_SIZE(bh) ((int)( (bh)->b_size - BLKH_SIZE ))
  1731. /* amount of used space in buffer (not including block head) */
  1732. #define B_CHILD_SIZE(cur) (MAX_CHILD_SIZE(cur)-(B_FREE_SPACE(cur)))
  1733. /* max and min number of keys in internal node */
  1734. #define MAX_NR_KEY(bh) ( (MAX_CHILD_SIZE(bh)-DC_SIZE)/(KEY_SIZE+DC_SIZE) )
  1735. #define MIN_NR_KEY(bh) (MAX_NR_KEY(bh)/2)
  1736. /***************************************************************************
  1737. * PATH STRUCTURES AND DEFINES *
  1738. ***************************************************************************/
  1739. /*
  1740. * search_by_key fills up the path from the root to the leaf as it descends
  1741. * the tree looking for the key. It uses reiserfs_bread to try to find
  1742. * buffers in the cache given their block number. If it does not find
  1743. * them in the cache it reads them from disk. For each node search_by_key
  1744. * finds using reiserfs_bread it then uses bin_search to look through that
  1745. * node. bin_search will find the position of the block_number of the next
  1746. * node if it is looking through an internal node. If it is looking through
  1747. * a leaf node bin_search will find the position of the item which has key
  1748. * either equal to given key, or which is the maximal key less than the
  1749. * given key.
  1750. */
  1751. struct path_element {
  1752. /* Pointer to the buffer at the path in the tree. */
  1753. struct buffer_head *pe_buffer;
  1754. /* Position in the tree node which is placed in the buffer above. */
  1755. int pe_position;
  1756. };
  1757. /*
  1758. * maximal height of a tree. don't change this without
  1759. * changing JOURNAL_PER_BALANCE_CNT
  1760. */
  1761. #define MAX_HEIGHT 5
  1762. /* Must be equals MAX_HEIGHT + FIRST_PATH_ELEMENT_OFFSET */
  1763. #define EXTENDED_MAX_HEIGHT 7
  1764. /* Must be equal to at least 2. */
  1765. #define FIRST_PATH_ELEMENT_OFFSET 2
  1766. /* Must be equal to FIRST_PATH_ELEMENT_OFFSET - 1 */
  1767. #define ILLEGAL_PATH_ELEMENT_OFFSET 1
  1768. /* this MUST be MAX_HEIGHT + 1. See about FEB below */
  1769. #define MAX_FEB_SIZE 6
  1770. /*
  1771. * We need to keep track of who the ancestors of nodes are. When we
  1772. * perform a search we record which nodes were visited while
  1773. * descending the tree looking for the node we searched for. This list
  1774. * of nodes is called the path. This information is used while
  1775. * performing balancing. Note that this path information may become
  1776. * invalid, and this means we must check it when using it to see if it
  1777. * is still valid. You'll need to read search_by_key and the comments
  1778. * in it, especially about decrement_counters_in_path(), to understand
  1779. * this structure.
  1780. *
  1781. * Paths make the code so much harder to work with and debug.... An
  1782. * enormous number of bugs are due to them, and trying to write or modify
  1783. * code that uses them just makes my head hurt. They are based on an
  1784. * excessive effort to avoid disturbing the precious VFS code.:-( The
  1785. * gods only know how we are going to SMP the code that uses them.
  1786. * znodes are the way!
  1787. */
  1788. #define PATH_READA 0x1 /* do read ahead */
  1789. #define PATH_READA_BACK 0x2 /* read backwards */
  1790. struct treepath {
  1791. int path_length; /* Length of the array above. */
  1792. int reada;
  1793. /* Array of the path elements. */
  1794. struct path_element path_elements[EXTENDED_MAX_HEIGHT];
  1795. int pos_in_item;
  1796. };
  1797. #define pos_in_item(path) ((path)->pos_in_item)
  1798. #define INITIALIZE_PATH(var) \
  1799. struct treepath var = {.path_length = ILLEGAL_PATH_ELEMENT_OFFSET, .reada = 0,}
  1800. /* Get path element by path and path position. */
  1801. #define PATH_OFFSET_PELEMENT(path, n_offset) ((path)->path_elements + (n_offset))
  1802. /* Get buffer header at the path by path and path position. */
  1803. #define PATH_OFFSET_PBUFFER(path, n_offset) (PATH_OFFSET_PELEMENT(path, n_offset)->pe_buffer)
  1804. /* Get position in the element at the path by path and path position. */
  1805. #define PATH_OFFSET_POSITION(path, n_offset) (PATH_OFFSET_PELEMENT(path, n_offset)->pe_position)
  1806. #define PATH_PLAST_BUFFER(path) (PATH_OFFSET_PBUFFER((path), (path)->path_length))
  1807. /*
  1808. * you know, to the person who didn't write this the macro name does not
  1809. * at first suggest what it does. Maybe POSITION_FROM_PATH_END? Or
  1810. * maybe we should just focus on dumping paths... -Hans
  1811. */
  1812. #define PATH_LAST_POSITION(path) (PATH_OFFSET_POSITION((path), (path)->path_length))
  1813. /*
  1814. * in do_balance leaf has h == 0 in contrast with path structure,
  1815. * where root has level == 0. That is why we need these defines
  1816. */
  1817. /* tb->S[h] */
  1818. #define PATH_H_PBUFFER(path, h) \
  1819. PATH_OFFSET_PBUFFER(path, path->path_length - (h))
  1820. /* tb->F[h] or tb->S[0]->b_parent */
  1821. #define PATH_H_PPARENT(path, h) PATH_H_PBUFFER(path, (h) + 1)
  1822. #define PATH_H_POSITION(path, h) \
  1823. PATH_OFFSET_POSITION(path, path->path_length - (h))
  1824. /* tb->S[h]->b_item_order */
  1825. #define PATH_H_B_ITEM_ORDER(path, h) PATH_H_POSITION(path, h + 1)
  1826. #define PATH_H_PATH_OFFSET(path, n_h) ((path)->path_length - (n_h))
  1827. static inline void *reiserfs_node_data(const struct buffer_head *bh)
  1828. {
  1829. return bh->b_data + sizeof(struct block_head);
  1830. }
  1831. /* get key from internal node */
  1832. static inline struct reiserfs_key *internal_key(struct buffer_head *bh,
  1833. int item_num)
  1834. {
  1835. struct reiserfs_key *key = reiserfs_node_data(bh);
  1836. return &key[item_num];
  1837. }
  1838. /* get the item header from leaf node */
  1839. static inline struct item_head *item_head(const struct buffer_head *bh,
  1840. int item_num)
  1841. {
  1842. struct item_head *ih = reiserfs_node_data(bh);
  1843. return &ih[item_num];
  1844. }
  1845. /* get the key from leaf node */
  1846. static inline struct reiserfs_key *leaf_key(const struct buffer_head *bh,
  1847. int item_num)
  1848. {
  1849. return &item_head(bh, item_num)->ih_key;
  1850. }
  1851. static inline void *ih_item_body(const struct buffer_head *bh,
  1852. const struct item_head *ih)
  1853. {
  1854. return bh->b_data + ih_location(ih);
  1855. }
  1856. /* get item body from leaf node */
  1857. static inline void *item_body(const struct buffer_head *bh, int item_num)
  1858. {
  1859. return ih_item_body(bh, item_head(bh, item_num));
  1860. }
  1861. static inline struct item_head *tp_item_head(const struct treepath *path)
  1862. {
  1863. return item_head(PATH_PLAST_BUFFER(path), PATH_LAST_POSITION(path));
  1864. }
  1865. static inline void *tp_item_body(const struct treepath *path)
  1866. {
  1867. return item_body(PATH_PLAST_BUFFER(path), PATH_LAST_POSITION(path));
  1868. }
  1869. #define get_last_bh(path) PATH_PLAST_BUFFER(path)
  1870. #define get_item_pos(path) PATH_LAST_POSITION(path)
  1871. #define item_moved(ih,path) comp_items(ih, path)
  1872. #define path_changed(ih,path) comp_items (ih, path)
  1873. /* array of the entry headers */
  1874. /* get item body */
  1875. #define B_I_DEH(bh, ih) ((struct reiserfs_de_head *)(ih_item_body(bh, ih)))
  1876. /*
  1877. * length of the directory entry in directory item. This define
  1878. * calculates length of i-th directory entry using directory entry
  1879. * locations from dir entry head. When it calculates length of 0-th
  1880. * directory entry, it uses length of whole item in place of entry
  1881. * location of the non-existent following entry in the calculation.
  1882. * See picture above.
  1883. */
  1884. static inline int entry_length(const struct buffer_head *bh,
  1885. const struct item_head *ih, int pos_in_item)
  1886. {
  1887. struct reiserfs_de_head *deh;
  1888. deh = B_I_DEH(bh, ih) + pos_in_item;
  1889. if (pos_in_item)
  1890. return deh_location(deh - 1) - deh_location(deh);
  1891. return ih_item_len(ih) - deh_location(deh);
  1892. }
  1893. /***************************************************************************
  1894. * MISC *
  1895. ***************************************************************************/
  1896. /* Size of pointer to the unformatted node. */
  1897. #define UNFM_P_SIZE (sizeof(unp_t))
  1898. #define UNFM_P_SHIFT 2
  1899. /* in in-core inode key is stored on le form */
  1900. #define INODE_PKEY(inode) ((struct reiserfs_key *)(REISERFS_I(inode)->i_key))
  1901. #define MAX_UL_INT 0xffffffff
  1902. #define MAX_INT 0x7ffffff
  1903. #define MAX_US_INT 0xffff
  1904. // reiserfs version 2 has max offset 60 bits. Version 1 - 32 bit offset
  1905. static inline loff_t max_reiserfs_offset(struct inode *inode)
  1906. {
  1907. if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5)
  1908. return (loff_t) U32_MAX;
  1909. return (loff_t) ((~(__u64) 0) >> 4);
  1910. }
  1911. #define MAX_KEY_OBJECTID MAX_UL_INT
  1912. #define MAX_B_NUM MAX_UL_INT
  1913. #define MAX_FC_NUM MAX_US_INT
  1914. /* the purpose is to detect overflow of an unsigned short */
  1915. #define REISERFS_LINK_MAX (MAX_US_INT - 1000)
  1916. /*
  1917. * The following defines are used in reiserfs_insert_item
  1918. * and reiserfs_append_item
  1919. */
  1920. #define REISERFS_KERNEL_MEM 0 /* kernel memory mode */
  1921. #define REISERFS_USER_MEM 1 /* user memory mode */
  1922. #define fs_generation(s) (REISERFS_SB(s)->s_generation_counter)
  1923. #define get_generation(s) atomic_read (&fs_generation(s))
  1924. #define FILESYSTEM_CHANGED_TB(tb) (get_generation((tb)->tb_sb) != (tb)->fs_gen)
  1925. #define __fs_changed(gen,s) (gen != get_generation (s))
  1926. #define fs_changed(gen,s) \
  1927. ({ \
  1928. reiserfs_cond_resched(s); \
  1929. __fs_changed(gen, s); \
  1930. })
  1931. /***************************************************************************
  1932. * FIXATE NODES *
  1933. ***************************************************************************/
  1934. #define VI_TYPE_LEFT_MERGEABLE 1
  1935. #define VI_TYPE_RIGHT_MERGEABLE 2
  1936. /*
  1937. * To make any changes in the tree we always first find node, that
  1938. * contains item to be changed/deleted or place to insert a new
  1939. * item. We call this node S. To do balancing we need to decide what
  1940. * we will shift to left/right neighbor, or to a new node, where new
  1941. * item will be etc. To make this analysis simpler we build virtual
  1942. * node. Virtual node is an array of items, that will replace items of
  1943. * node S. (For instance if we are going to delete an item, virtual
  1944. * node does not contain it). Virtual node keeps information about
  1945. * item sizes and types, mergeability of first and last items, sizes
  1946. * of all entries in directory item. We use this array of items when
  1947. * calculating what we can shift to neighbors and how many nodes we
  1948. * have to have if we do not any shiftings, if we shift to left/right
  1949. * neighbor or to both.
  1950. */
  1951. struct virtual_item {
  1952. int vi_index; /* index in the array of item operations */
  1953. unsigned short vi_type; /* left/right mergeability */
  1954. /* length of item that it will have after balancing */
  1955. unsigned short vi_item_len;
  1956. struct item_head *vi_ih;
  1957. const char *vi_item; /* body of item (old or new) */
  1958. const void *vi_new_data; /* 0 always but paste mode */
  1959. void *vi_uarea; /* item specific area */
  1960. };
  1961. struct virtual_node {
  1962. /* this is a pointer to the free space in the buffer */
  1963. char *vn_free_ptr;
  1964. unsigned short vn_nr_item; /* number of items in virtual node */
  1965. /*
  1966. * size of node , that node would have if it has
  1967. * unlimited size and no balancing is performed
  1968. */
  1969. short vn_size;
  1970. /* mode of balancing (paste, insert, delete, cut) */
  1971. short vn_mode;
  1972. short vn_affected_item_num;
  1973. short vn_pos_in_item;
  1974. /* item header of inserted item, 0 for other modes */
  1975. struct item_head *vn_ins_ih;
  1976. const void *vn_data;
  1977. /* array of items (including a new one, excluding item to be deleted) */
  1978. struct virtual_item *vn_vi;
  1979. };
  1980. /* used by directory items when creating virtual nodes */
  1981. struct direntry_uarea {
  1982. int flags;
  1983. __u16 entry_count;
  1984. __u16 entry_sizes[1];
  1985. } __attribute__ ((__packed__));
  1986. /***************************************************************************
  1987. * TREE BALANCE *
  1988. ***************************************************************************/
  1989. /*
  1990. * This temporary structure is used in tree balance algorithms, and
  1991. * constructed as we go to the extent that its various parts are
  1992. * needed. It contains arrays of nodes that can potentially be
  1993. * involved in the balancing of node S, and parameters that define how
  1994. * each of the nodes must be balanced. Note that in these algorithms
  1995. * for balancing the worst case is to need to balance the current node
  1996. * S and the left and right neighbors and all of their parents plus
  1997. * create a new node. We implement S1 balancing for the leaf nodes
  1998. * and S0 balancing for the internal nodes (S1 and S0 are defined in
  1999. * our papers.)
  2000. */
  2001. /* size of the array of buffers to free at end of do_balance */
  2002. #define MAX_FREE_BLOCK 7
  2003. /* maximum number of FEB blocknrs on a single level */
  2004. #define MAX_AMOUNT_NEEDED 2
  2005. /* someday somebody will prefix every field in this struct with tb_ */
  2006. struct tree_balance {
  2007. int tb_mode;
  2008. int need_balance_dirty;
  2009. struct super_block *tb_sb;
  2010. struct reiserfs_transaction_handle *transaction_handle;
  2011. struct treepath *tb_path;
  2012. /* array of left neighbors of nodes in the path */
  2013. struct buffer_head *L[MAX_HEIGHT];
  2014. /* array of right neighbors of nodes in the path */
  2015. struct buffer_head *R[MAX_HEIGHT];
  2016. /* array of fathers of the left neighbors */
  2017. struct buffer_head *FL[MAX_HEIGHT];
  2018. /* array of fathers of the right neighbors */
  2019. struct buffer_head *FR[MAX_HEIGHT];
  2020. /* array of common parents of center node and its left neighbor */
  2021. struct buffer_head *CFL[MAX_HEIGHT];
  2022. /* array of common parents of center node and its right neighbor */
  2023. struct buffer_head *CFR[MAX_HEIGHT];
  2024. /*
  2025. * array of empty buffers. Number of buffers in array equals
  2026. * cur_blknum.
  2027. */
  2028. struct buffer_head *FEB[MAX_FEB_SIZE];
  2029. struct buffer_head *used[MAX_FEB_SIZE];
  2030. struct buffer_head *thrown[MAX_FEB_SIZE];
  2031. /*
  2032. * array of number of items which must be shifted to the left in
  2033. * order to balance the current node; for leaves includes item that
  2034. * will be partially shifted; for internal nodes, it is the number
  2035. * of child pointers rather than items. It includes the new item
  2036. * being created. The code sometimes subtracts one to get the
  2037. * number of wholly shifted items for other purposes.
  2038. */
  2039. int lnum[MAX_HEIGHT];
  2040. /* substitute right for left in comment above */
  2041. int rnum[MAX_HEIGHT];
  2042. /*
  2043. * array indexed by height h mapping the key delimiting L[h] and
  2044. * S[h] to its item number within the node CFL[h]
  2045. */
  2046. int lkey[MAX_HEIGHT];
  2047. /* substitute r for l in comment above */
  2048. int rkey[MAX_HEIGHT];
  2049. /*
  2050. * the number of bytes by we are trying to add or remove from
  2051. * S[h]. A negative value means removing.
  2052. */
  2053. int insert_size[MAX_HEIGHT];
  2054. /*
  2055. * number of nodes that will replace node S[h] after balancing
  2056. * on the level h of the tree. If 0 then S is being deleted,
  2057. * if 1 then S is remaining and no new nodes are being created,
  2058. * if 2 or 3 then 1 or 2 new nodes is being created
  2059. */
  2060. int blknum[MAX_HEIGHT];
  2061. /* fields that are used only for balancing leaves of the tree */
  2062. /* number of empty blocks having been already allocated */
  2063. int cur_blknum;
  2064. /* number of items that fall into left most node when S[0] splits */
  2065. int s0num;
  2066. /*
  2067. * number of bytes which can flow to the left neighbor from the left
  2068. * most liquid item that cannot be shifted from S[0] entirely
  2069. * if -1 then nothing will be partially shifted
  2070. */
  2071. int lbytes;
  2072. /*
  2073. * number of bytes which will flow to the right neighbor from the right
  2074. * most liquid item that cannot be shifted from S[0] entirely
  2075. * if -1 then nothing will be partially shifted
  2076. */
  2077. int rbytes;
  2078. /*
  2079. * index into the array of item headers in
  2080. * S[0] of the affected item
  2081. */
  2082. int item_pos;
  2083. /* new nodes allocated to hold what could not fit into S */
  2084. struct buffer_head *S_new[2];
  2085. /*
  2086. * number of items that will be placed into nodes in S_new
  2087. * when S[0] splits
  2088. */
  2089. int snum[2];
  2090. /*
  2091. * number of bytes which flow to nodes in S_new when S[0] splits
  2092. * note: if S[0] splits into 3 nodes, then items do not need to be cut
  2093. */
  2094. int sbytes[2];
  2095. int pos_in_item;
  2096. int zeroes_num;
  2097. /*
  2098. * buffers which are to be freed after do_balance finishes
  2099. * by unfix_nodes
  2100. */
  2101. struct buffer_head *buf_to_free[MAX_FREE_BLOCK];
  2102. /*
  2103. * kmalloced memory. Used to create virtual node and keep
  2104. * map of dirtied bitmap blocks
  2105. */
  2106. char *vn_buf;
  2107. int vn_buf_size; /* size of the vn_buf */
  2108. /* VN starts after bitmap of bitmap blocks */
  2109. struct virtual_node *tb_vn;
  2110. /*
  2111. * saved value of `reiserfs_generation' counter see
  2112. * FILESYSTEM_CHANGED() macro in reiserfs_fs.h
  2113. */
  2114. int fs_gen;
  2115. #ifdef DISPLACE_NEW_PACKING_LOCALITIES
  2116. /*
  2117. * key pointer, to pass to block allocator or
  2118. * another low-level subsystem
  2119. */
  2120. struct in_core_key key;
  2121. #endif
  2122. };
  2123. /* These are modes of balancing */
  2124. /* When inserting an item. */
  2125. #define M_INSERT 'i'
  2126. /*
  2127. * When inserting into (directories only) or appending onto an already
  2128. * existent item.
  2129. */
  2130. #define M_PASTE 'p'
  2131. /* When deleting an item. */
  2132. #define M_DELETE 'd'
  2133. /* When truncating an item or removing an entry from a (directory) item. */
  2134. #define M_CUT 'c'
  2135. /* used when balancing on leaf level skipped (in reiserfsck) */
  2136. #define M_INTERNAL 'n'
  2137. /*
  2138. * When further balancing is not needed, then do_balance does not need
  2139. * to be called.
  2140. */
  2141. #define M_SKIP_BALANCING 's'
  2142. #define M_CONVERT 'v'
  2143. /* modes of leaf_move_items */
  2144. #define LEAF_FROM_S_TO_L 0
  2145. #define LEAF_FROM_S_TO_R 1
  2146. #define LEAF_FROM_R_TO_L 2
  2147. #define LEAF_FROM_L_TO_R 3
  2148. #define LEAF_FROM_S_TO_SNEW 4
  2149. #define FIRST_TO_LAST 0
  2150. #define LAST_TO_FIRST 1
  2151. /*
  2152. * used in do_balance for passing parent of node information that has
  2153. * been gotten from tb struct
  2154. */
  2155. struct buffer_info {
  2156. struct tree_balance *tb;
  2157. struct buffer_head *bi_bh;
  2158. struct buffer_head *bi_parent;
  2159. int bi_position;
  2160. };
  2161. static inline struct super_block *sb_from_tb(struct tree_balance *tb)
  2162. {
  2163. return tb ? tb->tb_sb : NULL;
  2164. }
  2165. static inline struct super_block *sb_from_bi(struct buffer_info *bi)
  2166. {
  2167. return bi ? sb_from_tb(bi->tb) : NULL;
  2168. }
  2169. /*
  2170. * there are 4 types of items: stat data, directory item, indirect, direct.
  2171. * +-------------------+------------+--------------+------------+
  2172. * | | k_offset | k_uniqueness | mergeable? |
  2173. * +-------------------+------------+--------------+------------+
  2174. * | stat data | 0 | 0 | no |
  2175. * +-------------------+------------+--------------+------------+
  2176. * | 1st directory item| DOT_OFFSET | DIRENTRY_ .. | no |
  2177. * | non 1st directory | hash value | UNIQUENESS | yes |
  2178. * | item | | | |
  2179. * +-------------------+------------+--------------+------------+
  2180. * | indirect item | offset + 1 |TYPE_INDIRECT | [1] |
  2181. * +-------------------+------------+--------------+------------+
  2182. * | direct item | offset + 1 |TYPE_DIRECT | [2] |
  2183. * +-------------------+------------+--------------+------------+
  2184. *
  2185. * [1] if this is not the first indirect item of the object
  2186. * [2] if this is not the first direct item of the object
  2187. */
  2188. struct item_operations {
  2189. int (*bytes_number) (struct item_head * ih, int block_size);
  2190. void (*decrement_key) (struct cpu_key *);
  2191. int (*is_left_mergeable) (struct reiserfs_key * ih,
  2192. unsigned long bsize);
  2193. void (*print_item) (struct item_head *, char *item);
  2194. void (*check_item) (struct item_head *, char *item);
  2195. int (*create_vi) (struct virtual_node * vn, struct virtual_item * vi,
  2196. int is_affected, int insert_size);
  2197. int (*check_left) (struct virtual_item * vi, int free,
  2198. int start_skip, int end_skip);
  2199. int (*check_right) (struct virtual_item * vi, int free);
  2200. int (*part_size) (struct virtual_item * vi, int from, int to);
  2201. int (*unit_num) (struct virtual_item * vi);
  2202. void (*print_vi) (struct virtual_item * vi);
  2203. };
  2204. extern struct item_operations *item_ops[TYPE_ANY + 1];
  2205. #define op_bytes_number(ih,bsize) item_ops[le_ih_k_type (ih)]->bytes_number (ih, bsize)
  2206. #define op_is_left_mergeable(key,bsize) item_ops[le_key_k_type (le_key_version (key), key)]->is_left_mergeable (key, bsize)
  2207. #define op_print_item(ih,item) item_ops[le_ih_k_type (ih)]->print_item (ih, item)
  2208. #define op_check_item(ih,item) item_ops[le_ih_k_type (ih)]->check_item (ih, item)
  2209. #define op_create_vi(vn,vi,is_affected,insert_size) item_ops[le_ih_k_type ((vi)->vi_ih)]->create_vi (vn,vi,is_affected,insert_size)
  2210. #define op_check_left(vi,free,start_skip,end_skip) item_ops[(vi)->vi_index]->check_left (vi, free, start_skip, end_skip)
  2211. #define op_check_right(vi,free) item_ops[(vi)->vi_index]->check_right (vi, free)
  2212. #define op_part_size(vi,from,to) item_ops[(vi)->vi_index]->part_size (vi, from, to)
  2213. #define op_unit_num(vi) item_ops[(vi)->vi_index]->unit_num (vi)
  2214. #define op_print_vi(vi) item_ops[(vi)->vi_index]->print_vi (vi)
  2215. #define COMP_SHORT_KEYS comp_short_keys
  2216. /* number of blocks pointed to by the indirect item */
  2217. #define I_UNFM_NUM(ih) (ih_item_len(ih) / UNFM_P_SIZE)
  2218. /*
  2219. * the used space within the unformatted node corresponding
  2220. * to pos within the item pointed to by ih
  2221. */
  2222. #define I_POS_UNFM_SIZE(ih,pos,size) (((pos) == I_UNFM_NUM(ih) - 1 ) ? (size) - ih_free_space(ih) : (size))
  2223. /*
  2224. * number of bytes contained by the direct item or the
  2225. * unformatted nodes the indirect item points to
  2226. */
  2227. /* following defines use reiserfs buffer header and item header */
  2228. /* get stat-data */
  2229. #define B_I_STAT_DATA(bh, ih) ( (struct stat_data * )((bh)->b_data + ih_location(ih)) )
  2230. /* this is 3976 for size==4096 */
  2231. #define MAX_DIRECT_ITEM_LEN(size) ((size) - BLKH_SIZE - 2*IH_SIZE - SD_SIZE - UNFM_P_SIZE)
  2232. /*
  2233. * indirect items consist of entries which contain blocknrs, pos
  2234. * indicates which entry, and B_I_POS_UNFM_POINTER resolves to the
  2235. * blocknr contained by the entry pos points to
  2236. */
  2237. #define B_I_POS_UNFM_POINTER(bh, ih, pos) \
  2238. le32_to_cpu(*(((unp_t *)ih_item_body(bh, ih)) + (pos)))
  2239. #define PUT_B_I_POS_UNFM_POINTER(bh, ih, pos, val) \
  2240. (*(((unp_t *)ih_item_body(bh, ih)) + (pos)) = cpu_to_le32(val))
  2241. struct reiserfs_iget_args {
  2242. __u32 objectid;
  2243. __u32 dirid;
  2244. };
  2245. /***************************************************************************
  2246. * FUNCTION DECLARATIONS *
  2247. ***************************************************************************/
  2248. #define get_journal_desc_magic(bh) (bh->b_data + bh->b_size - 12)
  2249. #define journal_trans_half(blocksize) \
  2250. ((blocksize - sizeof (struct reiserfs_journal_desc) + sizeof (__u32) - 12) / sizeof (__u32))
  2251. /* journal.c see journal.c for all the comments here */
  2252. /* first block written in a commit. */
  2253. struct reiserfs_journal_desc {
  2254. __le32 j_trans_id; /* id of commit */
  2255. /* length of commit. len +1 is the commit block */
  2256. __le32 j_len;
  2257. __le32 j_mount_id; /* mount id of this trans */
  2258. __le32 j_realblock[1]; /* real locations for each block */
  2259. };
  2260. #define get_desc_trans_id(d) le32_to_cpu((d)->j_trans_id)
  2261. #define get_desc_trans_len(d) le32_to_cpu((d)->j_len)
  2262. #define get_desc_mount_id(d) le32_to_cpu((d)->j_mount_id)
  2263. #define set_desc_trans_id(d,val) do { (d)->j_trans_id = cpu_to_le32 (val); } while (0)
  2264. #define set_desc_trans_len(d,val) do { (d)->j_len = cpu_to_le32 (val); } while (0)
  2265. #define set_desc_mount_id(d,val) do { (d)->j_mount_id = cpu_to_le32 (val); } while (0)
  2266. /* last block written in a commit */
  2267. struct reiserfs_journal_commit {
  2268. __le32 j_trans_id; /* must match j_trans_id from the desc block */
  2269. __le32 j_len; /* ditto */
  2270. __le32 j_realblock[1]; /* real locations for each block */
  2271. };
  2272. #define get_commit_trans_id(c) le32_to_cpu((c)->j_trans_id)
  2273. #define get_commit_trans_len(c) le32_to_cpu((c)->j_len)
  2274. #define get_commit_mount_id(c) le32_to_cpu((c)->j_mount_id)
  2275. #define set_commit_trans_id(c,val) do { (c)->j_trans_id = cpu_to_le32 (val); } while (0)
  2276. #define set_commit_trans_len(c,val) do { (c)->j_len = cpu_to_le32 (val); } while (0)
  2277. /*
  2278. * this header block gets written whenever a transaction is considered
  2279. * fully flushed, and is more recent than the last fully flushed transaction.
  2280. * fully flushed means all the log blocks and all the real blocks are on
  2281. * disk, and this transaction does not need to be replayed.
  2282. */
  2283. struct reiserfs_journal_header {
  2284. /* id of last fully flushed transaction */
  2285. __le32 j_last_flush_trans_id;
  2286. /* offset in the log of where to start replay after a crash */
  2287. __le32 j_first_unflushed_offset;
  2288. __le32 j_mount_id;
  2289. /* 12 */ struct journal_params jh_journal;
  2290. };
  2291. /* biggest tunable defines are right here */
  2292. #define JOURNAL_BLOCK_COUNT 8192 /* number of blocks in the journal */
  2293. /* biggest possible single transaction, don't change for now (8/3/99) */
  2294. #define JOURNAL_TRANS_MAX_DEFAULT 1024
  2295. #define JOURNAL_TRANS_MIN_DEFAULT 256
  2296. /*
  2297. * max blocks to batch into one transaction,
  2298. * don't make this any bigger than 900
  2299. */
  2300. #define JOURNAL_MAX_BATCH_DEFAULT 900
  2301. #define JOURNAL_MIN_RATIO 2
  2302. #define JOURNAL_MAX_COMMIT_AGE 30
  2303. #define JOURNAL_MAX_TRANS_AGE 30
  2304. #define JOURNAL_PER_BALANCE_CNT (3 * (MAX_HEIGHT-2) + 9)
  2305. #define JOURNAL_BLOCKS_PER_OBJECT(sb) (JOURNAL_PER_BALANCE_CNT * 3 + \
  2306. 2 * (REISERFS_QUOTA_INIT_BLOCKS(sb) + \
  2307. REISERFS_QUOTA_TRANS_BLOCKS(sb)))
  2308. #ifdef CONFIG_QUOTA
  2309. #define REISERFS_QUOTA_OPTS ((1 << REISERFS_USRQUOTA) | (1 << REISERFS_GRPQUOTA))
  2310. /* We need to update data and inode (atime) */
  2311. #define REISERFS_QUOTA_TRANS_BLOCKS(s) (REISERFS_SB(s)->s_mount_opt & REISERFS_QUOTA_OPTS ? 2 : 0)
  2312. /* 1 balancing, 1 bitmap, 1 data per write + stat data update */
  2313. #define REISERFS_QUOTA_INIT_BLOCKS(s) (REISERFS_SB(s)->s_mount_opt & REISERFS_QUOTA_OPTS ? \
  2314. (DQUOT_INIT_ALLOC*(JOURNAL_PER_BALANCE_CNT+2)+DQUOT_INIT_REWRITE+1) : 0)
  2315. /* same as with INIT */
  2316. #define REISERFS_QUOTA_DEL_BLOCKS(s) (REISERFS_SB(s)->s_mount_opt & REISERFS_QUOTA_OPTS ? \
  2317. (DQUOT_DEL_ALLOC*(JOURNAL_PER_BALANCE_CNT+2)+DQUOT_DEL_REWRITE+1) : 0)
  2318. #else
  2319. #define REISERFS_QUOTA_TRANS_BLOCKS(s) 0
  2320. #define REISERFS_QUOTA_INIT_BLOCKS(s) 0
  2321. #define REISERFS_QUOTA_DEL_BLOCKS(s) 0
  2322. #endif
  2323. /*
  2324. * both of these can be as low as 1, or as high as you want. The min is the
  2325. * number of 4k bitmap nodes preallocated on mount. New nodes are allocated
  2326. * as needed, and released when transactions are committed. On release, if
  2327. * the current number of nodes is > max, the node is freed, otherwise,
  2328. * it is put on a free list for faster use later.
  2329. */
  2330. #define REISERFS_MIN_BITMAP_NODES 10
  2331. #define REISERFS_MAX_BITMAP_NODES 100
  2332. /* these are based on journal hash size of 8192 */
  2333. #define JBH_HASH_SHIFT 13
  2334. #define JBH_HASH_MASK 8191
  2335. #define _jhashfn(sb,block) \
  2336. (((unsigned long)sb>>L1_CACHE_SHIFT) ^ \
  2337. (((block)<<(JBH_HASH_SHIFT - 6)) ^ ((block) >> 13) ^ ((block) << (JBH_HASH_SHIFT - 12))))
  2338. #define journal_hash(t,sb,block) ((t)[_jhashfn((sb),(block)) & JBH_HASH_MASK])
  2339. /* We need these to make journal.c code more readable */
  2340. #define journal_find_get_block(s, block) __find_get_block(SB_JOURNAL(s)->j_dev_bd, block, s->s_blocksize)
  2341. #define journal_getblk(s, block) __getblk(SB_JOURNAL(s)->j_dev_bd, block, s->s_blocksize)
  2342. #define journal_bread(s, block) __bread(SB_JOURNAL(s)->j_dev_bd, block, s->s_blocksize)
  2343. enum reiserfs_bh_state_bits {
  2344. BH_JDirty = BH_PrivateStart, /* buffer is in current transaction */
  2345. BH_JDirty_wait,
  2346. /*
  2347. * disk block was taken off free list before being in a
  2348. * finished transaction, or written to disk. Can be reused immed.
  2349. */
  2350. BH_JNew,
  2351. BH_JPrepared,
  2352. BH_JRestore_dirty,
  2353. BH_JTest, /* debugging only will go away */
  2354. };
  2355. BUFFER_FNS(JDirty, journaled);
  2356. TAS_BUFFER_FNS(JDirty, journaled);
  2357. BUFFER_FNS(JDirty_wait, journal_dirty);
  2358. TAS_BUFFER_FNS(JDirty_wait, journal_dirty);
  2359. BUFFER_FNS(JNew, journal_new);
  2360. TAS_BUFFER_FNS(JNew, journal_new);
  2361. BUFFER_FNS(JPrepared, journal_prepared);
  2362. TAS_BUFFER_FNS(JPrepared, journal_prepared);
  2363. BUFFER_FNS(JRestore_dirty, journal_restore_dirty);
  2364. TAS_BUFFER_FNS(JRestore_dirty, journal_restore_dirty);
  2365. BUFFER_FNS(JTest, journal_test);
  2366. TAS_BUFFER_FNS(JTest, journal_test);
  2367. /* transaction handle which is passed around for all journal calls */
  2368. struct reiserfs_transaction_handle {
  2369. /*
  2370. * super for this FS when journal_begin was called. saves calls to
  2371. * reiserfs_get_super also used by nested transactions to make
  2372. * sure they are nesting on the right FS _must_ be first
  2373. * in the handle
  2374. */
  2375. struct super_block *t_super;
  2376. int t_refcount;
  2377. int t_blocks_logged; /* number of blocks this writer has logged */
  2378. int t_blocks_allocated; /* number of blocks this writer allocated */
  2379. /* sanity check, equals the current trans id */
  2380. unsigned int t_trans_id;
  2381. void *t_handle_save; /* save existing current->journal_info */
  2382. /*
  2383. * if new block allocation occurres, that block
  2384. * should be displaced from others
  2385. */
  2386. unsigned displace_new_blocks:1;
  2387. struct list_head t_list;
  2388. };
  2389. /*
  2390. * used to keep track of ordered and tail writes, attached to the buffer
  2391. * head through b_journal_head.
  2392. */
  2393. struct reiserfs_jh {
  2394. struct reiserfs_journal_list *jl;
  2395. struct buffer_head *bh;
  2396. struct list_head list;
  2397. };
  2398. void reiserfs_free_jh(struct buffer_head *bh);
  2399. int reiserfs_add_tail_list(struct inode *inode, struct buffer_head *bh);
  2400. int reiserfs_add_ordered_list(struct inode *inode, struct buffer_head *bh);
  2401. int journal_mark_dirty(struct reiserfs_transaction_handle *,
  2402. struct buffer_head *bh);
  2403. static inline int reiserfs_file_data_log(struct inode *inode)
  2404. {
  2405. if (reiserfs_data_log(inode->i_sb) ||
  2406. (REISERFS_I(inode)->i_flags & i_data_log))
  2407. return 1;
  2408. return 0;
  2409. }
  2410. static inline int reiserfs_transaction_running(struct super_block *s)
  2411. {
  2412. struct reiserfs_transaction_handle *th = current->journal_info;
  2413. if (th && th->t_super == s)
  2414. return 1;
  2415. if (th && th->t_super == NULL)
  2416. BUG();
  2417. return 0;
  2418. }
  2419. static inline int reiserfs_transaction_free_space(struct reiserfs_transaction_handle *th)
  2420. {
  2421. return th->t_blocks_allocated - th->t_blocks_logged;
  2422. }
  2423. struct reiserfs_transaction_handle *reiserfs_persistent_transaction(struct
  2424. super_block
  2425. *,
  2426. int count);
  2427. int reiserfs_end_persistent_transaction(struct reiserfs_transaction_handle *);
  2428. void reiserfs_vfs_truncate_file(struct inode *inode);
  2429. int reiserfs_commit_page(struct inode *inode, struct page *page,
  2430. unsigned from, unsigned to);
  2431. void reiserfs_flush_old_commits(struct super_block *);
  2432. int reiserfs_commit_for_inode(struct inode *);
  2433. int reiserfs_inode_needs_commit(struct inode *);
  2434. void reiserfs_update_inode_transaction(struct inode *);
  2435. void reiserfs_wait_on_write_block(struct super_block *s);
  2436. void reiserfs_block_writes(struct reiserfs_transaction_handle *th);
  2437. void reiserfs_allow_writes(struct super_block *s);
  2438. void reiserfs_check_lock_depth(struct super_block *s, char *caller);
  2439. int reiserfs_prepare_for_journal(struct super_block *, struct buffer_head *bh,
  2440. int wait);
  2441. void reiserfs_restore_prepared_buffer(struct super_block *,
  2442. struct buffer_head *bh);
  2443. int journal_init(struct super_block *, const char *j_dev_name, int old_format,
  2444. unsigned int);
  2445. int journal_release(struct reiserfs_transaction_handle *, struct super_block *);
  2446. int journal_release_error(struct reiserfs_transaction_handle *,
  2447. struct super_block *);
  2448. int journal_end(struct reiserfs_transaction_handle *);
  2449. int journal_end_sync(struct reiserfs_transaction_handle *);
  2450. int journal_mark_freed(struct reiserfs_transaction_handle *,
  2451. struct super_block *, b_blocknr_t blocknr);
  2452. int journal_transaction_should_end(struct reiserfs_transaction_handle *, int);
  2453. int reiserfs_in_journal(struct super_block *sb, unsigned int bmap_nr,
  2454. int bit_nr, int searchall, b_blocknr_t *next);
  2455. int journal_begin(struct reiserfs_transaction_handle *,
  2456. struct super_block *sb, unsigned long);
  2457. int journal_join_abort(struct reiserfs_transaction_handle *,
  2458. struct super_block *sb);
  2459. void reiserfs_abort_journal(struct super_block *sb, int errno);
  2460. void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...);
  2461. int reiserfs_allocate_list_bitmaps(struct super_block *s,
  2462. struct reiserfs_list_bitmap *, unsigned int);
  2463. void reiserfs_schedule_old_flush(struct super_block *s);
  2464. void reiserfs_cancel_old_flush(struct super_block *s);
  2465. void add_save_link(struct reiserfs_transaction_handle *th,
  2466. struct inode *inode, int truncate);
  2467. int remove_save_link(struct inode *inode, int truncate);
  2468. /* objectid.c */
  2469. __u32 reiserfs_get_unused_objectid(struct reiserfs_transaction_handle *th);
  2470. void reiserfs_release_objectid(struct reiserfs_transaction_handle *th,
  2471. __u32 objectid_to_release);
  2472. int reiserfs_convert_objectid_map_v1(struct super_block *);
  2473. /* stree.c */
  2474. int B_IS_IN_TREE(const struct buffer_head *);
  2475. extern void copy_item_head(struct item_head *to,
  2476. const struct item_head *from);
  2477. /* first key is in cpu form, second - le */
  2478. extern int comp_short_keys(const struct reiserfs_key *le_key,
  2479. const struct cpu_key *cpu_key);
  2480. extern void le_key2cpu_key(struct cpu_key *to, const struct reiserfs_key *from);
  2481. /* both are in le form */
  2482. extern int comp_le_keys(const struct reiserfs_key *,
  2483. const struct reiserfs_key *);
  2484. extern int comp_short_le_keys(const struct reiserfs_key *,
  2485. const struct reiserfs_key *);
  2486. /* * get key version from on disk key - kludge */
  2487. static inline int le_key_version(const struct reiserfs_key *key)
  2488. {
  2489. int type;
  2490. type = offset_v2_k_type(&(key->u.k_offset_v2));
  2491. if (type != TYPE_DIRECT && type != TYPE_INDIRECT
  2492. && type != TYPE_DIRENTRY)
  2493. return KEY_FORMAT_3_5;
  2494. return KEY_FORMAT_3_6;
  2495. }
  2496. static inline void copy_key(struct reiserfs_key *to,
  2497. const struct reiserfs_key *from)
  2498. {
  2499. memcpy(to, from, KEY_SIZE);
  2500. }
  2501. int comp_items(const struct item_head *stored_ih, const struct treepath *path);
  2502. const struct reiserfs_key *get_rkey(const struct treepath *chk_path,
  2503. const struct super_block *sb);
  2504. int search_by_key(struct super_block *, const struct cpu_key *,
  2505. struct treepath *, int);
  2506. #define search_item(s,key,path) search_by_key (s, key, path, DISK_LEAF_NODE_LEVEL)
  2507. int search_for_position_by_key(struct super_block *sb,
  2508. const struct cpu_key *cpu_key,
  2509. struct treepath *search_path);
  2510. extern void decrement_bcount(struct buffer_head *bh);
  2511. void decrement_counters_in_path(struct treepath *search_path);
  2512. void pathrelse(struct treepath *search_path);
  2513. int reiserfs_check_path(struct treepath *p);
  2514. void pathrelse_and_restore(struct super_block *s, struct treepath *search_path);
  2515. int reiserfs_insert_item(struct reiserfs_transaction_handle *th,
  2516. struct treepath *path,
  2517. const struct cpu_key *key,
  2518. struct item_head *ih,
  2519. struct inode *inode, const char *body);
  2520. int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th,
  2521. struct treepath *path,
  2522. const struct cpu_key *key,
  2523. struct inode *inode,
  2524. const char *body, int paste_size);
  2525. int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
  2526. struct treepath *path,
  2527. struct cpu_key *key,
  2528. struct inode *inode,
  2529. struct page *page, loff_t new_file_size);
  2530. int reiserfs_delete_item(struct reiserfs_transaction_handle *th,
  2531. struct treepath *path,
  2532. const struct cpu_key *key,
  2533. struct inode *inode, struct buffer_head *un_bh);
  2534. void reiserfs_delete_solid_item(struct reiserfs_transaction_handle *th,
  2535. struct inode *inode, struct reiserfs_key *key);
  2536. int reiserfs_delete_object(struct reiserfs_transaction_handle *th,
  2537. struct inode *inode);
  2538. int reiserfs_do_truncate(struct reiserfs_transaction_handle *th,
  2539. struct inode *inode, struct page *,
  2540. int update_timestamps);
  2541. #define i_block_size(inode) ((inode)->i_sb->s_blocksize)
  2542. #define file_size(inode) ((inode)->i_size)
  2543. #define tail_size(inode) (file_size (inode) & (i_block_size (inode) - 1))
  2544. #define tail_has_to_be_packed(inode) (have_large_tails ((inode)->i_sb)?\
  2545. !STORE_TAIL_IN_UNFM_S1(file_size (inode), tail_size(inode), inode->i_sb->s_blocksize):have_small_tails ((inode)->i_sb)?!STORE_TAIL_IN_UNFM_S2(file_size (inode), tail_size(inode), inode->i_sb->s_blocksize):0 )
  2546. void padd_item(char *item, int total_length, int length);
  2547. /* inode.c */
  2548. /* args for the create parameter of reiserfs_get_block */
  2549. #define GET_BLOCK_NO_CREATE 0 /* don't create new blocks or convert tails */
  2550. #define GET_BLOCK_CREATE 1 /* add anything you need to find block */
  2551. #define GET_BLOCK_NO_HOLE 2 /* return -ENOENT for file holes */
  2552. #define GET_BLOCK_READ_DIRECT 4 /* read the tail if indirect item not found */
  2553. #define GET_BLOCK_NO_IMUX 8 /* i_mutex is not held, don't preallocate */
  2554. #define GET_BLOCK_NO_DANGLE 16 /* don't leave any transactions running */
  2555. void reiserfs_read_locked_inode(struct inode *inode,
  2556. struct reiserfs_iget_args *args);
  2557. int reiserfs_find_actor(struct inode *inode, void *p);
  2558. int reiserfs_init_locked_inode(struct inode *inode, void *p);
  2559. void reiserfs_evict_inode(struct inode *inode);
  2560. int reiserfs_write_inode(struct inode *inode, struct writeback_control *wbc);
  2561. int reiserfs_get_block(struct inode *inode, sector_t block,
  2562. struct buffer_head *bh_result, int create);
  2563. struct dentry *reiserfs_fh_to_dentry(struct super_block *sb, struct fid *fid,
  2564. int fh_len, int fh_type);
  2565. struct dentry *reiserfs_fh_to_parent(struct super_block *sb, struct fid *fid,
  2566. int fh_len, int fh_type);
  2567. int reiserfs_encode_fh(struct inode *inode, __u32 * data, int *lenp,
  2568. struct inode *parent);
  2569. int reiserfs_truncate_file(struct inode *, int update_timestamps);
  2570. void make_cpu_key(struct cpu_key *cpu_key, struct inode *inode, loff_t offset,
  2571. int type, int key_length);
  2572. void make_le_item_head(struct item_head *ih, const struct cpu_key *key,
  2573. int version,
  2574. loff_t offset, int type, int length, int entry_count);
  2575. struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key);
  2576. struct reiserfs_security_handle;
  2577. int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
  2578. struct inode *dir, umode_t mode,
  2579. const char *symname, loff_t i_size,
  2580. struct dentry *dentry, struct inode *inode,
  2581. struct reiserfs_security_handle *security);
  2582. void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
  2583. struct inode *inode, loff_t size);
  2584. static inline void reiserfs_update_sd(struct reiserfs_transaction_handle *th,
  2585. struct inode *inode)
  2586. {
  2587. reiserfs_update_sd_size(th, inode, inode->i_size);
  2588. }
  2589. void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode);
  2590. int reiserfs_setattr(struct dentry *dentry, struct iattr *attr);
  2591. int __reiserfs_write_begin(struct page *page, unsigned from, unsigned len);
  2592. /* namei.c */
  2593. void set_de_name_and_namelen(struct reiserfs_dir_entry *de);
  2594. int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
  2595. struct treepath *path, struct reiserfs_dir_entry *de);
  2596. struct dentry *reiserfs_get_parent(struct dentry *);
  2597. #ifdef CONFIG_REISERFS_PROC_INFO
  2598. int reiserfs_proc_info_init(struct super_block *sb);
  2599. int reiserfs_proc_info_done(struct super_block *sb);
  2600. int reiserfs_proc_info_global_init(void);
  2601. int reiserfs_proc_info_global_done(void);
  2602. #define PROC_EXP( e ) e
  2603. #define __PINFO( sb ) REISERFS_SB(sb) -> s_proc_info_data
  2604. #define PROC_INFO_MAX( sb, field, value ) \
  2605. __PINFO( sb ).field = \
  2606. max( REISERFS_SB( sb ) -> s_proc_info_data.field, value )
  2607. #define PROC_INFO_INC( sb, field ) ( ++ ( __PINFO( sb ).field ) )
  2608. #define PROC_INFO_ADD( sb, field, val ) ( __PINFO( sb ).field += ( val ) )
  2609. #define PROC_INFO_BH_STAT( sb, bh, level ) \
  2610. PROC_INFO_INC( sb, sbk_read_at[ ( level ) ] ); \
  2611. PROC_INFO_ADD( sb, free_at[ ( level ) ], B_FREE_SPACE( bh ) ); \
  2612. PROC_INFO_ADD( sb, items_at[ ( level ) ], B_NR_ITEMS( bh ) )
  2613. #else
  2614. static inline int reiserfs_proc_info_init(struct super_block *sb)
  2615. {
  2616. return 0;
  2617. }
  2618. static inline int reiserfs_proc_info_done(struct super_block *sb)
  2619. {
  2620. return 0;
  2621. }
  2622. static inline int reiserfs_proc_info_global_init(void)
  2623. {
  2624. return 0;
  2625. }
  2626. static inline int reiserfs_proc_info_global_done(void)
  2627. {
  2628. return 0;
  2629. }
  2630. #define PROC_EXP( e )
  2631. #define VOID_V ( ( void ) 0 )
  2632. #define PROC_INFO_MAX( sb, field, value ) VOID_V
  2633. #define PROC_INFO_INC( sb, field ) VOID_V
  2634. #define PROC_INFO_ADD( sb, field, val ) VOID_V
  2635. #define PROC_INFO_BH_STAT(sb, bh, n_node_level) VOID_V
  2636. #endif
  2637. /* dir.c */
  2638. extern const struct inode_operations reiserfs_dir_inode_operations;
  2639. extern const struct inode_operations reiserfs_symlink_inode_operations;
  2640. extern const struct inode_operations reiserfs_special_inode_operations;
  2641. extern const struct file_operations reiserfs_dir_operations;
  2642. int reiserfs_readdir_inode(struct inode *, struct dir_context *);
  2643. /* tail_conversion.c */
  2644. int direct2indirect(struct reiserfs_transaction_handle *, struct inode *,
  2645. struct treepath *, struct buffer_head *, loff_t);
  2646. int indirect2direct(struct reiserfs_transaction_handle *, struct inode *,
  2647. struct page *, struct treepath *, const struct cpu_key *,
  2648. loff_t, char *);
  2649. void reiserfs_unmap_buffer(struct buffer_head *);
  2650. /* file.c */
  2651. extern const struct inode_operations reiserfs_file_inode_operations;
  2652. extern const struct file_operations reiserfs_file_operations;
  2653. extern const struct address_space_operations reiserfs_address_space_operations;
  2654. /* fix_nodes.c */
  2655. int fix_nodes(int n_op_mode, struct tree_balance *tb,
  2656. struct item_head *ins_ih, const void *);
  2657. void unfix_nodes(struct tree_balance *);
  2658. /* prints.c */
  2659. void __reiserfs_panic(struct super_block *s, const char *id,
  2660. const char *function, const char *fmt, ...)
  2661. __attribute__ ((noreturn));
  2662. #define reiserfs_panic(s, id, fmt, args...) \
  2663. __reiserfs_panic(s, id, __func__, fmt, ##args)
  2664. void __reiserfs_error(struct super_block *s, const char *id,
  2665. const char *function, const char *fmt, ...);
  2666. #define reiserfs_error(s, id, fmt, args...) \
  2667. __reiserfs_error(s, id, __func__, fmt, ##args)
  2668. void reiserfs_info(struct super_block *s, const char *fmt, ...);
  2669. void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...);
  2670. void print_indirect_item(struct buffer_head *bh, int item_num);
  2671. void store_print_tb(struct tree_balance *tb);
  2672. void print_cur_tb(char *mes);
  2673. void print_de(struct reiserfs_dir_entry *de);
  2674. void print_bi(struct buffer_info *bi, char *mes);
  2675. #define PRINT_LEAF_ITEMS 1 /* print all items */
  2676. #define PRINT_DIRECTORY_ITEMS 2 /* print directory items */
  2677. #define PRINT_DIRECT_ITEMS 4 /* print contents of direct items */
  2678. void print_block(struct buffer_head *bh, ...);
  2679. void print_bmap(struct super_block *s, int silent);
  2680. void print_bmap_block(int i, char *data, int size, int silent);
  2681. /*void print_super_block (struct super_block * s, char * mes);*/
  2682. void print_objectid_map(struct super_block *s);
  2683. void print_block_head(struct buffer_head *bh, char *mes);
  2684. void check_leaf(struct buffer_head *bh);
  2685. void check_internal(struct buffer_head *bh);
  2686. void print_statistics(struct super_block *s);
  2687. char *reiserfs_hashname(int code);
  2688. /* lbalance.c */
  2689. int leaf_move_items(int shift_mode, struct tree_balance *tb, int mov_num,
  2690. int mov_bytes, struct buffer_head *Snew);
  2691. int leaf_shift_left(struct tree_balance *tb, int shift_num, int shift_bytes);
  2692. int leaf_shift_right(struct tree_balance *tb, int shift_num, int shift_bytes);
  2693. void leaf_delete_items(struct buffer_info *cur_bi, int last_first, int first,
  2694. int del_num, int del_bytes);
  2695. void leaf_insert_into_buf(struct buffer_info *bi, int before,
  2696. struct item_head * const inserted_item_ih,
  2697. const char * const inserted_item_body,
  2698. int zeros_number);
  2699. void leaf_paste_in_buffer(struct buffer_info *bi, int pasted_item_num,
  2700. int pos_in_item, int paste_size,
  2701. const char * const body, int zeros_number);
  2702. void leaf_cut_from_buffer(struct buffer_info *bi, int cut_item_num,
  2703. int pos_in_item, int cut_size);
  2704. void leaf_paste_entries(struct buffer_info *bi, int item_num, int before,
  2705. int new_entry_count, struct reiserfs_de_head *new_dehs,
  2706. const char *records, int paste_size);
  2707. /* ibalance.c */
  2708. int balance_internal(struct tree_balance *, int, int, struct item_head *,
  2709. struct buffer_head **);
  2710. /* do_balance.c */
  2711. void do_balance_mark_leaf_dirty(struct tree_balance *tb,
  2712. struct buffer_head *bh, int flag);
  2713. #define do_balance_mark_internal_dirty do_balance_mark_leaf_dirty
  2714. #define do_balance_mark_sb_dirty do_balance_mark_leaf_dirty
  2715. void do_balance(struct tree_balance *tb, struct item_head *ih,
  2716. const char *body, int flag);
  2717. void reiserfs_invalidate_buffer(struct tree_balance *tb,
  2718. struct buffer_head *bh);
  2719. int get_left_neighbor_position(struct tree_balance *tb, int h);
  2720. int get_right_neighbor_position(struct tree_balance *tb, int h);
  2721. void replace_key(struct tree_balance *tb, struct buffer_head *, int,
  2722. struct buffer_head *, int);
  2723. void make_empty_node(struct buffer_info *);
  2724. struct buffer_head *get_FEB(struct tree_balance *);
  2725. /* bitmap.c */
  2726. /*
  2727. * structure contains hints for block allocator, and it is a container for
  2728. * arguments, such as node, search path, transaction_handle, etc.
  2729. */
  2730. struct __reiserfs_blocknr_hint {
  2731. /* inode passed to allocator, if we allocate unf. nodes */
  2732. struct inode *inode;
  2733. sector_t block; /* file offset, in blocks */
  2734. struct in_core_key key;
  2735. /*
  2736. * search path, used by allocator to deternine search_start by
  2737. * various ways
  2738. */
  2739. struct treepath *path;
  2740. /*
  2741. * transaction handle is needed to log super blocks
  2742. * and bitmap blocks changes
  2743. */
  2744. struct reiserfs_transaction_handle *th;
  2745. b_blocknr_t beg, end;
  2746. /*
  2747. * a field used to transfer search start value (block number)
  2748. * between different block allocator procedures
  2749. * (determine_search_start() and others)
  2750. */
  2751. b_blocknr_t search_start;
  2752. /*
  2753. * is set in determine_prealloc_size() function,
  2754. * used by underlayed function that do actual allocation
  2755. */
  2756. int prealloc_size;
  2757. /*
  2758. * the allocator uses different polices for getting disk
  2759. * space for formatted/unformatted blocks with/without preallocation
  2760. */
  2761. unsigned formatted_node:1;
  2762. unsigned preallocate:1;
  2763. };
  2764. typedef struct __reiserfs_blocknr_hint reiserfs_blocknr_hint_t;
  2765. int reiserfs_parse_alloc_options(struct super_block *, char *);
  2766. void reiserfs_init_alloc_options(struct super_block *s);
  2767. /*
  2768. * given a directory, this will tell you what packing locality
  2769. * to use for a new object underneat it. The locality is returned
  2770. * in disk byte order (le).
  2771. */
  2772. __le32 reiserfs_choose_packing(struct inode *dir);
  2773. void show_alloc_options(struct seq_file *seq, struct super_block *s);
  2774. int reiserfs_init_bitmap_cache(struct super_block *sb);
  2775. void reiserfs_free_bitmap_cache(struct super_block *sb);
  2776. void reiserfs_cache_bitmap_metadata(struct super_block *sb, struct buffer_head *bh, struct reiserfs_bitmap_info *info);
  2777. struct buffer_head *reiserfs_read_bitmap_block(struct super_block *sb, unsigned int bitmap);
  2778. int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value);
  2779. void reiserfs_free_block(struct reiserfs_transaction_handle *th, struct inode *,
  2780. b_blocknr_t, int for_unformatted);
  2781. int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t *, b_blocknr_t *, int,
  2782. int);
  2783. static inline int reiserfs_new_form_blocknrs(struct tree_balance *tb,
  2784. b_blocknr_t * new_blocknrs,
  2785. int amount_needed)
  2786. {
  2787. reiserfs_blocknr_hint_t hint = {
  2788. .th = tb->transaction_handle,
  2789. .path = tb->tb_path,
  2790. .inode = NULL,
  2791. .key = tb->key,
  2792. .block = 0,
  2793. .formatted_node = 1
  2794. };
  2795. return reiserfs_allocate_blocknrs(&hint, new_blocknrs, amount_needed,
  2796. 0);
  2797. }
  2798. static inline int reiserfs_new_unf_blocknrs(struct reiserfs_transaction_handle
  2799. *th, struct inode *inode,
  2800. b_blocknr_t * new_blocknrs,
  2801. struct treepath *path,
  2802. sector_t block)
  2803. {
  2804. reiserfs_blocknr_hint_t hint = {
  2805. .th = th,
  2806. .path = path,
  2807. .inode = inode,
  2808. .block = block,
  2809. .formatted_node = 0,
  2810. .preallocate = 0
  2811. };
  2812. return reiserfs_allocate_blocknrs(&hint, new_blocknrs, 1, 0);
  2813. }
  2814. #ifdef REISERFS_PREALLOCATE
  2815. static inline int reiserfs_new_unf_blocknrs2(struct reiserfs_transaction_handle
  2816. *th, struct inode *inode,
  2817. b_blocknr_t * new_blocknrs,
  2818. struct treepath *path,
  2819. sector_t block)
  2820. {
  2821. reiserfs_blocknr_hint_t hint = {
  2822. .th = th,
  2823. .path = path,
  2824. .inode = inode,
  2825. .block = block,
  2826. .formatted_node = 0,
  2827. .preallocate = 1
  2828. };
  2829. return reiserfs_allocate_blocknrs(&hint, new_blocknrs, 1, 0);
  2830. }
  2831. void reiserfs_discard_prealloc(struct reiserfs_transaction_handle *th,
  2832. struct inode *inode);
  2833. void reiserfs_discard_all_prealloc(struct reiserfs_transaction_handle *th);
  2834. #endif
  2835. /* hashes.c */
  2836. __u32 keyed_hash(const signed char *msg, int len);
  2837. __u32 yura_hash(const signed char *msg, int len);
  2838. __u32 r5_hash(const signed char *msg, int len);
  2839. #define reiserfs_set_le_bit __set_bit_le
  2840. #define reiserfs_test_and_set_le_bit __test_and_set_bit_le
  2841. #define reiserfs_clear_le_bit __clear_bit_le
  2842. #define reiserfs_test_and_clear_le_bit __test_and_clear_bit_le
  2843. #define reiserfs_test_le_bit test_bit_le
  2844. #define reiserfs_find_next_zero_le_bit find_next_zero_bit_le
  2845. /*
  2846. * sometimes reiserfs_truncate may require to allocate few new blocks
  2847. * to perform indirect2direct conversion. People probably used to
  2848. * think, that truncate should work without problems on a filesystem
  2849. * without free disk space. They may complain that they can not
  2850. * truncate due to lack of free disk space. This spare space allows us
  2851. * to not worry about it. 500 is probably too much, but it should be
  2852. * absolutely safe
  2853. */
  2854. #define SPARE_SPACE 500
  2855. /* prototypes from ioctl.c */
  2856. long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
  2857. long reiserfs_compat_ioctl(struct file *filp,
  2858. unsigned int cmd, unsigned long arg);
  2859. int reiserfs_unpack(struct inode *inode, struct file *filp);