xfs_inode.c 124 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260
  1. /*
  2. * Copyright (c) 2000-2006 Silicon Graphics, Inc.
  3. * All Rights Reserved.
  4. *
  5. * This program is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU General Public License as
  7. * published by the Free Software Foundation.
  8. *
  9. * This program is distributed in the hope that it would be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write the Free Software Foundation,
  16. * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17. */
  18. #include <linux/log2.h>
  19. #include "xfs.h"
  20. #include "xfs_fs.h"
  21. #include "xfs_types.h"
  22. #include "xfs_bit.h"
  23. #include "xfs_log.h"
  24. #include "xfs_inum.h"
  25. #include "xfs_trans.h"
  26. #include "xfs_trans_priv.h"
  27. #include "xfs_sb.h"
  28. #include "xfs_ag.h"
  29. #include "xfs_dir2.h"
  30. #include "xfs_dmapi.h"
  31. #include "xfs_mount.h"
  32. #include "xfs_bmap_btree.h"
  33. #include "xfs_alloc_btree.h"
  34. #include "xfs_ialloc_btree.h"
  35. #include "xfs_dir2_sf.h"
  36. #include "xfs_attr_sf.h"
  37. #include "xfs_dinode.h"
  38. #include "xfs_inode.h"
  39. #include "xfs_buf_item.h"
  40. #include "xfs_inode_item.h"
  41. #include "xfs_btree.h"
  42. #include "xfs_btree_trace.h"
  43. #include "xfs_alloc.h"
  44. #include "xfs_ialloc.h"
  45. #include "xfs_bmap.h"
  46. #include "xfs_rw.h"
  47. #include "xfs_error.h"
  48. #include "xfs_utils.h"
  49. #include "xfs_quota.h"
  50. #include "xfs_filestream.h"
  51. #include "xfs_vnodeops.h"
  52. #include "xfs_trace.h"
  53. kmem_zone_t *xfs_ifork_zone;
  54. kmem_zone_t *xfs_inode_zone;
  55. /*
  56. * Used in xfs_itruncate(). This is the maximum number of extents
  57. * freed from a file in a single transaction.
  58. */
  59. #define XFS_ITRUNC_MAX_EXTENTS 2
  60. STATIC int xfs_iflush_int(xfs_inode_t *, xfs_buf_t *);
  61. STATIC int xfs_iformat_local(xfs_inode_t *, xfs_dinode_t *, int, int);
  62. STATIC int xfs_iformat_extents(xfs_inode_t *, xfs_dinode_t *, int);
  63. STATIC int xfs_iformat_btree(xfs_inode_t *, xfs_dinode_t *, int);
  64. #ifdef DEBUG
  65. /*
  66. * Make sure that the extents in the given memory buffer
  67. * are valid.
  68. */
  69. STATIC void
  70. xfs_validate_extents(
  71. xfs_ifork_t *ifp,
  72. int nrecs,
  73. xfs_exntfmt_t fmt)
  74. {
  75. xfs_bmbt_irec_t irec;
  76. xfs_bmbt_rec_host_t rec;
  77. int i;
  78. for (i = 0; i < nrecs; i++) {
  79. xfs_bmbt_rec_host_t *ep = xfs_iext_get_ext(ifp, i);
  80. rec.l0 = get_unaligned(&ep->l0);
  81. rec.l1 = get_unaligned(&ep->l1);
  82. xfs_bmbt_get_all(&rec, &irec);
  83. if (fmt == XFS_EXTFMT_NOSTATE)
  84. ASSERT(irec.br_state == XFS_EXT_NORM);
  85. }
  86. }
  87. #else /* DEBUG */
  88. #define xfs_validate_extents(ifp, nrecs, fmt)
  89. #endif /* DEBUG */
  90. /*
  91. * Check that none of the inode's in the buffer have a next
  92. * unlinked field of 0.
  93. */
  94. #if defined(DEBUG)
  95. void
  96. xfs_inobp_check(
  97. xfs_mount_t *mp,
  98. xfs_buf_t *bp)
  99. {
  100. int i;
  101. int j;
  102. xfs_dinode_t *dip;
  103. j = mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog;
  104. for (i = 0; i < j; i++) {
  105. dip = (xfs_dinode_t *)xfs_buf_offset(bp,
  106. i * mp->m_sb.sb_inodesize);
  107. if (!dip->di_next_unlinked) {
  108. xfs_fs_cmn_err(CE_ALERT, mp,
  109. "Detected a bogus zero next_unlinked field in incore inode buffer 0x%p. About to pop an ASSERT.",
  110. bp);
  111. ASSERT(dip->di_next_unlinked);
  112. }
  113. }
  114. }
  115. #endif
  116. /*
  117. * Find the buffer associated with the given inode map
  118. * We do basic validation checks on the buffer once it has been
  119. * retrieved from disk.
  120. */
  121. STATIC int
  122. xfs_imap_to_bp(
  123. xfs_mount_t *mp,
  124. xfs_trans_t *tp,
  125. struct xfs_imap *imap,
  126. xfs_buf_t **bpp,
  127. uint buf_flags,
  128. uint iget_flags)
  129. {
  130. int error;
  131. int i;
  132. int ni;
  133. xfs_buf_t *bp;
  134. error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, imap->im_blkno,
  135. (int)imap->im_len, buf_flags, &bp);
  136. if (error) {
  137. if (error != EAGAIN) {
  138. cmn_err(CE_WARN,
  139. "xfs_imap_to_bp: xfs_trans_read_buf()returned "
  140. "an error %d on %s. Returning error.",
  141. error, mp->m_fsname);
  142. } else {
  143. ASSERT(buf_flags & XBF_TRYLOCK);
  144. }
  145. return error;
  146. }
  147. /*
  148. * Validate the magic number and version of every inode in the buffer
  149. * (if DEBUG kernel) or the first inode in the buffer, otherwise.
  150. */
  151. #ifdef DEBUG
  152. ni = BBTOB(imap->im_len) >> mp->m_sb.sb_inodelog;
  153. #else /* usual case */
  154. ni = 1;
  155. #endif
  156. for (i = 0; i < ni; i++) {
  157. int di_ok;
  158. xfs_dinode_t *dip;
  159. dip = (xfs_dinode_t *)xfs_buf_offset(bp,
  160. (i << mp->m_sb.sb_inodelog));
  161. di_ok = be16_to_cpu(dip->di_magic) == XFS_DINODE_MAGIC &&
  162. XFS_DINODE_GOOD_VERSION(dip->di_version);
  163. if (unlikely(XFS_TEST_ERROR(!di_ok, mp,
  164. XFS_ERRTAG_ITOBP_INOTOBP,
  165. XFS_RANDOM_ITOBP_INOTOBP))) {
  166. if (iget_flags & XFS_IGET_BULKSTAT) {
  167. xfs_trans_brelse(tp, bp);
  168. return XFS_ERROR(EINVAL);
  169. }
  170. XFS_CORRUPTION_ERROR("xfs_imap_to_bp",
  171. XFS_ERRLEVEL_HIGH, mp, dip);
  172. #ifdef DEBUG
  173. cmn_err(CE_PANIC,
  174. "Device %s - bad inode magic/vsn "
  175. "daddr %lld #%d (magic=%x)",
  176. XFS_BUFTARG_NAME(mp->m_ddev_targp),
  177. (unsigned long long)imap->im_blkno, i,
  178. be16_to_cpu(dip->di_magic));
  179. #endif
  180. xfs_trans_brelse(tp, bp);
  181. return XFS_ERROR(EFSCORRUPTED);
  182. }
  183. }
  184. xfs_inobp_check(mp, bp);
  185. /*
  186. * Mark the buffer as an inode buffer now that it looks good
  187. */
  188. XFS_BUF_SET_VTYPE(bp, B_FS_INO);
  189. *bpp = bp;
  190. return 0;
  191. }
  192. /*
  193. * This routine is called to map an inode number within a file
  194. * system to the buffer containing the on-disk version of the
  195. * inode. It returns a pointer to the buffer containing the
  196. * on-disk inode in the bpp parameter, and in the dip parameter
  197. * it returns a pointer to the on-disk inode within that buffer.
  198. *
  199. * If a non-zero error is returned, then the contents of bpp and
  200. * dipp are undefined.
  201. *
  202. * Use xfs_imap() to determine the size and location of the
  203. * buffer to read from disk.
  204. */
  205. int
  206. xfs_inotobp(
  207. xfs_mount_t *mp,
  208. xfs_trans_t *tp,
  209. xfs_ino_t ino,
  210. xfs_dinode_t **dipp,
  211. xfs_buf_t **bpp,
  212. int *offset,
  213. uint imap_flags)
  214. {
  215. struct xfs_imap imap;
  216. xfs_buf_t *bp;
  217. int error;
  218. imap.im_blkno = 0;
  219. error = xfs_imap(mp, tp, ino, &imap, imap_flags);
  220. if (error)
  221. return error;
  222. error = xfs_imap_to_bp(mp, tp, &imap, &bp, XBF_LOCK, imap_flags);
  223. if (error)
  224. return error;
  225. *dipp = (xfs_dinode_t *)xfs_buf_offset(bp, imap.im_boffset);
  226. *bpp = bp;
  227. *offset = imap.im_boffset;
  228. return 0;
  229. }
  230. /*
  231. * This routine is called to map an inode to the buffer containing
  232. * the on-disk version of the inode. It returns a pointer to the
  233. * buffer containing the on-disk inode in the bpp parameter, and in
  234. * the dip parameter it returns a pointer to the on-disk inode within
  235. * that buffer.
  236. *
  237. * If a non-zero error is returned, then the contents of bpp and
  238. * dipp are undefined.
  239. *
  240. * The inode is expected to already been mapped to its buffer and read
  241. * in once, thus we can use the mapping information stored in the inode
  242. * rather than calling xfs_imap(). This allows us to avoid the overhead
  243. * of looking at the inode btree for small block file systems
  244. * (see xfs_imap()).
  245. */
  246. int
  247. xfs_itobp(
  248. xfs_mount_t *mp,
  249. xfs_trans_t *tp,
  250. xfs_inode_t *ip,
  251. xfs_dinode_t **dipp,
  252. xfs_buf_t **bpp,
  253. uint buf_flags)
  254. {
  255. xfs_buf_t *bp;
  256. int error;
  257. ASSERT(ip->i_imap.im_blkno != 0);
  258. error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &bp, buf_flags, 0);
  259. if (error)
  260. return error;
  261. if (!bp) {
  262. ASSERT(buf_flags & XBF_TRYLOCK);
  263. ASSERT(tp == NULL);
  264. *bpp = NULL;
  265. return EAGAIN;
  266. }
  267. *dipp = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_imap.im_boffset);
  268. *bpp = bp;
  269. return 0;
  270. }
  271. /*
  272. * Move inode type and inode format specific information from the
  273. * on-disk inode to the in-core inode. For fifos, devs, and sockets
  274. * this means set if_rdev to the proper value. For files, directories,
  275. * and symlinks this means to bring in the in-line data or extent
  276. * pointers. For a file in B-tree format, only the root is immediately
  277. * brought in-core. The rest will be in-lined in if_extents when it
  278. * is first referenced (see xfs_iread_extents()).
  279. */
  280. STATIC int
  281. xfs_iformat(
  282. xfs_inode_t *ip,
  283. xfs_dinode_t *dip)
  284. {
  285. xfs_attr_shortform_t *atp;
  286. int size;
  287. int error;
  288. xfs_fsize_t di_size;
  289. ip->i_df.if_ext_max =
  290. XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
  291. error = 0;
  292. if (unlikely(be32_to_cpu(dip->di_nextents) +
  293. be16_to_cpu(dip->di_anextents) >
  294. be64_to_cpu(dip->di_nblocks))) {
  295. xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
  296. "corrupt dinode %Lu, extent total = %d, nblocks = %Lu.",
  297. (unsigned long long)ip->i_ino,
  298. (int)(be32_to_cpu(dip->di_nextents) +
  299. be16_to_cpu(dip->di_anextents)),
  300. (unsigned long long)
  301. be64_to_cpu(dip->di_nblocks));
  302. XFS_CORRUPTION_ERROR("xfs_iformat(1)", XFS_ERRLEVEL_LOW,
  303. ip->i_mount, dip);
  304. return XFS_ERROR(EFSCORRUPTED);
  305. }
  306. if (unlikely(dip->di_forkoff > ip->i_mount->m_sb.sb_inodesize)) {
  307. xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
  308. "corrupt dinode %Lu, forkoff = 0x%x.",
  309. (unsigned long long)ip->i_ino,
  310. dip->di_forkoff);
  311. XFS_CORRUPTION_ERROR("xfs_iformat(2)", XFS_ERRLEVEL_LOW,
  312. ip->i_mount, dip);
  313. return XFS_ERROR(EFSCORRUPTED);
  314. }
  315. if (unlikely((ip->i_d.di_flags & XFS_DIFLAG_REALTIME) &&
  316. !ip->i_mount->m_rtdev_targp)) {
  317. xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
  318. "corrupt dinode %Lu, has realtime flag set.",
  319. ip->i_ino);
  320. XFS_CORRUPTION_ERROR("xfs_iformat(realtime)",
  321. XFS_ERRLEVEL_LOW, ip->i_mount, dip);
  322. return XFS_ERROR(EFSCORRUPTED);
  323. }
  324. switch (ip->i_d.di_mode & S_IFMT) {
  325. case S_IFIFO:
  326. case S_IFCHR:
  327. case S_IFBLK:
  328. case S_IFSOCK:
  329. if (unlikely(dip->di_format != XFS_DINODE_FMT_DEV)) {
  330. XFS_CORRUPTION_ERROR("xfs_iformat(3)", XFS_ERRLEVEL_LOW,
  331. ip->i_mount, dip);
  332. return XFS_ERROR(EFSCORRUPTED);
  333. }
  334. ip->i_d.di_size = 0;
  335. ip->i_size = 0;
  336. ip->i_df.if_u2.if_rdev = xfs_dinode_get_rdev(dip);
  337. break;
  338. case S_IFREG:
  339. case S_IFLNK:
  340. case S_IFDIR:
  341. switch (dip->di_format) {
  342. case XFS_DINODE_FMT_LOCAL:
  343. /*
  344. * no local regular files yet
  345. */
  346. if (unlikely((be16_to_cpu(dip->di_mode) & S_IFMT) == S_IFREG)) {
  347. xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
  348. "corrupt inode %Lu "
  349. "(local format for regular file).",
  350. (unsigned long long) ip->i_ino);
  351. XFS_CORRUPTION_ERROR("xfs_iformat(4)",
  352. XFS_ERRLEVEL_LOW,
  353. ip->i_mount, dip);
  354. return XFS_ERROR(EFSCORRUPTED);
  355. }
  356. di_size = be64_to_cpu(dip->di_size);
  357. if (unlikely(di_size > XFS_DFORK_DSIZE(dip, ip->i_mount))) {
  358. xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
  359. "corrupt inode %Lu "
  360. "(bad size %Ld for local inode).",
  361. (unsigned long long) ip->i_ino,
  362. (long long) di_size);
  363. XFS_CORRUPTION_ERROR("xfs_iformat(5)",
  364. XFS_ERRLEVEL_LOW,
  365. ip->i_mount, dip);
  366. return XFS_ERROR(EFSCORRUPTED);
  367. }
  368. size = (int)di_size;
  369. error = xfs_iformat_local(ip, dip, XFS_DATA_FORK, size);
  370. break;
  371. case XFS_DINODE_FMT_EXTENTS:
  372. error = xfs_iformat_extents(ip, dip, XFS_DATA_FORK);
  373. break;
  374. case XFS_DINODE_FMT_BTREE:
  375. error = xfs_iformat_btree(ip, dip, XFS_DATA_FORK);
  376. break;
  377. default:
  378. XFS_ERROR_REPORT("xfs_iformat(6)", XFS_ERRLEVEL_LOW,
  379. ip->i_mount);
  380. return XFS_ERROR(EFSCORRUPTED);
  381. }
  382. break;
  383. default:
  384. XFS_ERROR_REPORT("xfs_iformat(7)", XFS_ERRLEVEL_LOW, ip->i_mount);
  385. return XFS_ERROR(EFSCORRUPTED);
  386. }
  387. if (error) {
  388. return error;
  389. }
  390. if (!XFS_DFORK_Q(dip))
  391. return 0;
  392. ASSERT(ip->i_afp == NULL);
  393. ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP);
  394. ip->i_afp->if_ext_max =
  395. XFS_IFORK_ASIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
  396. switch (dip->di_aformat) {
  397. case XFS_DINODE_FMT_LOCAL:
  398. atp = (xfs_attr_shortform_t *)XFS_DFORK_APTR(dip);
  399. size = be16_to_cpu(atp->hdr.totsize);
  400. if (unlikely(size < sizeof(struct xfs_attr_sf_hdr))) {
  401. xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
  402. "corrupt inode %Lu "
  403. "(bad attr fork size %Ld).",
  404. (unsigned long long) ip->i_ino,
  405. (long long) size);
  406. XFS_CORRUPTION_ERROR("xfs_iformat(8)",
  407. XFS_ERRLEVEL_LOW,
  408. ip->i_mount, dip);
  409. return XFS_ERROR(EFSCORRUPTED);
  410. }
  411. error = xfs_iformat_local(ip, dip, XFS_ATTR_FORK, size);
  412. break;
  413. case XFS_DINODE_FMT_EXTENTS:
  414. error = xfs_iformat_extents(ip, dip, XFS_ATTR_FORK);
  415. break;
  416. case XFS_DINODE_FMT_BTREE:
  417. error = xfs_iformat_btree(ip, dip, XFS_ATTR_FORK);
  418. break;
  419. default:
  420. error = XFS_ERROR(EFSCORRUPTED);
  421. break;
  422. }
  423. if (error) {
  424. kmem_zone_free(xfs_ifork_zone, ip->i_afp);
  425. ip->i_afp = NULL;
  426. xfs_idestroy_fork(ip, XFS_DATA_FORK);
  427. }
  428. return error;
  429. }
  430. /*
  431. * The file is in-lined in the on-disk inode.
  432. * If it fits into if_inline_data, then copy
  433. * it there, otherwise allocate a buffer for it
  434. * and copy the data there. Either way, set
  435. * if_data to point at the data.
  436. * If we allocate a buffer for the data, make
  437. * sure that its size is a multiple of 4 and
  438. * record the real size in i_real_bytes.
  439. */
  440. STATIC int
  441. xfs_iformat_local(
  442. xfs_inode_t *ip,
  443. xfs_dinode_t *dip,
  444. int whichfork,
  445. int size)
  446. {
  447. xfs_ifork_t *ifp;
  448. int real_size;
  449. /*
  450. * If the size is unreasonable, then something
  451. * is wrong and we just bail out rather than crash in
  452. * kmem_alloc() or memcpy() below.
  453. */
  454. if (unlikely(size > XFS_DFORK_SIZE(dip, ip->i_mount, whichfork))) {
  455. xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
  456. "corrupt inode %Lu "
  457. "(bad size %d for local fork, size = %d).",
  458. (unsigned long long) ip->i_ino, size,
  459. XFS_DFORK_SIZE(dip, ip->i_mount, whichfork));
  460. XFS_CORRUPTION_ERROR("xfs_iformat_local", XFS_ERRLEVEL_LOW,
  461. ip->i_mount, dip);
  462. return XFS_ERROR(EFSCORRUPTED);
  463. }
  464. ifp = XFS_IFORK_PTR(ip, whichfork);
  465. real_size = 0;
  466. if (size == 0)
  467. ifp->if_u1.if_data = NULL;
  468. else if (size <= sizeof(ifp->if_u2.if_inline_data))
  469. ifp->if_u1.if_data = ifp->if_u2.if_inline_data;
  470. else {
  471. real_size = roundup(size, 4);
  472. ifp->if_u1.if_data = kmem_alloc(real_size, KM_SLEEP);
  473. }
  474. ifp->if_bytes = size;
  475. ifp->if_real_bytes = real_size;
  476. if (size)
  477. memcpy(ifp->if_u1.if_data, XFS_DFORK_PTR(dip, whichfork), size);
  478. ifp->if_flags &= ~XFS_IFEXTENTS;
  479. ifp->if_flags |= XFS_IFINLINE;
  480. return 0;
  481. }
  482. /*
  483. * The file consists of a set of extents all
  484. * of which fit into the on-disk inode.
  485. * If there are few enough extents to fit into
  486. * the if_inline_ext, then copy them there.
  487. * Otherwise allocate a buffer for them and copy
  488. * them into it. Either way, set if_extents
  489. * to point at the extents.
  490. */
  491. STATIC int
  492. xfs_iformat_extents(
  493. xfs_inode_t *ip,
  494. xfs_dinode_t *dip,
  495. int whichfork)
  496. {
  497. xfs_bmbt_rec_t *dp;
  498. xfs_ifork_t *ifp;
  499. int nex;
  500. int size;
  501. int i;
  502. ifp = XFS_IFORK_PTR(ip, whichfork);
  503. nex = XFS_DFORK_NEXTENTS(dip, whichfork);
  504. size = nex * (uint)sizeof(xfs_bmbt_rec_t);
  505. /*
  506. * If the number of extents is unreasonable, then something
  507. * is wrong and we just bail out rather than crash in
  508. * kmem_alloc() or memcpy() below.
  509. */
  510. if (unlikely(size < 0 || size > XFS_DFORK_SIZE(dip, ip->i_mount, whichfork))) {
  511. xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
  512. "corrupt inode %Lu ((a)extents = %d).",
  513. (unsigned long long) ip->i_ino, nex);
  514. XFS_CORRUPTION_ERROR("xfs_iformat_extents(1)", XFS_ERRLEVEL_LOW,
  515. ip->i_mount, dip);
  516. return XFS_ERROR(EFSCORRUPTED);
  517. }
  518. ifp->if_real_bytes = 0;
  519. if (nex == 0)
  520. ifp->if_u1.if_extents = NULL;
  521. else if (nex <= XFS_INLINE_EXTS)
  522. ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext;
  523. else
  524. xfs_iext_add(ifp, 0, nex);
  525. ifp->if_bytes = size;
  526. if (size) {
  527. dp = (xfs_bmbt_rec_t *) XFS_DFORK_PTR(dip, whichfork);
  528. xfs_validate_extents(ifp, nex, XFS_EXTFMT_INODE(ip));
  529. for (i = 0; i < nex; i++, dp++) {
  530. xfs_bmbt_rec_host_t *ep = xfs_iext_get_ext(ifp, i);
  531. ep->l0 = get_unaligned_be64(&dp->l0);
  532. ep->l1 = get_unaligned_be64(&dp->l1);
  533. }
  534. XFS_BMAP_TRACE_EXLIST(ip, nex, whichfork);
  535. if (whichfork != XFS_DATA_FORK ||
  536. XFS_EXTFMT_INODE(ip) == XFS_EXTFMT_NOSTATE)
  537. if (unlikely(xfs_check_nostate_extents(
  538. ifp, 0, nex))) {
  539. XFS_ERROR_REPORT("xfs_iformat_extents(2)",
  540. XFS_ERRLEVEL_LOW,
  541. ip->i_mount);
  542. return XFS_ERROR(EFSCORRUPTED);
  543. }
  544. }
  545. ifp->if_flags |= XFS_IFEXTENTS;
  546. return 0;
  547. }
  548. /*
  549. * The file has too many extents to fit into
  550. * the inode, so they are in B-tree format.
  551. * Allocate a buffer for the root of the B-tree
  552. * and copy the root into it. The i_extents
  553. * field will remain NULL until all of the
  554. * extents are read in (when they are needed).
  555. */
  556. STATIC int
  557. xfs_iformat_btree(
  558. xfs_inode_t *ip,
  559. xfs_dinode_t *dip,
  560. int whichfork)
  561. {
  562. xfs_bmdr_block_t *dfp;
  563. xfs_ifork_t *ifp;
  564. /* REFERENCED */
  565. int nrecs;
  566. int size;
  567. ifp = XFS_IFORK_PTR(ip, whichfork);
  568. dfp = (xfs_bmdr_block_t *)XFS_DFORK_PTR(dip, whichfork);
  569. size = XFS_BMAP_BROOT_SPACE(dfp);
  570. nrecs = be16_to_cpu(dfp->bb_numrecs);
  571. /*
  572. * blow out if -- fork has less extents than can fit in
  573. * fork (fork shouldn't be a btree format), root btree
  574. * block has more records than can fit into the fork,
  575. * or the number of extents is greater than the number of
  576. * blocks.
  577. */
  578. if (unlikely(XFS_IFORK_NEXTENTS(ip, whichfork) <= ifp->if_ext_max
  579. || XFS_BMDR_SPACE_CALC(nrecs) >
  580. XFS_DFORK_SIZE(dip, ip->i_mount, whichfork)
  581. || XFS_IFORK_NEXTENTS(ip, whichfork) > ip->i_d.di_nblocks)) {
  582. xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
  583. "corrupt inode %Lu (btree).",
  584. (unsigned long long) ip->i_ino);
  585. XFS_ERROR_REPORT("xfs_iformat_btree", XFS_ERRLEVEL_LOW,
  586. ip->i_mount);
  587. return XFS_ERROR(EFSCORRUPTED);
  588. }
  589. ifp->if_broot_bytes = size;
  590. ifp->if_broot = kmem_alloc(size, KM_SLEEP);
  591. ASSERT(ifp->if_broot != NULL);
  592. /*
  593. * Copy and convert from the on-disk structure
  594. * to the in-memory structure.
  595. */
  596. xfs_bmdr_to_bmbt(ip->i_mount, dfp,
  597. XFS_DFORK_SIZE(dip, ip->i_mount, whichfork),
  598. ifp->if_broot, size);
  599. ifp->if_flags &= ~XFS_IFEXTENTS;
  600. ifp->if_flags |= XFS_IFBROOT;
  601. return 0;
  602. }
  603. STATIC void
  604. xfs_dinode_from_disk(
  605. xfs_icdinode_t *to,
  606. xfs_dinode_t *from)
  607. {
  608. to->di_magic = be16_to_cpu(from->di_magic);
  609. to->di_mode = be16_to_cpu(from->di_mode);
  610. to->di_version = from ->di_version;
  611. to->di_format = from->di_format;
  612. to->di_onlink = be16_to_cpu(from->di_onlink);
  613. to->di_uid = be32_to_cpu(from->di_uid);
  614. to->di_gid = be32_to_cpu(from->di_gid);
  615. to->di_nlink = be32_to_cpu(from->di_nlink);
  616. to->di_projid = be16_to_cpu(from->di_projid);
  617. memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));
  618. to->di_flushiter = be16_to_cpu(from->di_flushiter);
  619. to->di_atime.t_sec = be32_to_cpu(from->di_atime.t_sec);
  620. to->di_atime.t_nsec = be32_to_cpu(from->di_atime.t_nsec);
  621. to->di_mtime.t_sec = be32_to_cpu(from->di_mtime.t_sec);
  622. to->di_mtime.t_nsec = be32_to_cpu(from->di_mtime.t_nsec);
  623. to->di_ctime.t_sec = be32_to_cpu(from->di_ctime.t_sec);
  624. to->di_ctime.t_nsec = be32_to_cpu(from->di_ctime.t_nsec);
  625. to->di_size = be64_to_cpu(from->di_size);
  626. to->di_nblocks = be64_to_cpu(from->di_nblocks);
  627. to->di_extsize = be32_to_cpu(from->di_extsize);
  628. to->di_nextents = be32_to_cpu(from->di_nextents);
  629. to->di_anextents = be16_to_cpu(from->di_anextents);
  630. to->di_forkoff = from->di_forkoff;
  631. to->di_aformat = from->di_aformat;
  632. to->di_dmevmask = be32_to_cpu(from->di_dmevmask);
  633. to->di_dmstate = be16_to_cpu(from->di_dmstate);
  634. to->di_flags = be16_to_cpu(from->di_flags);
  635. to->di_gen = be32_to_cpu(from->di_gen);
  636. }
  637. void
  638. xfs_dinode_to_disk(
  639. xfs_dinode_t *to,
  640. xfs_icdinode_t *from)
  641. {
  642. to->di_magic = cpu_to_be16(from->di_magic);
  643. to->di_mode = cpu_to_be16(from->di_mode);
  644. to->di_version = from ->di_version;
  645. to->di_format = from->di_format;
  646. to->di_onlink = cpu_to_be16(from->di_onlink);
  647. to->di_uid = cpu_to_be32(from->di_uid);
  648. to->di_gid = cpu_to_be32(from->di_gid);
  649. to->di_nlink = cpu_to_be32(from->di_nlink);
  650. to->di_projid = cpu_to_be16(from->di_projid);
  651. memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));
  652. to->di_flushiter = cpu_to_be16(from->di_flushiter);
  653. to->di_atime.t_sec = cpu_to_be32(from->di_atime.t_sec);
  654. to->di_atime.t_nsec = cpu_to_be32(from->di_atime.t_nsec);
  655. to->di_mtime.t_sec = cpu_to_be32(from->di_mtime.t_sec);
  656. to->di_mtime.t_nsec = cpu_to_be32(from->di_mtime.t_nsec);
  657. to->di_ctime.t_sec = cpu_to_be32(from->di_ctime.t_sec);
  658. to->di_ctime.t_nsec = cpu_to_be32(from->di_ctime.t_nsec);
  659. to->di_size = cpu_to_be64(from->di_size);
  660. to->di_nblocks = cpu_to_be64(from->di_nblocks);
  661. to->di_extsize = cpu_to_be32(from->di_extsize);
  662. to->di_nextents = cpu_to_be32(from->di_nextents);
  663. to->di_anextents = cpu_to_be16(from->di_anextents);
  664. to->di_forkoff = from->di_forkoff;
  665. to->di_aformat = from->di_aformat;
  666. to->di_dmevmask = cpu_to_be32(from->di_dmevmask);
  667. to->di_dmstate = cpu_to_be16(from->di_dmstate);
  668. to->di_flags = cpu_to_be16(from->di_flags);
  669. to->di_gen = cpu_to_be32(from->di_gen);
  670. }
  671. STATIC uint
  672. _xfs_dic2xflags(
  673. __uint16_t di_flags)
  674. {
  675. uint flags = 0;
  676. if (di_flags & XFS_DIFLAG_ANY) {
  677. if (di_flags & XFS_DIFLAG_REALTIME)
  678. flags |= XFS_XFLAG_REALTIME;
  679. if (di_flags & XFS_DIFLAG_PREALLOC)
  680. flags |= XFS_XFLAG_PREALLOC;
  681. if (di_flags & XFS_DIFLAG_IMMUTABLE)
  682. flags |= XFS_XFLAG_IMMUTABLE;
  683. if (di_flags & XFS_DIFLAG_APPEND)
  684. flags |= XFS_XFLAG_APPEND;
  685. if (di_flags & XFS_DIFLAG_SYNC)
  686. flags |= XFS_XFLAG_SYNC;
  687. if (di_flags & XFS_DIFLAG_NOATIME)
  688. flags |= XFS_XFLAG_NOATIME;
  689. if (di_flags & XFS_DIFLAG_NODUMP)
  690. flags |= XFS_XFLAG_NODUMP;
  691. if (di_flags & XFS_DIFLAG_RTINHERIT)
  692. flags |= XFS_XFLAG_RTINHERIT;
  693. if (di_flags & XFS_DIFLAG_PROJINHERIT)
  694. flags |= XFS_XFLAG_PROJINHERIT;
  695. if (di_flags & XFS_DIFLAG_NOSYMLINKS)
  696. flags |= XFS_XFLAG_NOSYMLINKS;
  697. if (di_flags & XFS_DIFLAG_EXTSIZE)
  698. flags |= XFS_XFLAG_EXTSIZE;
  699. if (di_flags & XFS_DIFLAG_EXTSZINHERIT)
  700. flags |= XFS_XFLAG_EXTSZINHERIT;
  701. if (di_flags & XFS_DIFLAG_NODEFRAG)
  702. flags |= XFS_XFLAG_NODEFRAG;
  703. if (di_flags & XFS_DIFLAG_FILESTREAM)
  704. flags |= XFS_XFLAG_FILESTREAM;
  705. }
  706. return flags;
  707. }
  708. uint
  709. xfs_ip2xflags(
  710. xfs_inode_t *ip)
  711. {
  712. xfs_icdinode_t *dic = &ip->i_d;
  713. return _xfs_dic2xflags(dic->di_flags) |
  714. (XFS_IFORK_Q(ip) ? XFS_XFLAG_HASATTR : 0);
  715. }
  716. uint
  717. xfs_dic2xflags(
  718. xfs_dinode_t *dip)
  719. {
  720. return _xfs_dic2xflags(be16_to_cpu(dip->di_flags)) |
  721. (XFS_DFORK_Q(dip) ? XFS_XFLAG_HASATTR : 0);
  722. }
  723. /*
  724. * Read the disk inode attributes into the in-core inode structure.
  725. */
  726. int
  727. xfs_iread(
  728. xfs_mount_t *mp,
  729. xfs_trans_t *tp,
  730. xfs_inode_t *ip,
  731. xfs_daddr_t bno,
  732. uint iget_flags)
  733. {
  734. xfs_buf_t *bp;
  735. xfs_dinode_t *dip;
  736. int error;
  737. /*
  738. * Fill in the location information in the in-core inode.
  739. */
  740. ip->i_imap.im_blkno = bno;
  741. error = xfs_imap(mp, tp, ip->i_ino, &ip->i_imap, iget_flags);
  742. if (error)
  743. return error;
  744. ASSERT(bno == 0 || bno == ip->i_imap.im_blkno);
  745. /*
  746. * Get pointers to the on-disk inode and the buffer containing it.
  747. */
  748. error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &bp,
  749. XBF_LOCK, iget_flags);
  750. if (error)
  751. return error;
  752. dip = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_imap.im_boffset);
  753. /*
  754. * If we got something that isn't an inode it means someone
  755. * (nfs or dmi) has a stale handle.
  756. */
  757. if (be16_to_cpu(dip->di_magic) != XFS_DINODE_MAGIC) {
  758. #ifdef DEBUG
  759. xfs_fs_cmn_err(CE_ALERT, mp, "xfs_iread: "
  760. "dip->di_magic (0x%x) != "
  761. "XFS_DINODE_MAGIC (0x%x)",
  762. be16_to_cpu(dip->di_magic),
  763. XFS_DINODE_MAGIC);
  764. #endif /* DEBUG */
  765. error = XFS_ERROR(EINVAL);
  766. goto out_brelse;
  767. }
  768. /*
  769. * If the on-disk inode is already linked to a directory
  770. * entry, copy all of the inode into the in-core inode.
  771. * xfs_iformat() handles copying in the inode format
  772. * specific information.
  773. * Otherwise, just get the truly permanent information.
  774. */
  775. if (dip->di_mode) {
  776. xfs_dinode_from_disk(&ip->i_d, dip);
  777. error = xfs_iformat(ip, dip);
  778. if (error) {
  779. #ifdef DEBUG
  780. xfs_fs_cmn_err(CE_ALERT, mp, "xfs_iread: "
  781. "xfs_iformat() returned error %d",
  782. error);
  783. #endif /* DEBUG */
  784. goto out_brelse;
  785. }
  786. } else {
  787. ip->i_d.di_magic = be16_to_cpu(dip->di_magic);
  788. ip->i_d.di_version = dip->di_version;
  789. ip->i_d.di_gen = be32_to_cpu(dip->di_gen);
  790. ip->i_d.di_flushiter = be16_to_cpu(dip->di_flushiter);
  791. /*
  792. * Make sure to pull in the mode here as well in
  793. * case the inode is released without being used.
  794. * This ensures that xfs_inactive() will see that
  795. * the inode is already free and not try to mess
  796. * with the uninitialized part of it.
  797. */
  798. ip->i_d.di_mode = 0;
  799. /*
  800. * Initialize the per-fork minima and maxima for a new
  801. * inode here. xfs_iformat will do it for old inodes.
  802. */
  803. ip->i_df.if_ext_max =
  804. XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
  805. }
  806. /*
  807. * The inode format changed when we moved the link count and
  808. * made it 32 bits long. If this is an old format inode,
  809. * convert it in memory to look like a new one. If it gets
  810. * flushed to disk we will convert back before flushing or
  811. * logging it. We zero out the new projid field and the old link
  812. * count field. We'll handle clearing the pad field (the remains
  813. * of the old uuid field) when we actually convert the inode to
  814. * the new format. We don't change the version number so that we
  815. * can distinguish this from a real new format inode.
  816. */
  817. if (ip->i_d.di_version == 1) {
  818. ip->i_d.di_nlink = ip->i_d.di_onlink;
  819. ip->i_d.di_onlink = 0;
  820. ip->i_d.di_projid = 0;
  821. }
  822. ip->i_delayed_blks = 0;
  823. ip->i_size = ip->i_d.di_size;
  824. /*
  825. * Mark the buffer containing the inode as something to keep
  826. * around for a while. This helps to keep recently accessed
  827. * meta-data in-core longer.
  828. */
  829. XFS_BUF_SET_REF(bp, XFS_INO_REF);
  830. /*
  831. * Use xfs_trans_brelse() to release the buffer containing the
  832. * on-disk inode, because it was acquired with xfs_trans_read_buf()
  833. * in xfs_itobp() above. If tp is NULL, this is just a normal
  834. * brelse(). If we're within a transaction, then xfs_trans_brelse()
  835. * will only release the buffer if it is not dirty within the
  836. * transaction. It will be OK to release the buffer in this case,
  837. * because inodes on disk are never destroyed and we will be
  838. * locking the new in-core inode before putting it in the hash
  839. * table where other processes can find it. Thus we don't have
  840. * to worry about the inode being changed just because we released
  841. * the buffer.
  842. */
  843. out_brelse:
  844. xfs_trans_brelse(tp, bp);
  845. return error;
  846. }
  847. /*
  848. * Read in extents from a btree-format inode.
  849. * Allocate and fill in if_extents. Real work is done in xfs_bmap.c.
  850. */
  851. int
  852. xfs_iread_extents(
  853. xfs_trans_t *tp,
  854. xfs_inode_t *ip,
  855. int whichfork)
  856. {
  857. int error;
  858. xfs_ifork_t *ifp;
  859. xfs_extnum_t nextents;
  860. size_t size;
  861. if (unlikely(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) {
  862. XFS_ERROR_REPORT("xfs_iread_extents", XFS_ERRLEVEL_LOW,
  863. ip->i_mount);
  864. return XFS_ERROR(EFSCORRUPTED);
  865. }
  866. nextents = XFS_IFORK_NEXTENTS(ip, whichfork);
  867. size = nextents * sizeof(xfs_bmbt_rec_t);
  868. ifp = XFS_IFORK_PTR(ip, whichfork);
  869. /*
  870. * We know that the size is valid (it's checked in iformat_btree)
  871. */
  872. ifp->if_lastex = NULLEXTNUM;
  873. ifp->if_bytes = ifp->if_real_bytes = 0;
  874. ifp->if_flags |= XFS_IFEXTENTS;
  875. xfs_iext_add(ifp, 0, nextents);
  876. error = xfs_bmap_read_extents(tp, ip, whichfork);
  877. if (error) {
  878. xfs_iext_destroy(ifp);
  879. ifp->if_flags &= ~XFS_IFEXTENTS;
  880. return error;
  881. }
  882. xfs_validate_extents(ifp, nextents, XFS_EXTFMT_INODE(ip));
  883. return 0;
  884. }
  885. /*
  886. * Allocate an inode on disk and return a copy of its in-core version.
  887. * The in-core inode is locked exclusively. Set mode, nlink, and rdev
  888. * appropriately within the inode. The uid and gid for the inode are
  889. * set according to the contents of the given cred structure.
  890. *
  891. * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()
  892. * has a free inode available, call xfs_iget()
  893. * to obtain the in-core version of the allocated inode. Finally,
  894. * fill in the inode and log its initial contents. In this case,
  895. * ialloc_context would be set to NULL and call_again set to false.
  896. *
  897. * If xfs_dialloc() does not have an available inode,
  898. * it will replenish its supply by doing an allocation. Since we can
  899. * only do one allocation within a transaction without deadlocks, we
  900. * must commit the current transaction before returning the inode itself.
  901. * In this case, therefore, we will set call_again to true and return.
  902. * The caller should then commit the current transaction, start a new
  903. * transaction, and call xfs_ialloc() again to actually get the inode.
  904. *
  905. * To ensure that some other process does not grab the inode that
  906. * was allocated during the first call to xfs_ialloc(), this routine
  907. * also returns the [locked] bp pointing to the head of the freelist
  908. * as ialloc_context. The caller should hold this buffer across
  909. * the commit and pass it back into this routine on the second call.
  910. *
  911. * If we are allocating quota inodes, we do not have a parent inode
  912. * to attach to or associate with (i.e. pip == NULL) because they
  913. * are not linked into the directory structure - they are attached
  914. * directly to the superblock - and so have no parent.
  915. */
  916. int
  917. xfs_ialloc(
  918. xfs_trans_t *tp,
  919. xfs_inode_t *pip,
  920. mode_t mode,
  921. xfs_nlink_t nlink,
  922. xfs_dev_t rdev,
  923. cred_t *cr,
  924. xfs_prid_t prid,
  925. int okalloc,
  926. xfs_buf_t **ialloc_context,
  927. boolean_t *call_again,
  928. xfs_inode_t **ipp)
  929. {
  930. xfs_ino_t ino;
  931. xfs_inode_t *ip;
  932. uint flags;
  933. int error;
  934. timespec_t tv;
  935. int filestreams = 0;
  936. /*
  937. * Call the space management code to pick
  938. * the on-disk inode to be allocated.
  939. */
  940. error = xfs_dialloc(tp, pip ? pip->i_ino : 0, mode, okalloc,
  941. ialloc_context, call_again, &ino);
  942. if (error)
  943. return error;
  944. if (*call_again || ino == NULLFSINO) {
  945. *ipp = NULL;
  946. return 0;
  947. }
  948. ASSERT(*ialloc_context == NULL);
  949. /*
  950. * Get the in-core inode with the lock held exclusively.
  951. * This is because we're setting fields here we need
  952. * to prevent others from looking at until we're done.
  953. */
  954. error = xfs_trans_iget(tp->t_mountp, tp, ino,
  955. XFS_IGET_CREATE, XFS_ILOCK_EXCL, &ip);
  956. if (error)
  957. return error;
  958. ASSERT(ip != NULL);
  959. ip->i_d.di_mode = (__uint16_t)mode;
  960. ip->i_d.di_onlink = 0;
  961. ip->i_d.di_nlink = nlink;
  962. ASSERT(ip->i_d.di_nlink == nlink);
  963. ip->i_d.di_uid = current_fsuid();
  964. ip->i_d.di_gid = current_fsgid();
  965. ip->i_d.di_projid = prid;
  966. memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
  967. /*
  968. * If the superblock version is up to where we support new format
  969. * inodes and this is currently an old format inode, then change
  970. * the inode version number now. This way we only do the conversion
  971. * here rather than here and in the flush/logging code.
  972. */
  973. if (xfs_sb_version_hasnlink(&tp->t_mountp->m_sb) &&
  974. ip->i_d.di_version == 1) {
  975. ip->i_d.di_version = 2;
  976. /*
  977. * We've already zeroed the old link count, the projid field,
  978. * and the pad field.
  979. */
  980. }
  981. /*
  982. * Project ids won't be stored on disk if we are using a version 1 inode.
  983. */
  984. if ((prid != 0) && (ip->i_d.di_version == 1))
  985. xfs_bump_ino_vers2(tp, ip);
  986. if (pip && XFS_INHERIT_GID(pip)) {
  987. ip->i_d.di_gid = pip->i_d.di_gid;
  988. if ((pip->i_d.di_mode & S_ISGID) && (mode & S_IFMT) == S_IFDIR) {
  989. ip->i_d.di_mode |= S_ISGID;
  990. }
  991. }
  992. /*
  993. * If the group ID of the new file does not match the effective group
  994. * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
  995. * (and only if the irix_sgid_inherit compatibility variable is set).
  996. */
  997. if ((irix_sgid_inherit) &&
  998. (ip->i_d.di_mode & S_ISGID) &&
  999. (!in_group_p((gid_t)ip->i_d.di_gid))) {
  1000. ip->i_d.di_mode &= ~S_ISGID;
  1001. }
  1002. ip->i_d.di_size = 0;
  1003. ip->i_size = 0;
  1004. ip->i_d.di_nextents = 0;
  1005. ASSERT(ip->i_d.di_nblocks == 0);
  1006. nanotime(&tv);
  1007. ip->i_d.di_mtime.t_sec = (__int32_t)tv.tv_sec;
  1008. ip->i_d.di_mtime.t_nsec = (__int32_t)tv.tv_nsec;
  1009. ip->i_d.di_atime = ip->i_d.di_mtime;
  1010. ip->i_d.di_ctime = ip->i_d.di_mtime;
  1011. /*
  1012. * di_gen will have been taken care of in xfs_iread.
  1013. */
  1014. ip->i_d.di_extsize = 0;
  1015. ip->i_d.di_dmevmask = 0;
  1016. ip->i_d.di_dmstate = 0;
  1017. ip->i_d.di_flags = 0;
  1018. flags = XFS_ILOG_CORE;
  1019. switch (mode & S_IFMT) {
  1020. case S_IFIFO:
  1021. case S_IFCHR:
  1022. case S_IFBLK:
  1023. case S_IFSOCK:
  1024. ip->i_d.di_format = XFS_DINODE_FMT_DEV;
  1025. ip->i_df.if_u2.if_rdev = rdev;
  1026. ip->i_df.if_flags = 0;
  1027. flags |= XFS_ILOG_DEV;
  1028. break;
  1029. case S_IFREG:
  1030. /*
  1031. * we can't set up filestreams until after the VFS inode
  1032. * is set up properly.
  1033. */
  1034. if (pip && xfs_inode_is_filestream(pip))
  1035. filestreams = 1;
  1036. /* fall through */
  1037. case S_IFDIR:
  1038. if (pip && (pip->i_d.di_flags & XFS_DIFLAG_ANY)) {
  1039. uint di_flags = 0;
  1040. if ((mode & S_IFMT) == S_IFDIR) {
  1041. if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
  1042. di_flags |= XFS_DIFLAG_RTINHERIT;
  1043. if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
  1044. di_flags |= XFS_DIFLAG_EXTSZINHERIT;
  1045. ip->i_d.di_extsize = pip->i_d.di_extsize;
  1046. }
  1047. } else if ((mode & S_IFMT) == S_IFREG) {
  1048. if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
  1049. di_flags |= XFS_DIFLAG_REALTIME;
  1050. if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
  1051. di_flags |= XFS_DIFLAG_EXTSIZE;
  1052. ip->i_d.di_extsize = pip->i_d.di_extsize;
  1053. }
  1054. }
  1055. if ((pip->i_d.di_flags & XFS_DIFLAG_NOATIME) &&
  1056. xfs_inherit_noatime)
  1057. di_flags |= XFS_DIFLAG_NOATIME;
  1058. if ((pip->i_d.di_flags & XFS_DIFLAG_NODUMP) &&
  1059. xfs_inherit_nodump)
  1060. di_flags |= XFS_DIFLAG_NODUMP;
  1061. if ((pip->i_d.di_flags & XFS_DIFLAG_SYNC) &&
  1062. xfs_inherit_sync)
  1063. di_flags |= XFS_DIFLAG_SYNC;
  1064. if ((pip->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) &&
  1065. xfs_inherit_nosymlinks)
  1066. di_flags |= XFS_DIFLAG_NOSYMLINKS;
  1067. if (pip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
  1068. di_flags |= XFS_DIFLAG_PROJINHERIT;
  1069. if ((pip->i_d.di_flags & XFS_DIFLAG_NODEFRAG) &&
  1070. xfs_inherit_nodefrag)
  1071. di_flags |= XFS_DIFLAG_NODEFRAG;
  1072. if (pip->i_d.di_flags & XFS_DIFLAG_FILESTREAM)
  1073. di_flags |= XFS_DIFLAG_FILESTREAM;
  1074. ip->i_d.di_flags |= di_flags;
  1075. }
  1076. /* FALLTHROUGH */
  1077. case S_IFLNK:
  1078. ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
  1079. ip->i_df.if_flags = XFS_IFEXTENTS;
  1080. ip->i_df.if_bytes = ip->i_df.if_real_bytes = 0;
  1081. ip->i_df.if_u1.if_extents = NULL;
  1082. break;
  1083. default:
  1084. ASSERT(0);
  1085. }
  1086. /*
  1087. * Attribute fork settings for new inode.
  1088. */
  1089. ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
  1090. ip->i_d.di_anextents = 0;
  1091. /*
  1092. * Log the new values stuffed into the inode.
  1093. */
  1094. xfs_trans_log_inode(tp, ip, flags);
  1095. /* now that we have an i_mode we can setup inode ops and unlock */
  1096. xfs_setup_inode(ip);
  1097. /* now we have set up the vfs inode we can associate the filestream */
  1098. if (filestreams) {
  1099. error = xfs_filestream_associate(pip, ip);
  1100. if (error < 0)
  1101. return -error;
  1102. if (!error)
  1103. xfs_iflags_set(ip, XFS_IFILESTREAM);
  1104. }
  1105. *ipp = ip;
  1106. return 0;
  1107. }
  1108. /*
  1109. * Check to make sure that there are no blocks allocated to the
  1110. * file beyond the size of the file. We don't check this for
  1111. * files with fixed size extents or real time extents, but we
  1112. * at least do it for regular files.
  1113. */
  1114. #ifdef DEBUG
  1115. void
  1116. xfs_isize_check(
  1117. xfs_mount_t *mp,
  1118. xfs_inode_t *ip,
  1119. xfs_fsize_t isize)
  1120. {
  1121. xfs_fileoff_t map_first;
  1122. int nimaps;
  1123. xfs_bmbt_irec_t imaps[2];
  1124. if ((ip->i_d.di_mode & S_IFMT) != S_IFREG)
  1125. return;
  1126. if (XFS_IS_REALTIME_INODE(ip))
  1127. return;
  1128. if (ip->i_d.di_flags & XFS_DIFLAG_EXTSIZE)
  1129. return;
  1130. nimaps = 2;
  1131. map_first = XFS_B_TO_FSB(mp, (xfs_ufsize_t)isize);
  1132. /*
  1133. * The filesystem could be shutting down, so bmapi may return
  1134. * an error.
  1135. */
  1136. if (xfs_bmapi(NULL, ip, map_first,
  1137. (XFS_B_TO_FSB(mp,
  1138. (xfs_ufsize_t)XFS_MAXIOFFSET(mp)) -
  1139. map_first),
  1140. XFS_BMAPI_ENTIRE, NULL, 0, imaps, &nimaps,
  1141. NULL, NULL))
  1142. return;
  1143. ASSERT(nimaps == 1);
  1144. ASSERT(imaps[0].br_startblock == HOLESTARTBLOCK);
  1145. }
  1146. #endif /* DEBUG */
  1147. /*
  1148. * Calculate the last possible buffered byte in a file. This must
  1149. * include data that was buffered beyond the EOF by the write code.
  1150. * This also needs to deal with overflowing the xfs_fsize_t type
  1151. * which can happen for sizes near the limit.
  1152. *
  1153. * We also need to take into account any blocks beyond the EOF. It
  1154. * may be the case that they were buffered by a write which failed.
  1155. * In that case the pages will still be in memory, but the inode size
  1156. * will never have been updated.
  1157. */
  1158. STATIC xfs_fsize_t
  1159. xfs_file_last_byte(
  1160. xfs_inode_t *ip)
  1161. {
  1162. xfs_mount_t *mp;
  1163. xfs_fsize_t last_byte;
  1164. xfs_fileoff_t last_block;
  1165. xfs_fileoff_t size_last_block;
  1166. int error;
  1167. ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL|XFS_IOLOCK_SHARED));
  1168. mp = ip->i_mount;
  1169. /*
  1170. * Only check for blocks beyond the EOF if the extents have
  1171. * been read in. This eliminates the need for the inode lock,
  1172. * and it also saves us from looking when it really isn't
  1173. * necessary.
  1174. */
  1175. if (ip->i_df.if_flags & XFS_IFEXTENTS) {
  1176. xfs_ilock(ip, XFS_ILOCK_SHARED);
  1177. error = xfs_bmap_last_offset(NULL, ip, &last_block,
  1178. XFS_DATA_FORK);
  1179. xfs_iunlock(ip, XFS_ILOCK_SHARED);
  1180. if (error) {
  1181. last_block = 0;
  1182. }
  1183. } else {
  1184. last_block = 0;
  1185. }
  1186. size_last_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)ip->i_size);
  1187. last_block = XFS_FILEOFF_MAX(last_block, size_last_block);
  1188. last_byte = XFS_FSB_TO_B(mp, last_block);
  1189. if (last_byte < 0) {
  1190. return XFS_MAXIOFFSET(mp);
  1191. }
  1192. last_byte += (1 << mp->m_writeio_log);
  1193. if (last_byte < 0) {
  1194. return XFS_MAXIOFFSET(mp);
  1195. }
  1196. return last_byte;
  1197. }
  1198. /*
  1199. * Start the truncation of the file to new_size. The new size
  1200. * must be smaller than the current size. This routine will
  1201. * clear the buffer and page caches of file data in the removed
  1202. * range, and xfs_itruncate_finish() will remove the underlying
  1203. * disk blocks.
  1204. *
  1205. * The inode must have its I/O lock locked EXCLUSIVELY, and it
  1206. * must NOT have the inode lock held at all. This is because we're
  1207. * calling into the buffer/page cache code and we can't hold the
  1208. * inode lock when we do so.
  1209. *
  1210. * We need to wait for any direct I/Os in flight to complete before we
  1211. * proceed with the truncate. This is needed to prevent the extents
  1212. * being read or written by the direct I/Os from being removed while the
  1213. * I/O is in flight as there is no other method of synchronising
  1214. * direct I/O with the truncate operation. Also, because we hold
  1215. * the IOLOCK in exclusive mode, we prevent new direct I/Os from being
  1216. * started until the truncate completes and drops the lock. Essentially,
  1217. * the xfs_ioend_wait() call forms an I/O barrier that provides strict
  1218. * ordering between direct I/Os and the truncate operation.
  1219. *
  1220. * The flags parameter can have either the value XFS_ITRUNC_DEFINITE
  1221. * or XFS_ITRUNC_MAYBE. The XFS_ITRUNC_MAYBE value should be used
  1222. * in the case that the caller is locking things out of order and
  1223. * may not be able to call xfs_itruncate_finish() with the inode lock
  1224. * held without dropping the I/O lock. If the caller must drop the
  1225. * I/O lock before calling xfs_itruncate_finish(), then xfs_itruncate_start()
  1226. * must be called again with all the same restrictions as the initial
  1227. * call.
  1228. */
  1229. int
  1230. xfs_itruncate_start(
  1231. xfs_inode_t *ip,
  1232. uint flags,
  1233. xfs_fsize_t new_size)
  1234. {
  1235. xfs_fsize_t last_byte;
  1236. xfs_off_t toss_start;
  1237. xfs_mount_t *mp;
  1238. int error = 0;
  1239. ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
  1240. ASSERT((new_size == 0) || (new_size <= ip->i_size));
  1241. ASSERT((flags == XFS_ITRUNC_DEFINITE) ||
  1242. (flags == XFS_ITRUNC_MAYBE));
  1243. mp = ip->i_mount;
  1244. /* wait for the completion of any pending DIOs */
  1245. if (new_size == 0 || new_size < ip->i_size)
  1246. xfs_ioend_wait(ip);
  1247. /*
  1248. * Call toss_pages or flushinval_pages to get rid of pages
  1249. * overlapping the region being removed. We have to use
  1250. * the less efficient flushinval_pages in the case that the
  1251. * caller may not be able to finish the truncate without
  1252. * dropping the inode's I/O lock. Make sure
  1253. * to catch any pages brought in by buffers overlapping
  1254. * the EOF by searching out beyond the isize by our
  1255. * block size. We round new_size up to a block boundary
  1256. * so that we don't toss things on the same block as
  1257. * new_size but before it.
  1258. *
  1259. * Before calling toss_page or flushinval_pages, make sure to
  1260. * call remapf() over the same region if the file is mapped.
  1261. * This frees up mapped file references to the pages in the
  1262. * given range and for the flushinval_pages case it ensures
  1263. * that we get the latest mapped changes flushed out.
  1264. */
  1265. toss_start = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size);
  1266. toss_start = XFS_FSB_TO_B(mp, toss_start);
  1267. if (toss_start < 0) {
  1268. /*
  1269. * The place to start tossing is beyond our maximum
  1270. * file size, so there is no way that the data extended
  1271. * out there.
  1272. */
  1273. return 0;
  1274. }
  1275. last_byte = xfs_file_last_byte(ip);
  1276. trace_xfs_itruncate_start(ip, flags, new_size, toss_start, last_byte);
  1277. if (last_byte > toss_start) {
  1278. if (flags & XFS_ITRUNC_DEFINITE) {
  1279. xfs_tosspages(ip, toss_start,
  1280. -1, FI_REMAPF_LOCKED);
  1281. } else {
  1282. error = xfs_flushinval_pages(ip, toss_start,
  1283. -1, FI_REMAPF_LOCKED);
  1284. }
  1285. }
  1286. #ifdef DEBUG
  1287. if (new_size == 0) {
  1288. ASSERT(VN_CACHED(VFS_I(ip)) == 0);
  1289. }
  1290. #endif
  1291. return error;
  1292. }
  1293. /*
  1294. * Shrink the file to the given new_size. The new size must be smaller than
  1295. * the current size. This will free up the underlying blocks in the removed
  1296. * range after a call to xfs_itruncate_start() or xfs_atruncate_start().
  1297. *
  1298. * The transaction passed to this routine must have made a permanent log
  1299. * reservation of at least XFS_ITRUNCATE_LOG_RES. This routine may commit the
  1300. * given transaction and start new ones, so make sure everything involved in
  1301. * the transaction is tidy before calling here. Some transaction will be
  1302. * returned to the caller to be committed. The incoming transaction must
  1303. * already include the inode, and both inode locks must be held exclusively.
  1304. * The inode must also be "held" within the transaction. On return the inode
  1305. * will be "held" within the returned transaction. This routine does NOT
  1306. * require any disk space to be reserved for it within the transaction.
  1307. *
  1308. * The fork parameter must be either xfs_attr_fork or xfs_data_fork, and it
  1309. * indicates the fork which is to be truncated. For the attribute fork we only
  1310. * support truncation to size 0.
  1311. *
  1312. * We use the sync parameter to indicate whether or not the first transaction
  1313. * we perform might have to be synchronous. For the attr fork, it needs to be
  1314. * so if the unlink of the inode is not yet known to be permanent in the log.
  1315. * This keeps us from freeing and reusing the blocks of the attribute fork
  1316. * before the unlink of the inode becomes permanent.
  1317. *
  1318. * For the data fork, we normally have to run synchronously if we're being
  1319. * called out of the inactive path or we're being called out of the create path
  1320. * where we're truncating an existing file. Either way, the truncate needs to
  1321. * be sync so blocks don't reappear in the file with altered data in case of a
  1322. * crash. wsync filesystems can run the first case async because anything that
  1323. * shrinks the inode has to run sync so by the time we're called here from
  1324. * inactive, the inode size is permanently set to 0.
  1325. *
  1326. * Calls from the truncate path always need to be sync unless we're in a wsync
  1327. * filesystem and the file has already been unlinked.
  1328. *
  1329. * The caller is responsible for correctly setting the sync parameter. It gets
  1330. * too hard for us to guess here which path we're being called out of just
  1331. * based on inode state.
  1332. *
  1333. * If we get an error, we must return with the inode locked and linked into the
  1334. * current transaction. This keeps things simple for the higher level code,
  1335. * because it always knows that the inode is locked and held in the transaction
  1336. * that returns to it whether errors occur or not. We don't mark the inode
  1337. * dirty on error so that transactions can be easily aborted if possible.
  1338. */
  1339. int
  1340. xfs_itruncate_finish(
  1341. xfs_trans_t **tp,
  1342. xfs_inode_t *ip,
  1343. xfs_fsize_t new_size,
  1344. int fork,
  1345. int sync)
  1346. {
  1347. xfs_fsblock_t first_block;
  1348. xfs_fileoff_t first_unmap_block;
  1349. xfs_fileoff_t last_block;
  1350. xfs_filblks_t unmap_len=0;
  1351. xfs_mount_t *mp;
  1352. xfs_trans_t *ntp;
  1353. int done;
  1354. int committed;
  1355. xfs_bmap_free_t free_list;
  1356. int error;
  1357. ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_IOLOCK_EXCL));
  1358. ASSERT((new_size == 0) || (new_size <= ip->i_size));
  1359. ASSERT(*tp != NULL);
  1360. ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES);
  1361. ASSERT(ip->i_transp == *tp);
  1362. ASSERT(ip->i_itemp != NULL);
  1363. ASSERT(ip->i_itemp->ili_flags & XFS_ILI_HOLD);
  1364. ntp = *tp;
  1365. mp = (ntp)->t_mountp;
  1366. ASSERT(! XFS_NOT_DQATTACHED(mp, ip));
  1367. /*
  1368. * We only support truncating the entire attribute fork.
  1369. */
  1370. if (fork == XFS_ATTR_FORK) {
  1371. new_size = 0LL;
  1372. }
  1373. first_unmap_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size);
  1374. trace_xfs_itruncate_finish_start(ip, new_size);
  1375. /*
  1376. * The first thing we do is set the size to new_size permanently
  1377. * on disk. This way we don't have to worry about anyone ever
  1378. * being able to look at the data being freed even in the face
  1379. * of a crash. What we're getting around here is the case where
  1380. * we free a block, it is allocated to another file, it is written
  1381. * to, and then we crash. If the new data gets written to the
  1382. * file but the log buffers containing the free and reallocation
  1383. * don't, then we'd end up with garbage in the blocks being freed.
  1384. * As long as we make the new_size permanent before actually
  1385. * freeing any blocks it doesn't matter if they get writtten to.
  1386. *
  1387. * The callers must signal into us whether or not the size
  1388. * setting here must be synchronous. There are a few cases
  1389. * where it doesn't have to be synchronous. Those cases
  1390. * occur if the file is unlinked and we know the unlink is
  1391. * permanent or if the blocks being truncated are guaranteed
  1392. * to be beyond the inode eof (regardless of the link count)
  1393. * and the eof value is permanent. Both of these cases occur
  1394. * only on wsync-mounted filesystems. In those cases, we're
  1395. * guaranteed that no user will ever see the data in the blocks
  1396. * that are being truncated so the truncate can run async.
  1397. * In the free beyond eof case, the file may wind up with
  1398. * more blocks allocated to it than it needs if we crash
  1399. * and that won't get fixed until the next time the file
  1400. * is re-opened and closed but that's ok as that shouldn't
  1401. * be too many blocks.
  1402. *
  1403. * However, we can't just make all wsync xactions run async
  1404. * because there's one call out of the create path that needs
  1405. * to run sync where it's truncating an existing file to size
  1406. * 0 whose size is > 0.
  1407. *
  1408. * It's probably possible to come up with a test in this
  1409. * routine that would correctly distinguish all the above
  1410. * cases from the values of the function parameters and the
  1411. * inode state but for sanity's sake, I've decided to let the
  1412. * layers above just tell us. It's simpler to correctly figure
  1413. * out in the layer above exactly under what conditions we
  1414. * can run async and I think it's easier for others read and
  1415. * follow the logic in case something has to be changed.
  1416. * cscope is your friend -- rcc.
  1417. *
  1418. * The attribute fork is much simpler.
  1419. *
  1420. * For the attribute fork we allow the caller to tell us whether
  1421. * the unlink of the inode that led to this call is yet permanent
  1422. * in the on disk log. If it is not and we will be freeing extents
  1423. * in this inode then we make the first transaction synchronous
  1424. * to make sure that the unlink is permanent by the time we free
  1425. * the blocks.
  1426. */
  1427. if (fork == XFS_DATA_FORK) {
  1428. if (ip->i_d.di_nextents > 0) {
  1429. /*
  1430. * If we are not changing the file size then do
  1431. * not update the on-disk file size - we may be
  1432. * called from xfs_inactive_free_eofblocks(). If we
  1433. * update the on-disk file size and then the system
  1434. * crashes before the contents of the file are
  1435. * flushed to disk then the files may be full of
  1436. * holes (ie NULL files bug).
  1437. */
  1438. if (ip->i_size != new_size) {
  1439. ip->i_d.di_size = new_size;
  1440. ip->i_size = new_size;
  1441. xfs_trans_log_inode(ntp, ip, XFS_ILOG_CORE);
  1442. }
  1443. }
  1444. } else if (sync) {
  1445. ASSERT(!(mp->m_flags & XFS_MOUNT_WSYNC));
  1446. if (ip->i_d.di_anextents > 0)
  1447. xfs_trans_set_sync(ntp);
  1448. }
  1449. ASSERT(fork == XFS_DATA_FORK ||
  1450. (fork == XFS_ATTR_FORK &&
  1451. ((sync && !(mp->m_flags & XFS_MOUNT_WSYNC)) ||
  1452. (sync == 0 && (mp->m_flags & XFS_MOUNT_WSYNC)))));
  1453. /*
  1454. * Since it is possible for space to become allocated beyond
  1455. * the end of the file (in a crash where the space is allocated
  1456. * but the inode size is not yet updated), simply remove any
  1457. * blocks which show up between the new EOF and the maximum
  1458. * possible file size. If the first block to be removed is
  1459. * beyond the maximum file size (ie it is the same as last_block),
  1460. * then there is nothing to do.
  1461. */
  1462. last_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
  1463. ASSERT(first_unmap_block <= last_block);
  1464. done = 0;
  1465. if (last_block == first_unmap_block) {
  1466. done = 1;
  1467. } else {
  1468. unmap_len = last_block - first_unmap_block + 1;
  1469. }
  1470. while (!done) {
  1471. /*
  1472. * Free up up to XFS_ITRUNC_MAX_EXTENTS. xfs_bunmapi()
  1473. * will tell us whether it freed the entire range or
  1474. * not. If this is a synchronous mount (wsync),
  1475. * then we can tell bunmapi to keep all the
  1476. * transactions asynchronous since the unlink
  1477. * transaction that made this inode inactive has
  1478. * already hit the disk. There's no danger of
  1479. * the freed blocks being reused, there being a
  1480. * crash, and the reused blocks suddenly reappearing
  1481. * in this file with garbage in them once recovery
  1482. * runs.
  1483. */
  1484. xfs_bmap_init(&free_list, &first_block);
  1485. error = xfs_bunmapi(ntp, ip,
  1486. first_unmap_block, unmap_len,
  1487. xfs_bmapi_aflag(fork) |
  1488. (sync ? 0 : XFS_BMAPI_ASYNC),
  1489. XFS_ITRUNC_MAX_EXTENTS,
  1490. &first_block, &free_list,
  1491. NULL, &done);
  1492. if (error) {
  1493. /*
  1494. * If the bunmapi call encounters an error,
  1495. * return to the caller where the transaction
  1496. * can be properly aborted. We just need to
  1497. * make sure we're not holding any resources
  1498. * that we were not when we came in.
  1499. */
  1500. xfs_bmap_cancel(&free_list);
  1501. return error;
  1502. }
  1503. /*
  1504. * Duplicate the transaction that has the permanent
  1505. * reservation and commit the old transaction.
  1506. */
  1507. error = xfs_bmap_finish(tp, &free_list, &committed);
  1508. ntp = *tp;
  1509. if (committed) {
  1510. /* link the inode into the next xact in the chain */
  1511. xfs_trans_ijoin(ntp, ip,
  1512. XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
  1513. xfs_trans_ihold(ntp, ip);
  1514. }
  1515. if (error) {
  1516. /*
  1517. * If the bmap finish call encounters an error, return
  1518. * to the caller where the transaction can be properly
  1519. * aborted. We just need to make sure we're not
  1520. * holding any resources that we were not when we came
  1521. * in.
  1522. *
  1523. * Aborting from this point might lose some blocks in
  1524. * the file system, but oh well.
  1525. */
  1526. xfs_bmap_cancel(&free_list);
  1527. return error;
  1528. }
  1529. if (committed) {
  1530. /*
  1531. * Mark the inode dirty so it will be logged and
  1532. * moved forward in the log as part of every commit.
  1533. */
  1534. xfs_trans_log_inode(ntp, ip, XFS_ILOG_CORE);
  1535. }
  1536. ntp = xfs_trans_dup(ntp);
  1537. error = xfs_trans_commit(*tp, 0);
  1538. *tp = ntp;
  1539. /* link the inode into the next transaction in the chain */
  1540. xfs_trans_ijoin(ntp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
  1541. xfs_trans_ihold(ntp, ip);
  1542. if (error)
  1543. return error;
  1544. /*
  1545. * transaction commit worked ok so we can drop the extra ticket
  1546. * reference that we gained in xfs_trans_dup()
  1547. */
  1548. xfs_log_ticket_put(ntp->t_ticket);
  1549. error = xfs_trans_reserve(ntp, 0,
  1550. XFS_ITRUNCATE_LOG_RES(mp), 0,
  1551. XFS_TRANS_PERM_LOG_RES,
  1552. XFS_ITRUNCATE_LOG_COUNT);
  1553. if (error)
  1554. return error;
  1555. }
  1556. /*
  1557. * Only update the size in the case of the data fork, but
  1558. * always re-log the inode so that our permanent transaction
  1559. * can keep on rolling it forward in the log.
  1560. */
  1561. if (fork == XFS_DATA_FORK) {
  1562. xfs_isize_check(mp, ip, new_size);
  1563. /*
  1564. * If we are not changing the file size then do
  1565. * not update the on-disk file size - we may be
  1566. * called from xfs_inactive_free_eofblocks(). If we
  1567. * update the on-disk file size and then the system
  1568. * crashes before the contents of the file are
  1569. * flushed to disk then the files may be full of
  1570. * holes (ie NULL files bug).
  1571. */
  1572. if (ip->i_size != new_size) {
  1573. ip->i_d.di_size = new_size;
  1574. ip->i_size = new_size;
  1575. }
  1576. }
  1577. xfs_trans_log_inode(ntp, ip, XFS_ILOG_CORE);
  1578. ASSERT((new_size != 0) ||
  1579. (fork == XFS_ATTR_FORK) ||
  1580. (ip->i_delayed_blks == 0));
  1581. ASSERT((new_size != 0) ||
  1582. (fork == XFS_ATTR_FORK) ||
  1583. (ip->i_d.di_nextents == 0));
  1584. trace_xfs_itruncate_finish_end(ip, new_size);
  1585. return 0;
  1586. }
  1587. /*
  1588. * This is called when the inode's link count goes to 0.
  1589. * We place the on-disk inode on a list in the AGI. It
  1590. * will be pulled from this list when the inode is freed.
  1591. */
  1592. int
  1593. xfs_iunlink(
  1594. xfs_trans_t *tp,
  1595. xfs_inode_t *ip)
  1596. {
  1597. xfs_mount_t *mp;
  1598. xfs_agi_t *agi;
  1599. xfs_dinode_t *dip;
  1600. xfs_buf_t *agibp;
  1601. xfs_buf_t *ibp;
  1602. xfs_agino_t agino;
  1603. short bucket_index;
  1604. int offset;
  1605. int error;
  1606. ASSERT(ip->i_d.di_nlink == 0);
  1607. ASSERT(ip->i_d.di_mode != 0);
  1608. ASSERT(ip->i_transp == tp);
  1609. mp = tp->t_mountp;
  1610. /*
  1611. * Get the agi buffer first. It ensures lock ordering
  1612. * on the list.
  1613. */
  1614. error = xfs_read_agi(mp, tp, XFS_INO_TO_AGNO(mp, ip->i_ino), &agibp);
  1615. if (error)
  1616. return error;
  1617. agi = XFS_BUF_TO_AGI(agibp);
  1618. /*
  1619. * Get the index into the agi hash table for the
  1620. * list this inode will go on.
  1621. */
  1622. agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
  1623. ASSERT(agino != 0);
  1624. bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
  1625. ASSERT(agi->agi_unlinked[bucket_index]);
  1626. ASSERT(be32_to_cpu(agi->agi_unlinked[bucket_index]) != agino);
  1627. if (be32_to_cpu(agi->agi_unlinked[bucket_index]) != NULLAGINO) {
  1628. /*
  1629. * There is already another inode in the bucket we need
  1630. * to add ourselves to. Add us at the front of the list.
  1631. * Here we put the head pointer into our next pointer,
  1632. * and then we fall through to point the head at us.
  1633. */
  1634. error = xfs_itobp(mp, tp, ip, &dip, &ibp, XBF_LOCK);
  1635. if (error)
  1636. return error;
  1637. ASSERT(be32_to_cpu(dip->di_next_unlinked) == NULLAGINO);
  1638. /* both on-disk, don't endian flip twice */
  1639. dip->di_next_unlinked = agi->agi_unlinked[bucket_index];
  1640. offset = ip->i_imap.im_boffset +
  1641. offsetof(xfs_dinode_t, di_next_unlinked);
  1642. xfs_trans_inode_buf(tp, ibp);
  1643. xfs_trans_log_buf(tp, ibp, offset,
  1644. (offset + sizeof(xfs_agino_t) - 1));
  1645. xfs_inobp_check(mp, ibp);
  1646. }
  1647. /*
  1648. * Point the bucket head pointer at the inode being inserted.
  1649. */
  1650. ASSERT(agino != 0);
  1651. agi->agi_unlinked[bucket_index] = cpu_to_be32(agino);
  1652. offset = offsetof(xfs_agi_t, agi_unlinked) +
  1653. (sizeof(xfs_agino_t) * bucket_index);
  1654. xfs_trans_log_buf(tp, agibp, offset,
  1655. (offset + sizeof(xfs_agino_t) - 1));
  1656. return 0;
  1657. }
  1658. /*
  1659. * Pull the on-disk inode from the AGI unlinked list.
  1660. */
  1661. STATIC int
  1662. xfs_iunlink_remove(
  1663. xfs_trans_t *tp,
  1664. xfs_inode_t *ip)
  1665. {
  1666. xfs_ino_t next_ino;
  1667. xfs_mount_t *mp;
  1668. xfs_agi_t *agi;
  1669. xfs_dinode_t *dip;
  1670. xfs_buf_t *agibp;
  1671. xfs_buf_t *ibp;
  1672. xfs_agnumber_t agno;
  1673. xfs_agino_t agino;
  1674. xfs_agino_t next_agino;
  1675. xfs_buf_t *last_ibp;
  1676. xfs_dinode_t *last_dip = NULL;
  1677. short bucket_index;
  1678. int offset, last_offset = 0;
  1679. int error;
  1680. mp = tp->t_mountp;
  1681. agno = XFS_INO_TO_AGNO(mp, ip->i_ino);
  1682. /*
  1683. * Get the agi buffer first. It ensures lock ordering
  1684. * on the list.
  1685. */
  1686. error = xfs_read_agi(mp, tp, agno, &agibp);
  1687. if (error)
  1688. return error;
  1689. agi = XFS_BUF_TO_AGI(agibp);
  1690. /*
  1691. * Get the index into the agi hash table for the
  1692. * list this inode will go on.
  1693. */
  1694. agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
  1695. ASSERT(agino != 0);
  1696. bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
  1697. ASSERT(be32_to_cpu(agi->agi_unlinked[bucket_index]) != NULLAGINO);
  1698. ASSERT(agi->agi_unlinked[bucket_index]);
  1699. if (be32_to_cpu(agi->agi_unlinked[bucket_index]) == agino) {
  1700. /*
  1701. * We're at the head of the list. Get the inode's
  1702. * on-disk buffer to see if there is anyone after us
  1703. * on the list. Only modify our next pointer if it
  1704. * is not already NULLAGINO. This saves us the overhead
  1705. * of dealing with the buffer when there is no need to
  1706. * change it.
  1707. */
  1708. error = xfs_itobp(mp, tp, ip, &dip, &ibp, XBF_LOCK);
  1709. if (error) {
  1710. cmn_err(CE_WARN,
  1711. "xfs_iunlink_remove: xfs_itobp() returned an error %d on %s. Returning error.",
  1712. error, mp->m_fsname);
  1713. return error;
  1714. }
  1715. next_agino = be32_to_cpu(dip->di_next_unlinked);
  1716. ASSERT(next_agino != 0);
  1717. if (next_agino != NULLAGINO) {
  1718. dip->di_next_unlinked = cpu_to_be32(NULLAGINO);
  1719. offset = ip->i_imap.im_boffset +
  1720. offsetof(xfs_dinode_t, di_next_unlinked);
  1721. xfs_trans_inode_buf(tp, ibp);
  1722. xfs_trans_log_buf(tp, ibp, offset,
  1723. (offset + sizeof(xfs_agino_t) - 1));
  1724. xfs_inobp_check(mp, ibp);
  1725. } else {
  1726. xfs_trans_brelse(tp, ibp);
  1727. }
  1728. /*
  1729. * Point the bucket head pointer at the next inode.
  1730. */
  1731. ASSERT(next_agino != 0);
  1732. ASSERT(next_agino != agino);
  1733. agi->agi_unlinked[bucket_index] = cpu_to_be32(next_agino);
  1734. offset = offsetof(xfs_agi_t, agi_unlinked) +
  1735. (sizeof(xfs_agino_t) * bucket_index);
  1736. xfs_trans_log_buf(tp, agibp, offset,
  1737. (offset + sizeof(xfs_agino_t) - 1));
  1738. } else {
  1739. /*
  1740. * We need to search the list for the inode being freed.
  1741. */
  1742. next_agino = be32_to_cpu(agi->agi_unlinked[bucket_index]);
  1743. last_ibp = NULL;
  1744. while (next_agino != agino) {
  1745. /*
  1746. * If the last inode wasn't the one pointing to
  1747. * us, then release its buffer since we're not
  1748. * going to do anything with it.
  1749. */
  1750. if (last_ibp != NULL) {
  1751. xfs_trans_brelse(tp, last_ibp);
  1752. }
  1753. next_ino = XFS_AGINO_TO_INO(mp, agno, next_agino);
  1754. error = xfs_inotobp(mp, tp, next_ino, &last_dip,
  1755. &last_ibp, &last_offset, 0);
  1756. if (error) {
  1757. cmn_err(CE_WARN,
  1758. "xfs_iunlink_remove: xfs_inotobp() returned an error %d on %s. Returning error.",
  1759. error, mp->m_fsname);
  1760. return error;
  1761. }
  1762. next_agino = be32_to_cpu(last_dip->di_next_unlinked);
  1763. ASSERT(next_agino != NULLAGINO);
  1764. ASSERT(next_agino != 0);
  1765. }
  1766. /*
  1767. * Now last_ibp points to the buffer previous to us on
  1768. * the unlinked list. Pull us from the list.
  1769. */
  1770. error = xfs_itobp(mp, tp, ip, &dip, &ibp, XBF_LOCK);
  1771. if (error) {
  1772. cmn_err(CE_WARN,
  1773. "xfs_iunlink_remove: xfs_itobp() returned an error %d on %s. Returning error.",
  1774. error, mp->m_fsname);
  1775. return error;
  1776. }
  1777. next_agino = be32_to_cpu(dip->di_next_unlinked);
  1778. ASSERT(next_agino != 0);
  1779. ASSERT(next_agino != agino);
  1780. if (next_agino != NULLAGINO) {
  1781. dip->di_next_unlinked = cpu_to_be32(NULLAGINO);
  1782. offset = ip->i_imap.im_boffset +
  1783. offsetof(xfs_dinode_t, di_next_unlinked);
  1784. xfs_trans_inode_buf(tp, ibp);
  1785. xfs_trans_log_buf(tp, ibp, offset,
  1786. (offset + sizeof(xfs_agino_t) - 1));
  1787. xfs_inobp_check(mp, ibp);
  1788. } else {
  1789. xfs_trans_brelse(tp, ibp);
  1790. }
  1791. /*
  1792. * Point the previous inode on the list to the next inode.
  1793. */
  1794. last_dip->di_next_unlinked = cpu_to_be32(next_agino);
  1795. ASSERT(next_agino != 0);
  1796. offset = last_offset + offsetof(xfs_dinode_t, di_next_unlinked);
  1797. xfs_trans_inode_buf(tp, last_ibp);
  1798. xfs_trans_log_buf(tp, last_ibp, offset,
  1799. (offset + sizeof(xfs_agino_t) - 1));
  1800. xfs_inobp_check(mp, last_ibp);
  1801. }
  1802. return 0;
  1803. }
  1804. STATIC void
  1805. xfs_ifree_cluster(
  1806. xfs_inode_t *free_ip,
  1807. xfs_trans_t *tp,
  1808. xfs_ino_t inum)
  1809. {
  1810. xfs_mount_t *mp = free_ip->i_mount;
  1811. int blks_per_cluster;
  1812. int nbufs;
  1813. int ninodes;
  1814. int i, j, found, pre_flushed;
  1815. xfs_daddr_t blkno;
  1816. xfs_buf_t *bp;
  1817. xfs_inode_t *ip, **ip_found;
  1818. xfs_inode_log_item_t *iip;
  1819. xfs_log_item_t *lip;
  1820. struct xfs_perag *pag;
  1821. pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, inum));
  1822. if (mp->m_sb.sb_blocksize >= XFS_INODE_CLUSTER_SIZE(mp)) {
  1823. blks_per_cluster = 1;
  1824. ninodes = mp->m_sb.sb_inopblock;
  1825. nbufs = XFS_IALLOC_BLOCKS(mp);
  1826. } else {
  1827. blks_per_cluster = XFS_INODE_CLUSTER_SIZE(mp) /
  1828. mp->m_sb.sb_blocksize;
  1829. ninodes = blks_per_cluster * mp->m_sb.sb_inopblock;
  1830. nbufs = XFS_IALLOC_BLOCKS(mp) / blks_per_cluster;
  1831. }
  1832. ip_found = kmem_alloc(ninodes * sizeof(xfs_inode_t *), KM_NOFS);
  1833. for (j = 0; j < nbufs; j++, inum += ninodes) {
  1834. blkno = XFS_AGB_TO_DADDR(mp, XFS_INO_TO_AGNO(mp, inum),
  1835. XFS_INO_TO_AGBNO(mp, inum));
  1836. /*
  1837. * Look for each inode in memory and attempt to lock it,
  1838. * we can be racing with flush and tail pushing here.
  1839. * any inode we get the locks on, add to an array of
  1840. * inode items to process later.
  1841. *
  1842. * The get the buffer lock, we could beat a flush
  1843. * or tail pushing thread to the lock here, in which
  1844. * case they will go looking for the inode buffer
  1845. * and fail, we need some other form of interlock
  1846. * here.
  1847. */
  1848. found = 0;
  1849. for (i = 0; i < ninodes; i++) {
  1850. read_lock(&pag->pag_ici_lock);
  1851. ip = radix_tree_lookup(&pag->pag_ici_root,
  1852. XFS_INO_TO_AGINO(mp, (inum + i)));
  1853. /* Inode not in memory or we found it already,
  1854. * nothing to do
  1855. */
  1856. if (!ip || xfs_iflags_test(ip, XFS_ISTALE)) {
  1857. read_unlock(&pag->pag_ici_lock);
  1858. continue;
  1859. }
  1860. if (xfs_inode_clean(ip)) {
  1861. read_unlock(&pag->pag_ici_lock);
  1862. continue;
  1863. }
  1864. /* If we can get the locks then add it to the
  1865. * list, otherwise by the time we get the bp lock
  1866. * below it will already be attached to the
  1867. * inode buffer.
  1868. */
  1869. /* This inode will already be locked - by us, lets
  1870. * keep it that way.
  1871. */
  1872. if (ip == free_ip) {
  1873. if (xfs_iflock_nowait(ip)) {
  1874. xfs_iflags_set(ip, XFS_ISTALE);
  1875. if (xfs_inode_clean(ip)) {
  1876. xfs_ifunlock(ip);
  1877. } else {
  1878. ip_found[found++] = ip;
  1879. }
  1880. }
  1881. read_unlock(&pag->pag_ici_lock);
  1882. continue;
  1883. }
  1884. if (xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
  1885. if (xfs_iflock_nowait(ip)) {
  1886. xfs_iflags_set(ip, XFS_ISTALE);
  1887. if (xfs_inode_clean(ip)) {
  1888. xfs_ifunlock(ip);
  1889. xfs_iunlock(ip, XFS_ILOCK_EXCL);
  1890. } else {
  1891. ip_found[found++] = ip;
  1892. }
  1893. } else {
  1894. xfs_iunlock(ip, XFS_ILOCK_EXCL);
  1895. }
  1896. }
  1897. read_unlock(&pag->pag_ici_lock);
  1898. }
  1899. bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, blkno,
  1900. mp->m_bsize * blks_per_cluster,
  1901. XBF_LOCK);
  1902. pre_flushed = 0;
  1903. lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
  1904. while (lip) {
  1905. if (lip->li_type == XFS_LI_INODE) {
  1906. iip = (xfs_inode_log_item_t *)lip;
  1907. ASSERT(iip->ili_logged == 1);
  1908. lip->li_cb = (void(*)(xfs_buf_t*,xfs_log_item_t*)) xfs_istale_done;
  1909. xfs_trans_ail_copy_lsn(mp->m_ail,
  1910. &iip->ili_flush_lsn,
  1911. &iip->ili_item.li_lsn);
  1912. xfs_iflags_set(iip->ili_inode, XFS_ISTALE);
  1913. pre_flushed++;
  1914. }
  1915. lip = lip->li_bio_list;
  1916. }
  1917. for (i = 0; i < found; i++) {
  1918. ip = ip_found[i];
  1919. iip = ip->i_itemp;
  1920. if (!iip) {
  1921. ip->i_update_core = 0;
  1922. xfs_ifunlock(ip);
  1923. xfs_iunlock(ip, XFS_ILOCK_EXCL);
  1924. continue;
  1925. }
  1926. iip->ili_last_fields = iip->ili_format.ilf_fields;
  1927. iip->ili_format.ilf_fields = 0;
  1928. iip->ili_logged = 1;
  1929. xfs_trans_ail_copy_lsn(mp->m_ail, &iip->ili_flush_lsn,
  1930. &iip->ili_item.li_lsn);
  1931. xfs_buf_attach_iodone(bp,
  1932. (void(*)(xfs_buf_t*,xfs_log_item_t*))
  1933. xfs_istale_done, (xfs_log_item_t *)iip);
  1934. if (ip != free_ip) {
  1935. xfs_iunlock(ip, XFS_ILOCK_EXCL);
  1936. }
  1937. }
  1938. if (found || pre_flushed)
  1939. xfs_trans_stale_inode_buf(tp, bp);
  1940. xfs_trans_binval(tp, bp);
  1941. }
  1942. kmem_free(ip_found);
  1943. xfs_perag_put(pag);
  1944. }
  1945. /*
  1946. * This is called to return an inode to the inode free list.
  1947. * The inode should already be truncated to 0 length and have
  1948. * no pages associated with it. This routine also assumes that
  1949. * the inode is already a part of the transaction.
  1950. *
  1951. * The on-disk copy of the inode will have been added to the list
  1952. * of unlinked inodes in the AGI. We need to remove the inode from
  1953. * that list atomically with respect to freeing it here.
  1954. */
  1955. int
  1956. xfs_ifree(
  1957. xfs_trans_t *tp,
  1958. xfs_inode_t *ip,
  1959. xfs_bmap_free_t *flist)
  1960. {
  1961. int error;
  1962. int delete;
  1963. xfs_ino_t first_ino;
  1964. xfs_dinode_t *dip;
  1965. xfs_buf_t *ibp;
  1966. ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
  1967. ASSERT(ip->i_transp == tp);
  1968. ASSERT(ip->i_d.di_nlink == 0);
  1969. ASSERT(ip->i_d.di_nextents == 0);
  1970. ASSERT(ip->i_d.di_anextents == 0);
  1971. ASSERT((ip->i_d.di_size == 0 && ip->i_size == 0) ||
  1972. ((ip->i_d.di_mode & S_IFMT) != S_IFREG));
  1973. ASSERT(ip->i_d.di_nblocks == 0);
  1974. /*
  1975. * Pull the on-disk inode from the AGI unlinked list.
  1976. */
  1977. error = xfs_iunlink_remove(tp, ip);
  1978. if (error != 0) {
  1979. return error;
  1980. }
  1981. error = xfs_difree(tp, ip->i_ino, flist, &delete, &first_ino);
  1982. if (error != 0) {
  1983. return error;
  1984. }
  1985. ip->i_d.di_mode = 0; /* mark incore inode as free */
  1986. ip->i_d.di_flags = 0;
  1987. ip->i_d.di_dmevmask = 0;
  1988. ip->i_d.di_forkoff = 0; /* mark the attr fork not in use */
  1989. ip->i_df.if_ext_max =
  1990. XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
  1991. ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
  1992. ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
  1993. /*
  1994. * Bump the generation count so no one will be confused
  1995. * by reincarnations of this inode.
  1996. */
  1997. ip->i_d.di_gen++;
  1998. xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
  1999. error = xfs_itobp(ip->i_mount, tp, ip, &dip, &ibp, XBF_LOCK);
  2000. if (error)
  2001. return error;
  2002. /*
  2003. * Clear the on-disk di_mode. This is to prevent xfs_bulkstat
  2004. * from picking up this inode when it is reclaimed (its incore state
  2005. * initialzed but not flushed to disk yet). The in-core di_mode is
  2006. * already cleared and a corresponding transaction logged.
  2007. * The hack here just synchronizes the in-core to on-disk
  2008. * di_mode value in advance before the actual inode sync to disk.
  2009. * This is OK because the inode is already unlinked and would never
  2010. * change its di_mode again for this inode generation.
  2011. * This is a temporary hack that would require a proper fix
  2012. * in the future.
  2013. */
  2014. dip->di_mode = 0;
  2015. if (delete) {
  2016. xfs_ifree_cluster(ip, tp, first_ino);
  2017. }
  2018. return 0;
  2019. }
  2020. /*
  2021. * Reallocate the space for if_broot based on the number of records
  2022. * being added or deleted as indicated in rec_diff. Move the records
  2023. * and pointers in if_broot to fit the new size. When shrinking this
  2024. * will eliminate holes between the records and pointers created by
  2025. * the caller. When growing this will create holes to be filled in
  2026. * by the caller.
  2027. *
  2028. * The caller must not request to add more records than would fit in
  2029. * the on-disk inode root. If the if_broot is currently NULL, then
  2030. * if we adding records one will be allocated. The caller must also
  2031. * not request that the number of records go below zero, although
  2032. * it can go to zero.
  2033. *
  2034. * ip -- the inode whose if_broot area is changing
  2035. * ext_diff -- the change in the number of records, positive or negative,
  2036. * requested for the if_broot array.
  2037. */
  2038. void
  2039. xfs_iroot_realloc(
  2040. xfs_inode_t *ip,
  2041. int rec_diff,
  2042. int whichfork)
  2043. {
  2044. struct xfs_mount *mp = ip->i_mount;
  2045. int cur_max;
  2046. xfs_ifork_t *ifp;
  2047. struct xfs_btree_block *new_broot;
  2048. int new_max;
  2049. size_t new_size;
  2050. char *np;
  2051. char *op;
  2052. /*
  2053. * Handle the degenerate case quietly.
  2054. */
  2055. if (rec_diff == 0) {
  2056. return;
  2057. }
  2058. ifp = XFS_IFORK_PTR(ip, whichfork);
  2059. if (rec_diff > 0) {
  2060. /*
  2061. * If there wasn't any memory allocated before, just
  2062. * allocate it now and get out.
  2063. */
  2064. if (ifp->if_broot_bytes == 0) {
  2065. new_size = (size_t)XFS_BMAP_BROOT_SPACE_CALC(rec_diff);
  2066. ifp->if_broot = kmem_alloc(new_size, KM_SLEEP);
  2067. ifp->if_broot_bytes = (int)new_size;
  2068. return;
  2069. }
  2070. /*
  2071. * If there is already an existing if_broot, then we need
  2072. * to realloc() it and shift the pointers to their new
  2073. * location. The records don't change location because
  2074. * they are kept butted up against the btree block header.
  2075. */
  2076. cur_max = xfs_bmbt_maxrecs(mp, ifp->if_broot_bytes, 0);
  2077. new_max = cur_max + rec_diff;
  2078. new_size = (size_t)XFS_BMAP_BROOT_SPACE_CALC(new_max);
  2079. ifp->if_broot = kmem_realloc(ifp->if_broot, new_size,
  2080. (size_t)XFS_BMAP_BROOT_SPACE_CALC(cur_max), /* old size */
  2081. KM_SLEEP);
  2082. op = (char *)XFS_BMAP_BROOT_PTR_ADDR(mp, ifp->if_broot, 1,
  2083. ifp->if_broot_bytes);
  2084. np = (char *)XFS_BMAP_BROOT_PTR_ADDR(mp, ifp->if_broot, 1,
  2085. (int)new_size);
  2086. ifp->if_broot_bytes = (int)new_size;
  2087. ASSERT(ifp->if_broot_bytes <=
  2088. XFS_IFORK_SIZE(ip, whichfork) + XFS_BROOT_SIZE_ADJ);
  2089. memmove(np, op, cur_max * (uint)sizeof(xfs_dfsbno_t));
  2090. return;
  2091. }
  2092. /*
  2093. * rec_diff is less than 0. In this case, we are shrinking the
  2094. * if_broot buffer. It must already exist. If we go to zero
  2095. * records, just get rid of the root and clear the status bit.
  2096. */
  2097. ASSERT((ifp->if_broot != NULL) && (ifp->if_broot_bytes > 0));
  2098. cur_max = xfs_bmbt_maxrecs(mp, ifp->if_broot_bytes, 0);
  2099. new_max = cur_max + rec_diff;
  2100. ASSERT(new_max >= 0);
  2101. if (new_max > 0)
  2102. new_size = (size_t)XFS_BMAP_BROOT_SPACE_CALC(new_max);
  2103. else
  2104. new_size = 0;
  2105. if (new_size > 0) {
  2106. new_broot = kmem_alloc(new_size, KM_SLEEP);
  2107. /*
  2108. * First copy over the btree block header.
  2109. */
  2110. memcpy(new_broot, ifp->if_broot, XFS_BTREE_LBLOCK_LEN);
  2111. } else {
  2112. new_broot = NULL;
  2113. ifp->if_flags &= ~XFS_IFBROOT;
  2114. }
  2115. /*
  2116. * Only copy the records and pointers if there are any.
  2117. */
  2118. if (new_max > 0) {
  2119. /*
  2120. * First copy the records.
  2121. */
  2122. op = (char *)XFS_BMBT_REC_ADDR(mp, ifp->if_broot, 1);
  2123. np = (char *)XFS_BMBT_REC_ADDR(mp, new_broot, 1);
  2124. memcpy(np, op, new_max * (uint)sizeof(xfs_bmbt_rec_t));
  2125. /*
  2126. * Then copy the pointers.
  2127. */
  2128. op = (char *)XFS_BMAP_BROOT_PTR_ADDR(mp, ifp->if_broot, 1,
  2129. ifp->if_broot_bytes);
  2130. np = (char *)XFS_BMAP_BROOT_PTR_ADDR(mp, new_broot, 1,
  2131. (int)new_size);
  2132. memcpy(np, op, new_max * (uint)sizeof(xfs_dfsbno_t));
  2133. }
  2134. kmem_free(ifp->if_broot);
  2135. ifp->if_broot = new_broot;
  2136. ifp->if_broot_bytes = (int)new_size;
  2137. ASSERT(ifp->if_broot_bytes <=
  2138. XFS_IFORK_SIZE(ip, whichfork) + XFS_BROOT_SIZE_ADJ);
  2139. return;
  2140. }
  2141. /*
  2142. * This is called when the amount of space needed for if_data
  2143. * is increased or decreased. The change in size is indicated by
  2144. * the number of bytes that need to be added or deleted in the
  2145. * byte_diff parameter.
  2146. *
  2147. * If the amount of space needed has decreased below the size of the
  2148. * inline buffer, then switch to using the inline buffer. Otherwise,
  2149. * use kmem_realloc() or kmem_alloc() to adjust the size of the buffer
  2150. * to what is needed.
  2151. *
  2152. * ip -- the inode whose if_data area is changing
  2153. * byte_diff -- the change in the number of bytes, positive or negative,
  2154. * requested for the if_data array.
  2155. */
  2156. void
  2157. xfs_idata_realloc(
  2158. xfs_inode_t *ip,
  2159. int byte_diff,
  2160. int whichfork)
  2161. {
  2162. xfs_ifork_t *ifp;
  2163. int new_size;
  2164. int real_size;
  2165. if (byte_diff == 0) {
  2166. return;
  2167. }
  2168. ifp = XFS_IFORK_PTR(ip, whichfork);
  2169. new_size = (int)ifp->if_bytes + byte_diff;
  2170. ASSERT(new_size >= 0);
  2171. if (new_size == 0) {
  2172. if (ifp->if_u1.if_data != ifp->if_u2.if_inline_data) {
  2173. kmem_free(ifp->if_u1.if_data);
  2174. }
  2175. ifp->if_u1.if_data = NULL;
  2176. real_size = 0;
  2177. } else if (new_size <= sizeof(ifp->if_u2.if_inline_data)) {
  2178. /*
  2179. * If the valid extents/data can fit in if_inline_ext/data,
  2180. * copy them from the malloc'd vector and free it.
  2181. */
  2182. if (ifp->if_u1.if_data == NULL) {
  2183. ifp->if_u1.if_data = ifp->if_u2.if_inline_data;
  2184. } else if (ifp->if_u1.if_data != ifp->if_u2.if_inline_data) {
  2185. ASSERT(ifp->if_real_bytes != 0);
  2186. memcpy(ifp->if_u2.if_inline_data, ifp->if_u1.if_data,
  2187. new_size);
  2188. kmem_free(ifp->if_u1.if_data);
  2189. ifp->if_u1.if_data = ifp->if_u2.if_inline_data;
  2190. }
  2191. real_size = 0;
  2192. } else {
  2193. /*
  2194. * Stuck with malloc/realloc.
  2195. * For inline data, the underlying buffer must be
  2196. * a multiple of 4 bytes in size so that it can be
  2197. * logged and stay on word boundaries. We enforce
  2198. * that here.
  2199. */
  2200. real_size = roundup(new_size, 4);
  2201. if (ifp->if_u1.if_data == NULL) {
  2202. ASSERT(ifp->if_real_bytes == 0);
  2203. ifp->if_u1.if_data = kmem_alloc(real_size, KM_SLEEP);
  2204. } else if (ifp->if_u1.if_data != ifp->if_u2.if_inline_data) {
  2205. /*
  2206. * Only do the realloc if the underlying size
  2207. * is really changing.
  2208. */
  2209. if (ifp->if_real_bytes != real_size) {
  2210. ifp->if_u1.if_data =
  2211. kmem_realloc(ifp->if_u1.if_data,
  2212. real_size,
  2213. ifp->if_real_bytes,
  2214. KM_SLEEP);
  2215. }
  2216. } else {
  2217. ASSERT(ifp->if_real_bytes == 0);
  2218. ifp->if_u1.if_data = kmem_alloc(real_size, KM_SLEEP);
  2219. memcpy(ifp->if_u1.if_data, ifp->if_u2.if_inline_data,
  2220. ifp->if_bytes);
  2221. }
  2222. }
  2223. ifp->if_real_bytes = real_size;
  2224. ifp->if_bytes = new_size;
  2225. ASSERT(ifp->if_bytes <= XFS_IFORK_SIZE(ip, whichfork));
  2226. }
  2227. void
  2228. xfs_idestroy_fork(
  2229. xfs_inode_t *ip,
  2230. int whichfork)
  2231. {
  2232. xfs_ifork_t *ifp;
  2233. ifp = XFS_IFORK_PTR(ip, whichfork);
  2234. if (ifp->if_broot != NULL) {
  2235. kmem_free(ifp->if_broot);
  2236. ifp->if_broot = NULL;
  2237. }
  2238. /*
  2239. * If the format is local, then we can't have an extents
  2240. * array so just look for an inline data array. If we're
  2241. * not local then we may or may not have an extents list,
  2242. * so check and free it up if we do.
  2243. */
  2244. if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) {
  2245. if ((ifp->if_u1.if_data != ifp->if_u2.if_inline_data) &&
  2246. (ifp->if_u1.if_data != NULL)) {
  2247. ASSERT(ifp->if_real_bytes != 0);
  2248. kmem_free(ifp->if_u1.if_data);
  2249. ifp->if_u1.if_data = NULL;
  2250. ifp->if_real_bytes = 0;
  2251. }
  2252. } else if ((ifp->if_flags & XFS_IFEXTENTS) &&
  2253. ((ifp->if_flags & XFS_IFEXTIREC) ||
  2254. ((ifp->if_u1.if_extents != NULL) &&
  2255. (ifp->if_u1.if_extents != ifp->if_u2.if_inline_ext)))) {
  2256. ASSERT(ifp->if_real_bytes != 0);
  2257. xfs_iext_destroy(ifp);
  2258. }
  2259. ASSERT(ifp->if_u1.if_extents == NULL ||
  2260. ifp->if_u1.if_extents == ifp->if_u2.if_inline_ext);
  2261. ASSERT(ifp->if_real_bytes == 0);
  2262. if (whichfork == XFS_ATTR_FORK) {
  2263. kmem_zone_free(xfs_ifork_zone, ip->i_afp);
  2264. ip->i_afp = NULL;
  2265. }
  2266. }
  2267. /*
  2268. * Increment the pin count of the given buffer.
  2269. * This value is protected by ipinlock spinlock in the mount structure.
  2270. */
  2271. void
  2272. xfs_ipin(
  2273. xfs_inode_t *ip)
  2274. {
  2275. ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
  2276. atomic_inc(&ip->i_pincount);
  2277. }
  2278. /*
  2279. * Decrement the pin count of the given inode, and wake up
  2280. * anyone in xfs_iwait_unpin() if the count goes to 0. The
  2281. * inode must have been previously pinned with a call to xfs_ipin().
  2282. */
  2283. void
  2284. xfs_iunpin(
  2285. xfs_inode_t *ip)
  2286. {
  2287. ASSERT(atomic_read(&ip->i_pincount) > 0);
  2288. if (atomic_dec_and_test(&ip->i_pincount))
  2289. wake_up(&ip->i_ipin_wait);
  2290. }
  2291. /*
  2292. * This is called to unpin an inode. It can be directed to wait or to return
  2293. * immediately without waiting for the inode to be unpinned. The caller must
  2294. * have the inode locked in at least shared mode so that the buffer cannot be
  2295. * subsequently pinned once someone is waiting for it to be unpinned.
  2296. */
  2297. STATIC void
  2298. __xfs_iunpin_wait(
  2299. xfs_inode_t *ip,
  2300. int wait)
  2301. {
  2302. xfs_inode_log_item_t *iip = ip->i_itemp;
  2303. ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
  2304. if (atomic_read(&ip->i_pincount) == 0)
  2305. return;
  2306. /* Give the log a push to start the unpinning I/O */
  2307. if (iip && iip->ili_last_lsn)
  2308. xfs_log_force_lsn(ip->i_mount, iip->ili_last_lsn, 0);
  2309. else
  2310. xfs_log_force(ip->i_mount, 0);
  2311. if (wait)
  2312. wait_event(ip->i_ipin_wait, (atomic_read(&ip->i_pincount) == 0));
  2313. }
  2314. void
  2315. xfs_iunpin_wait(
  2316. xfs_inode_t *ip)
  2317. {
  2318. __xfs_iunpin_wait(ip, 1);
  2319. }
  2320. static inline void
  2321. xfs_iunpin_nowait(
  2322. xfs_inode_t *ip)
  2323. {
  2324. __xfs_iunpin_wait(ip, 0);
  2325. }
  2326. /*
  2327. * xfs_iextents_copy()
  2328. *
  2329. * This is called to copy the REAL extents (as opposed to the delayed
  2330. * allocation extents) from the inode into the given buffer. It
  2331. * returns the number of bytes copied into the buffer.
  2332. *
  2333. * If there are no delayed allocation extents, then we can just
  2334. * memcpy() the extents into the buffer. Otherwise, we need to
  2335. * examine each extent in turn and skip those which are delayed.
  2336. */
  2337. int
  2338. xfs_iextents_copy(
  2339. xfs_inode_t *ip,
  2340. xfs_bmbt_rec_t *dp,
  2341. int whichfork)
  2342. {
  2343. int copied;
  2344. int i;
  2345. xfs_ifork_t *ifp;
  2346. int nrecs;
  2347. xfs_fsblock_t start_block;
  2348. ifp = XFS_IFORK_PTR(ip, whichfork);
  2349. ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
  2350. ASSERT(ifp->if_bytes > 0);
  2351. nrecs = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
  2352. XFS_BMAP_TRACE_EXLIST(ip, nrecs, whichfork);
  2353. ASSERT(nrecs > 0);
  2354. /*
  2355. * There are some delayed allocation extents in the
  2356. * inode, so copy the extents one at a time and skip
  2357. * the delayed ones. There must be at least one
  2358. * non-delayed extent.
  2359. */
  2360. copied = 0;
  2361. for (i = 0; i < nrecs; i++) {
  2362. xfs_bmbt_rec_host_t *ep = xfs_iext_get_ext(ifp, i);
  2363. start_block = xfs_bmbt_get_startblock(ep);
  2364. if (isnullstartblock(start_block)) {
  2365. /*
  2366. * It's a delayed allocation extent, so skip it.
  2367. */
  2368. continue;
  2369. }
  2370. /* Translate to on disk format */
  2371. put_unaligned(cpu_to_be64(ep->l0), &dp->l0);
  2372. put_unaligned(cpu_to_be64(ep->l1), &dp->l1);
  2373. dp++;
  2374. copied++;
  2375. }
  2376. ASSERT(copied != 0);
  2377. xfs_validate_extents(ifp, copied, XFS_EXTFMT_INODE(ip));
  2378. return (copied * (uint)sizeof(xfs_bmbt_rec_t));
  2379. }
  2380. /*
  2381. * Each of the following cases stores data into the same region
  2382. * of the on-disk inode, so only one of them can be valid at
  2383. * any given time. While it is possible to have conflicting formats
  2384. * and log flags, e.g. having XFS_ILOG_?DATA set when the fork is
  2385. * in EXTENTS format, this can only happen when the fork has
  2386. * changed formats after being modified but before being flushed.
  2387. * In these cases, the format always takes precedence, because the
  2388. * format indicates the current state of the fork.
  2389. */
  2390. /*ARGSUSED*/
  2391. STATIC void
  2392. xfs_iflush_fork(
  2393. xfs_inode_t *ip,
  2394. xfs_dinode_t *dip,
  2395. xfs_inode_log_item_t *iip,
  2396. int whichfork,
  2397. xfs_buf_t *bp)
  2398. {
  2399. char *cp;
  2400. xfs_ifork_t *ifp;
  2401. xfs_mount_t *mp;
  2402. #ifdef XFS_TRANS_DEBUG
  2403. int first;
  2404. #endif
  2405. static const short brootflag[2] =
  2406. { XFS_ILOG_DBROOT, XFS_ILOG_ABROOT };
  2407. static const short dataflag[2] =
  2408. { XFS_ILOG_DDATA, XFS_ILOG_ADATA };
  2409. static const short extflag[2] =
  2410. { XFS_ILOG_DEXT, XFS_ILOG_AEXT };
  2411. if (!iip)
  2412. return;
  2413. ifp = XFS_IFORK_PTR(ip, whichfork);
  2414. /*
  2415. * This can happen if we gave up in iformat in an error path,
  2416. * for the attribute fork.
  2417. */
  2418. if (!ifp) {
  2419. ASSERT(whichfork == XFS_ATTR_FORK);
  2420. return;
  2421. }
  2422. cp = XFS_DFORK_PTR(dip, whichfork);
  2423. mp = ip->i_mount;
  2424. switch (XFS_IFORK_FORMAT(ip, whichfork)) {
  2425. case XFS_DINODE_FMT_LOCAL:
  2426. if ((iip->ili_format.ilf_fields & dataflag[whichfork]) &&
  2427. (ifp->if_bytes > 0)) {
  2428. ASSERT(ifp->if_u1.if_data != NULL);
  2429. ASSERT(ifp->if_bytes <= XFS_IFORK_SIZE(ip, whichfork));
  2430. memcpy(cp, ifp->if_u1.if_data, ifp->if_bytes);
  2431. }
  2432. break;
  2433. case XFS_DINODE_FMT_EXTENTS:
  2434. ASSERT((ifp->if_flags & XFS_IFEXTENTS) ||
  2435. !(iip->ili_format.ilf_fields & extflag[whichfork]));
  2436. ASSERT((xfs_iext_get_ext(ifp, 0) != NULL) ||
  2437. (ifp->if_bytes == 0));
  2438. ASSERT((xfs_iext_get_ext(ifp, 0) == NULL) ||
  2439. (ifp->if_bytes > 0));
  2440. if ((iip->ili_format.ilf_fields & extflag[whichfork]) &&
  2441. (ifp->if_bytes > 0)) {
  2442. ASSERT(XFS_IFORK_NEXTENTS(ip, whichfork) > 0);
  2443. (void)xfs_iextents_copy(ip, (xfs_bmbt_rec_t *)cp,
  2444. whichfork);
  2445. }
  2446. break;
  2447. case XFS_DINODE_FMT_BTREE:
  2448. if ((iip->ili_format.ilf_fields & brootflag[whichfork]) &&
  2449. (ifp->if_broot_bytes > 0)) {
  2450. ASSERT(ifp->if_broot != NULL);
  2451. ASSERT(ifp->if_broot_bytes <=
  2452. (XFS_IFORK_SIZE(ip, whichfork) +
  2453. XFS_BROOT_SIZE_ADJ));
  2454. xfs_bmbt_to_bmdr(mp, ifp->if_broot, ifp->if_broot_bytes,
  2455. (xfs_bmdr_block_t *)cp,
  2456. XFS_DFORK_SIZE(dip, mp, whichfork));
  2457. }
  2458. break;
  2459. case XFS_DINODE_FMT_DEV:
  2460. if (iip->ili_format.ilf_fields & XFS_ILOG_DEV) {
  2461. ASSERT(whichfork == XFS_DATA_FORK);
  2462. xfs_dinode_put_rdev(dip, ip->i_df.if_u2.if_rdev);
  2463. }
  2464. break;
  2465. case XFS_DINODE_FMT_UUID:
  2466. if (iip->ili_format.ilf_fields & XFS_ILOG_UUID) {
  2467. ASSERT(whichfork == XFS_DATA_FORK);
  2468. memcpy(XFS_DFORK_DPTR(dip),
  2469. &ip->i_df.if_u2.if_uuid,
  2470. sizeof(uuid_t));
  2471. }
  2472. break;
  2473. default:
  2474. ASSERT(0);
  2475. break;
  2476. }
  2477. }
  2478. STATIC int
  2479. xfs_iflush_cluster(
  2480. xfs_inode_t *ip,
  2481. xfs_buf_t *bp)
  2482. {
  2483. xfs_mount_t *mp = ip->i_mount;
  2484. struct xfs_perag *pag;
  2485. unsigned long first_index, mask;
  2486. unsigned long inodes_per_cluster;
  2487. int ilist_size;
  2488. xfs_inode_t **ilist;
  2489. xfs_inode_t *iq;
  2490. int nr_found;
  2491. int clcount = 0;
  2492. int bufwasdelwri;
  2493. int i;
  2494. pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
  2495. ASSERT(pag->pagi_inodeok);
  2496. ASSERT(pag->pag_ici_init);
  2497. inodes_per_cluster = XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_inodelog;
  2498. ilist_size = inodes_per_cluster * sizeof(xfs_inode_t *);
  2499. ilist = kmem_alloc(ilist_size, KM_MAYFAIL|KM_NOFS);
  2500. if (!ilist)
  2501. goto out_put;
  2502. mask = ~(((XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_inodelog)) - 1);
  2503. first_index = XFS_INO_TO_AGINO(mp, ip->i_ino) & mask;
  2504. read_lock(&pag->pag_ici_lock);
  2505. /* really need a gang lookup range call here */
  2506. nr_found = radix_tree_gang_lookup(&pag->pag_ici_root, (void**)ilist,
  2507. first_index, inodes_per_cluster);
  2508. if (nr_found == 0)
  2509. goto out_free;
  2510. for (i = 0; i < nr_found; i++) {
  2511. iq = ilist[i];
  2512. if (iq == ip)
  2513. continue;
  2514. /* if the inode lies outside this cluster, we're done. */
  2515. if ((XFS_INO_TO_AGINO(mp, iq->i_ino) & mask) != first_index)
  2516. break;
  2517. /*
  2518. * Do an un-protected check to see if the inode is dirty and
  2519. * is a candidate for flushing. These checks will be repeated
  2520. * later after the appropriate locks are acquired.
  2521. */
  2522. if (xfs_inode_clean(iq) && xfs_ipincount(iq) == 0)
  2523. continue;
  2524. /*
  2525. * Try to get locks. If any are unavailable or it is pinned,
  2526. * then this inode cannot be flushed and is skipped.
  2527. */
  2528. if (!xfs_ilock_nowait(iq, XFS_ILOCK_SHARED))
  2529. continue;
  2530. if (!xfs_iflock_nowait(iq)) {
  2531. xfs_iunlock(iq, XFS_ILOCK_SHARED);
  2532. continue;
  2533. }
  2534. if (xfs_ipincount(iq)) {
  2535. xfs_ifunlock(iq);
  2536. xfs_iunlock(iq, XFS_ILOCK_SHARED);
  2537. continue;
  2538. }
  2539. /*
  2540. * arriving here means that this inode can be flushed. First
  2541. * re-check that it's dirty before flushing.
  2542. */
  2543. if (!xfs_inode_clean(iq)) {
  2544. int error;
  2545. error = xfs_iflush_int(iq, bp);
  2546. if (error) {
  2547. xfs_iunlock(iq, XFS_ILOCK_SHARED);
  2548. goto cluster_corrupt_out;
  2549. }
  2550. clcount++;
  2551. } else {
  2552. xfs_ifunlock(iq);
  2553. }
  2554. xfs_iunlock(iq, XFS_ILOCK_SHARED);
  2555. }
  2556. if (clcount) {
  2557. XFS_STATS_INC(xs_icluster_flushcnt);
  2558. XFS_STATS_ADD(xs_icluster_flushinode, clcount);
  2559. }
  2560. out_free:
  2561. read_unlock(&pag->pag_ici_lock);
  2562. kmem_free(ilist);
  2563. out_put:
  2564. xfs_perag_put(pag);
  2565. return 0;
  2566. cluster_corrupt_out:
  2567. /*
  2568. * Corruption detected in the clustering loop. Invalidate the
  2569. * inode buffer and shut down the filesystem.
  2570. */
  2571. read_unlock(&pag->pag_ici_lock);
  2572. /*
  2573. * Clean up the buffer. If it was B_DELWRI, just release it --
  2574. * brelse can handle it with no problems. If not, shut down the
  2575. * filesystem before releasing the buffer.
  2576. */
  2577. bufwasdelwri = XFS_BUF_ISDELAYWRITE(bp);
  2578. if (bufwasdelwri)
  2579. xfs_buf_relse(bp);
  2580. xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
  2581. if (!bufwasdelwri) {
  2582. /*
  2583. * Just like incore_relse: if we have b_iodone functions,
  2584. * mark the buffer as an error and call them. Otherwise
  2585. * mark it as stale and brelse.
  2586. */
  2587. if (XFS_BUF_IODONE_FUNC(bp)) {
  2588. XFS_BUF_CLR_BDSTRAT_FUNC(bp);
  2589. XFS_BUF_UNDONE(bp);
  2590. XFS_BUF_STALE(bp);
  2591. XFS_BUF_ERROR(bp,EIO);
  2592. xfs_biodone(bp);
  2593. } else {
  2594. XFS_BUF_STALE(bp);
  2595. xfs_buf_relse(bp);
  2596. }
  2597. }
  2598. /*
  2599. * Unlocks the flush lock
  2600. */
  2601. xfs_iflush_abort(iq);
  2602. kmem_free(ilist);
  2603. xfs_perag_put(pag);
  2604. return XFS_ERROR(EFSCORRUPTED);
  2605. }
  2606. /*
  2607. * xfs_iflush() will write a modified inode's changes out to the
  2608. * inode's on disk home. The caller must have the inode lock held
  2609. * in at least shared mode and the inode flush completion must be
  2610. * active as well. The inode lock will still be held upon return from
  2611. * the call and the caller is free to unlock it.
  2612. * The inode flush will be completed when the inode reaches the disk.
  2613. * The flags indicate how the inode's buffer should be written out.
  2614. */
  2615. int
  2616. xfs_iflush(
  2617. xfs_inode_t *ip,
  2618. uint flags)
  2619. {
  2620. xfs_inode_log_item_t *iip;
  2621. xfs_buf_t *bp;
  2622. xfs_dinode_t *dip;
  2623. xfs_mount_t *mp;
  2624. int error;
  2625. int noblock = (flags == XFS_IFLUSH_ASYNC_NOBLOCK);
  2626. enum { INT_DELWRI = (1 << 0), INT_ASYNC = (1 << 1) };
  2627. XFS_STATS_INC(xs_iflush_count);
  2628. ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
  2629. ASSERT(!completion_done(&ip->i_flush));
  2630. ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
  2631. ip->i_d.di_nextents > ip->i_df.if_ext_max);
  2632. iip = ip->i_itemp;
  2633. mp = ip->i_mount;
  2634. /*
  2635. * We can't flush the inode until it is unpinned, so wait for it if we
  2636. * are allowed to block. We know noone new can pin it, because we are
  2637. * holding the inode lock shared and you need to hold it exclusively to
  2638. * pin the inode.
  2639. *
  2640. * If we are not allowed to block, force the log out asynchronously so
  2641. * that when we come back the inode will be unpinned. If other inodes
  2642. * in the same cluster are dirty, they will probably write the inode
  2643. * out for us if they occur after the log force completes.
  2644. */
  2645. if (noblock && xfs_ipincount(ip)) {
  2646. xfs_iunpin_nowait(ip);
  2647. xfs_ifunlock(ip);
  2648. return EAGAIN;
  2649. }
  2650. xfs_iunpin_wait(ip);
  2651. /*
  2652. * For stale inodes we cannot rely on the backing buffer remaining
  2653. * stale in cache for the remaining life of the stale inode and so
  2654. * xfs_itobp() below may give us a buffer that no longer contains
  2655. * inodes below. We have to check this after ensuring the inode is
  2656. * unpinned so that it is safe to reclaim the stale inode after the
  2657. * flush call.
  2658. */
  2659. if (xfs_iflags_test(ip, XFS_ISTALE)) {
  2660. xfs_ifunlock(ip);
  2661. return 0;
  2662. }
  2663. /*
  2664. * This may have been unpinned because the filesystem is shutting
  2665. * down forcibly. If that's the case we must not write this inode
  2666. * to disk, because the log record didn't make it to disk!
  2667. */
  2668. if (XFS_FORCED_SHUTDOWN(mp)) {
  2669. ip->i_update_core = 0;
  2670. if (iip)
  2671. iip->ili_format.ilf_fields = 0;
  2672. xfs_ifunlock(ip);
  2673. return XFS_ERROR(EIO);
  2674. }
  2675. /*
  2676. * Decide how buffer will be flushed out. This is done before
  2677. * the call to xfs_iflush_int because this field is zeroed by it.
  2678. */
  2679. if (iip != NULL && iip->ili_format.ilf_fields != 0) {
  2680. /*
  2681. * Flush out the inode buffer according to the directions
  2682. * of the caller. In the cases where the caller has given
  2683. * us a choice choose the non-delwri case. This is because
  2684. * the inode is in the AIL and we need to get it out soon.
  2685. */
  2686. switch (flags) {
  2687. case XFS_IFLUSH_SYNC:
  2688. case XFS_IFLUSH_DELWRI_ELSE_SYNC:
  2689. flags = 0;
  2690. break;
  2691. case XFS_IFLUSH_ASYNC_NOBLOCK:
  2692. case XFS_IFLUSH_ASYNC:
  2693. case XFS_IFLUSH_DELWRI_ELSE_ASYNC:
  2694. flags = INT_ASYNC;
  2695. break;
  2696. case XFS_IFLUSH_DELWRI:
  2697. flags = INT_DELWRI;
  2698. break;
  2699. default:
  2700. ASSERT(0);
  2701. flags = 0;
  2702. break;
  2703. }
  2704. } else {
  2705. switch (flags) {
  2706. case XFS_IFLUSH_DELWRI_ELSE_SYNC:
  2707. case XFS_IFLUSH_DELWRI_ELSE_ASYNC:
  2708. case XFS_IFLUSH_DELWRI:
  2709. flags = INT_DELWRI;
  2710. break;
  2711. case XFS_IFLUSH_ASYNC_NOBLOCK:
  2712. case XFS_IFLUSH_ASYNC:
  2713. flags = INT_ASYNC;
  2714. break;
  2715. case XFS_IFLUSH_SYNC:
  2716. flags = 0;
  2717. break;
  2718. default:
  2719. ASSERT(0);
  2720. flags = 0;
  2721. break;
  2722. }
  2723. }
  2724. /*
  2725. * Get the buffer containing the on-disk inode.
  2726. */
  2727. error = xfs_itobp(mp, NULL, ip, &dip, &bp,
  2728. noblock ? XBF_TRYLOCK : XBF_LOCK);
  2729. if (error || !bp) {
  2730. xfs_ifunlock(ip);
  2731. return error;
  2732. }
  2733. /*
  2734. * First flush out the inode that xfs_iflush was called with.
  2735. */
  2736. error = xfs_iflush_int(ip, bp);
  2737. if (error)
  2738. goto corrupt_out;
  2739. /*
  2740. * If the buffer is pinned then push on the log now so we won't
  2741. * get stuck waiting in the write for too long.
  2742. */
  2743. if (XFS_BUF_ISPINNED(bp))
  2744. xfs_log_force(mp, 0);
  2745. /*
  2746. * inode clustering:
  2747. * see if other inodes can be gathered into this write
  2748. */
  2749. error = xfs_iflush_cluster(ip, bp);
  2750. if (error)
  2751. goto cluster_corrupt_out;
  2752. if (flags & INT_DELWRI) {
  2753. xfs_bdwrite(mp, bp);
  2754. } else if (flags & INT_ASYNC) {
  2755. error = xfs_bawrite(mp, bp);
  2756. } else {
  2757. error = xfs_bwrite(mp, bp);
  2758. }
  2759. return error;
  2760. corrupt_out:
  2761. xfs_buf_relse(bp);
  2762. xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
  2763. cluster_corrupt_out:
  2764. /*
  2765. * Unlocks the flush lock
  2766. */
  2767. xfs_iflush_abort(ip);
  2768. return XFS_ERROR(EFSCORRUPTED);
  2769. }
  2770. STATIC int
  2771. xfs_iflush_int(
  2772. xfs_inode_t *ip,
  2773. xfs_buf_t *bp)
  2774. {
  2775. xfs_inode_log_item_t *iip;
  2776. xfs_dinode_t *dip;
  2777. xfs_mount_t *mp;
  2778. #ifdef XFS_TRANS_DEBUG
  2779. int first;
  2780. #endif
  2781. ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
  2782. ASSERT(!completion_done(&ip->i_flush));
  2783. ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
  2784. ip->i_d.di_nextents > ip->i_df.if_ext_max);
  2785. iip = ip->i_itemp;
  2786. mp = ip->i_mount;
  2787. /*
  2788. * If the inode isn't dirty, then just release the inode
  2789. * flush lock and do nothing.
  2790. */
  2791. if (xfs_inode_clean(ip)) {
  2792. xfs_ifunlock(ip);
  2793. return 0;
  2794. }
  2795. /* set *dip = inode's place in the buffer */
  2796. dip = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_imap.im_boffset);
  2797. /*
  2798. * Clear i_update_core before copying out the data.
  2799. * This is for coordination with our timestamp updates
  2800. * that don't hold the inode lock. They will always
  2801. * update the timestamps BEFORE setting i_update_core,
  2802. * so if we clear i_update_core after they set it we
  2803. * are guaranteed to see their updates to the timestamps.
  2804. * I believe that this depends on strongly ordered memory
  2805. * semantics, but we have that. We use the SYNCHRONIZE
  2806. * macro to make sure that the compiler does not reorder
  2807. * the i_update_core access below the data copy below.
  2808. */
  2809. ip->i_update_core = 0;
  2810. SYNCHRONIZE();
  2811. /*
  2812. * Make sure to get the latest timestamps from the Linux inode.
  2813. */
  2814. xfs_synchronize_times(ip);
  2815. if (XFS_TEST_ERROR(be16_to_cpu(dip->di_magic) != XFS_DINODE_MAGIC,
  2816. mp, XFS_ERRTAG_IFLUSH_1, XFS_RANDOM_IFLUSH_1)) {
  2817. xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
  2818. "xfs_iflush: Bad inode %Lu magic number 0x%x, ptr 0x%p",
  2819. ip->i_ino, be16_to_cpu(dip->di_magic), dip);
  2820. goto corrupt_out;
  2821. }
  2822. if (XFS_TEST_ERROR(ip->i_d.di_magic != XFS_DINODE_MAGIC,
  2823. mp, XFS_ERRTAG_IFLUSH_2, XFS_RANDOM_IFLUSH_2)) {
  2824. xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
  2825. "xfs_iflush: Bad inode %Lu, ptr 0x%p, magic number 0x%x",
  2826. ip->i_ino, ip, ip->i_d.di_magic);
  2827. goto corrupt_out;
  2828. }
  2829. if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) {
  2830. if (XFS_TEST_ERROR(
  2831. (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
  2832. (ip->i_d.di_format != XFS_DINODE_FMT_BTREE),
  2833. mp, XFS_ERRTAG_IFLUSH_3, XFS_RANDOM_IFLUSH_3)) {
  2834. xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
  2835. "xfs_iflush: Bad regular inode %Lu, ptr 0x%p",
  2836. ip->i_ino, ip);
  2837. goto corrupt_out;
  2838. }
  2839. } else if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
  2840. if (XFS_TEST_ERROR(
  2841. (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
  2842. (ip->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
  2843. (ip->i_d.di_format != XFS_DINODE_FMT_LOCAL),
  2844. mp, XFS_ERRTAG_IFLUSH_4, XFS_RANDOM_IFLUSH_4)) {
  2845. xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
  2846. "xfs_iflush: Bad directory inode %Lu, ptr 0x%p",
  2847. ip->i_ino, ip);
  2848. goto corrupt_out;
  2849. }
  2850. }
  2851. if (XFS_TEST_ERROR(ip->i_d.di_nextents + ip->i_d.di_anextents >
  2852. ip->i_d.di_nblocks, mp, XFS_ERRTAG_IFLUSH_5,
  2853. XFS_RANDOM_IFLUSH_5)) {
  2854. xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
  2855. "xfs_iflush: detected corrupt incore inode %Lu, total extents = %d, nblocks = %Ld, ptr 0x%p",
  2856. ip->i_ino,
  2857. ip->i_d.di_nextents + ip->i_d.di_anextents,
  2858. ip->i_d.di_nblocks,
  2859. ip);
  2860. goto corrupt_out;
  2861. }
  2862. if (XFS_TEST_ERROR(ip->i_d.di_forkoff > mp->m_sb.sb_inodesize,
  2863. mp, XFS_ERRTAG_IFLUSH_6, XFS_RANDOM_IFLUSH_6)) {
  2864. xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
  2865. "xfs_iflush: bad inode %Lu, forkoff 0x%x, ptr 0x%p",
  2866. ip->i_ino, ip->i_d.di_forkoff, ip);
  2867. goto corrupt_out;
  2868. }
  2869. /*
  2870. * bump the flush iteration count, used to detect flushes which
  2871. * postdate a log record during recovery.
  2872. */
  2873. ip->i_d.di_flushiter++;
  2874. /*
  2875. * Copy the dirty parts of the inode into the on-disk
  2876. * inode. We always copy out the core of the inode,
  2877. * because if the inode is dirty at all the core must
  2878. * be.
  2879. */
  2880. xfs_dinode_to_disk(dip, &ip->i_d);
  2881. /* Wrap, we never let the log put out DI_MAX_FLUSH */
  2882. if (ip->i_d.di_flushiter == DI_MAX_FLUSH)
  2883. ip->i_d.di_flushiter = 0;
  2884. /*
  2885. * If this is really an old format inode and the superblock version
  2886. * has not been updated to support only new format inodes, then
  2887. * convert back to the old inode format. If the superblock version
  2888. * has been updated, then make the conversion permanent.
  2889. */
  2890. ASSERT(ip->i_d.di_version == 1 || xfs_sb_version_hasnlink(&mp->m_sb));
  2891. if (ip->i_d.di_version == 1) {
  2892. if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
  2893. /*
  2894. * Convert it back.
  2895. */
  2896. ASSERT(ip->i_d.di_nlink <= XFS_MAXLINK_1);
  2897. dip->di_onlink = cpu_to_be16(ip->i_d.di_nlink);
  2898. } else {
  2899. /*
  2900. * The superblock version has already been bumped,
  2901. * so just make the conversion to the new inode
  2902. * format permanent.
  2903. */
  2904. ip->i_d.di_version = 2;
  2905. dip->di_version = 2;
  2906. ip->i_d.di_onlink = 0;
  2907. dip->di_onlink = 0;
  2908. memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
  2909. memset(&(dip->di_pad[0]), 0,
  2910. sizeof(dip->di_pad));
  2911. ASSERT(ip->i_d.di_projid == 0);
  2912. }
  2913. }
  2914. xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK, bp);
  2915. if (XFS_IFORK_Q(ip))
  2916. xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK, bp);
  2917. xfs_inobp_check(mp, bp);
  2918. /*
  2919. * We've recorded everything logged in the inode, so we'd
  2920. * like to clear the ilf_fields bits so we don't log and
  2921. * flush things unnecessarily. However, we can't stop
  2922. * logging all this information until the data we've copied
  2923. * into the disk buffer is written to disk. If we did we might
  2924. * overwrite the copy of the inode in the log with all the
  2925. * data after re-logging only part of it, and in the face of
  2926. * a crash we wouldn't have all the data we need to recover.
  2927. *
  2928. * What we do is move the bits to the ili_last_fields field.
  2929. * When logging the inode, these bits are moved back to the
  2930. * ilf_fields field. In the xfs_iflush_done() routine we
  2931. * clear ili_last_fields, since we know that the information
  2932. * those bits represent is permanently on disk. As long as
  2933. * the flush completes before the inode is logged again, then
  2934. * both ilf_fields and ili_last_fields will be cleared.
  2935. *
  2936. * We can play with the ilf_fields bits here, because the inode
  2937. * lock must be held exclusively in order to set bits there
  2938. * and the flush lock protects the ili_last_fields bits.
  2939. * Set ili_logged so the flush done
  2940. * routine can tell whether or not to look in the AIL.
  2941. * Also, store the current LSN of the inode so that we can tell
  2942. * whether the item has moved in the AIL from xfs_iflush_done().
  2943. * In order to read the lsn we need the AIL lock, because
  2944. * it is a 64 bit value that cannot be read atomically.
  2945. */
  2946. if (iip != NULL && iip->ili_format.ilf_fields != 0) {
  2947. iip->ili_last_fields = iip->ili_format.ilf_fields;
  2948. iip->ili_format.ilf_fields = 0;
  2949. iip->ili_logged = 1;
  2950. xfs_trans_ail_copy_lsn(mp->m_ail, &iip->ili_flush_lsn,
  2951. &iip->ili_item.li_lsn);
  2952. /*
  2953. * Attach the function xfs_iflush_done to the inode's
  2954. * buffer. This will remove the inode from the AIL
  2955. * and unlock the inode's flush lock when the inode is
  2956. * completely written to disk.
  2957. */
  2958. xfs_buf_attach_iodone(bp, (void(*)(xfs_buf_t*,xfs_log_item_t*))
  2959. xfs_iflush_done, (xfs_log_item_t *)iip);
  2960. ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
  2961. ASSERT(XFS_BUF_IODONE_FUNC(bp) != NULL);
  2962. } else {
  2963. /*
  2964. * We're flushing an inode which is not in the AIL and has
  2965. * not been logged but has i_update_core set. For this
  2966. * case we can use a B_DELWRI flush and immediately drop
  2967. * the inode flush lock because we can avoid the whole
  2968. * AIL state thing. It's OK to drop the flush lock now,
  2969. * because we've already locked the buffer and to do anything
  2970. * you really need both.
  2971. */
  2972. if (iip != NULL) {
  2973. ASSERT(iip->ili_logged == 0);
  2974. ASSERT(iip->ili_last_fields == 0);
  2975. ASSERT((iip->ili_item.li_flags & XFS_LI_IN_AIL) == 0);
  2976. }
  2977. xfs_ifunlock(ip);
  2978. }
  2979. return 0;
  2980. corrupt_out:
  2981. return XFS_ERROR(EFSCORRUPTED);
  2982. }
  2983. /*
  2984. * Return a pointer to the extent record at file index idx.
  2985. */
  2986. xfs_bmbt_rec_host_t *
  2987. xfs_iext_get_ext(
  2988. xfs_ifork_t *ifp, /* inode fork pointer */
  2989. xfs_extnum_t idx) /* index of target extent */
  2990. {
  2991. ASSERT(idx >= 0);
  2992. if ((ifp->if_flags & XFS_IFEXTIREC) && (idx == 0)) {
  2993. return ifp->if_u1.if_ext_irec->er_extbuf;
  2994. } else if (ifp->if_flags & XFS_IFEXTIREC) {
  2995. xfs_ext_irec_t *erp; /* irec pointer */
  2996. int erp_idx = 0; /* irec index */
  2997. xfs_extnum_t page_idx = idx; /* ext index in target list */
  2998. erp = xfs_iext_idx_to_irec(ifp, &page_idx, &erp_idx, 0);
  2999. return &erp->er_extbuf[page_idx];
  3000. } else if (ifp->if_bytes) {
  3001. return &ifp->if_u1.if_extents[idx];
  3002. } else {
  3003. return NULL;
  3004. }
  3005. }
  3006. /*
  3007. * Insert new item(s) into the extent records for incore inode
  3008. * fork 'ifp'. 'count' new items are inserted at index 'idx'.
  3009. */
  3010. void
  3011. xfs_iext_insert(
  3012. xfs_inode_t *ip, /* incore inode pointer */
  3013. xfs_extnum_t idx, /* starting index of new items */
  3014. xfs_extnum_t count, /* number of inserted items */
  3015. xfs_bmbt_irec_t *new, /* items to insert */
  3016. int state) /* type of extent conversion */
  3017. {
  3018. xfs_ifork_t *ifp = (state & BMAP_ATTRFORK) ? ip->i_afp : &ip->i_df;
  3019. xfs_extnum_t i; /* extent record index */
  3020. trace_xfs_iext_insert(ip, idx, new, state, _RET_IP_);
  3021. ASSERT(ifp->if_flags & XFS_IFEXTENTS);
  3022. xfs_iext_add(ifp, idx, count);
  3023. for (i = idx; i < idx + count; i++, new++)
  3024. xfs_bmbt_set_all(xfs_iext_get_ext(ifp, i), new);
  3025. }
  3026. /*
  3027. * This is called when the amount of space required for incore file
  3028. * extents needs to be increased. The ext_diff parameter stores the
  3029. * number of new extents being added and the idx parameter contains
  3030. * the extent index where the new extents will be added. If the new
  3031. * extents are being appended, then we just need to (re)allocate and
  3032. * initialize the space. Otherwise, if the new extents are being
  3033. * inserted into the middle of the existing entries, a bit more work
  3034. * is required to make room for the new extents to be inserted. The
  3035. * caller is responsible for filling in the new extent entries upon
  3036. * return.
  3037. */
  3038. void
  3039. xfs_iext_add(
  3040. xfs_ifork_t *ifp, /* inode fork pointer */
  3041. xfs_extnum_t idx, /* index to begin adding exts */
  3042. int ext_diff) /* number of extents to add */
  3043. {
  3044. int byte_diff; /* new bytes being added */
  3045. int new_size; /* size of extents after adding */
  3046. xfs_extnum_t nextents; /* number of extents in file */
  3047. nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
  3048. ASSERT((idx >= 0) && (idx <= nextents));
  3049. byte_diff = ext_diff * sizeof(xfs_bmbt_rec_t);
  3050. new_size = ifp->if_bytes + byte_diff;
  3051. /*
  3052. * If the new number of extents (nextents + ext_diff)
  3053. * fits inside the inode, then continue to use the inline
  3054. * extent buffer.
  3055. */
  3056. if (nextents + ext_diff <= XFS_INLINE_EXTS) {
  3057. if (idx < nextents) {
  3058. memmove(&ifp->if_u2.if_inline_ext[idx + ext_diff],
  3059. &ifp->if_u2.if_inline_ext[idx],
  3060. (nextents - idx) * sizeof(xfs_bmbt_rec_t));
  3061. memset(&ifp->if_u2.if_inline_ext[idx], 0, byte_diff);
  3062. }
  3063. ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext;
  3064. ifp->if_real_bytes = 0;
  3065. ifp->if_lastex = nextents + ext_diff;
  3066. }
  3067. /*
  3068. * Otherwise use a linear (direct) extent list.
  3069. * If the extents are currently inside the inode,
  3070. * xfs_iext_realloc_direct will switch us from
  3071. * inline to direct extent allocation mode.
  3072. */
  3073. else if (nextents + ext_diff <= XFS_LINEAR_EXTS) {
  3074. xfs_iext_realloc_direct(ifp, new_size);
  3075. if (idx < nextents) {
  3076. memmove(&ifp->if_u1.if_extents[idx + ext_diff],
  3077. &ifp->if_u1.if_extents[idx],
  3078. (nextents - idx) * sizeof(xfs_bmbt_rec_t));
  3079. memset(&ifp->if_u1.if_extents[idx], 0, byte_diff);
  3080. }
  3081. }
  3082. /* Indirection array */
  3083. else {
  3084. xfs_ext_irec_t *erp;
  3085. int erp_idx = 0;
  3086. int page_idx = idx;
  3087. ASSERT(nextents + ext_diff > XFS_LINEAR_EXTS);
  3088. if (ifp->if_flags & XFS_IFEXTIREC) {
  3089. erp = xfs_iext_idx_to_irec(ifp, &page_idx, &erp_idx, 1);
  3090. } else {
  3091. xfs_iext_irec_init(ifp);
  3092. ASSERT(ifp->if_flags & XFS_IFEXTIREC);
  3093. erp = ifp->if_u1.if_ext_irec;
  3094. }
  3095. /* Extents fit in target extent page */
  3096. if (erp && erp->er_extcount + ext_diff <= XFS_LINEAR_EXTS) {
  3097. if (page_idx < erp->er_extcount) {
  3098. memmove(&erp->er_extbuf[page_idx + ext_diff],
  3099. &erp->er_extbuf[page_idx],
  3100. (erp->er_extcount - page_idx) *
  3101. sizeof(xfs_bmbt_rec_t));
  3102. memset(&erp->er_extbuf[page_idx], 0, byte_diff);
  3103. }
  3104. erp->er_extcount += ext_diff;
  3105. xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, ext_diff);
  3106. }
  3107. /* Insert a new extent page */
  3108. else if (erp) {
  3109. xfs_iext_add_indirect_multi(ifp,
  3110. erp_idx, page_idx, ext_diff);
  3111. }
  3112. /*
  3113. * If extent(s) are being appended to the last page in
  3114. * the indirection array and the new extent(s) don't fit
  3115. * in the page, then erp is NULL and erp_idx is set to
  3116. * the next index needed in the indirection array.
  3117. */
  3118. else {
  3119. int count = ext_diff;
  3120. while (count) {
  3121. erp = xfs_iext_irec_new(ifp, erp_idx);
  3122. erp->er_extcount = count;
  3123. count -= MIN(count, (int)XFS_LINEAR_EXTS);
  3124. if (count) {
  3125. erp_idx++;
  3126. }
  3127. }
  3128. }
  3129. }
  3130. ifp->if_bytes = new_size;
  3131. }
  3132. /*
  3133. * This is called when incore extents are being added to the indirection
  3134. * array and the new extents do not fit in the target extent list. The
  3135. * erp_idx parameter contains the irec index for the target extent list
  3136. * in the indirection array, and the idx parameter contains the extent
  3137. * index within the list. The number of extents being added is stored
  3138. * in the count parameter.
  3139. *
  3140. * |-------| |-------|
  3141. * | | | | idx - number of extents before idx
  3142. * | idx | | count |
  3143. * | | | | count - number of extents being inserted at idx
  3144. * |-------| |-------|
  3145. * | count | | nex2 | nex2 - number of extents after idx + count
  3146. * |-------| |-------|
  3147. */
  3148. void
  3149. xfs_iext_add_indirect_multi(
  3150. xfs_ifork_t *ifp, /* inode fork pointer */
  3151. int erp_idx, /* target extent irec index */
  3152. xfs_extnum_t idx, /* index within target list */
  3153. int count) /* new extents being added */
  3154. {
  3155. int byte_diff; /* new bytes being added */
  3156. xfs_ext_irec_t *erp; /* pointer to irec entry */
  3157. xfs_extnum_t ext_diff; /* number of extents to add */
  3158. xfs_extnum_t ext_cnt; /* new extents still needed */
  3159. xfs_extnum_t nex2; /* extents after idx + count */
  3160. xfs_bmbt_rec_t *nex2_ep = NULL; /* temp list for nex2 extents */
  3161. int nlists; /* number of irec's (lists) */
  3162. ASSERT(ifp->if_flags & XFS_IFEXTIREC);
  3163. erp = &ifp->if_u1.if_ext_irec[erp_idx];
  3164. nex2 = erp->er_extcount - idx;
  3165. nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
  3166. /*
  3167. * Save second part of target extent list
  3168. * (all extents past */
  3169. if (nex2) {
  3170. byte_diff = nex2 * sizeof(xfs_bmbt_rec_t);
  3171. nex2_ep = (xfs_bmbt_rec_t *) kmem_alloc(byte_diff, KM_NOFS);
  3172. memmove(nex2_ep, &erp->er_extbuf[idx], byte_diff);
  3173. erp->er_extcount -= nex2;
  3174. xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, -nex2);
  3175. memset(&erp->er_extbuf[idx], 0, byte_diff);
  3176. }
  3177. /*
  3178. * Add the new extents to the end of the target
  3179. * list, then allocate new irec record(s) and
  3180. * extent buffer(s) as needed to store the rest
  3181. * of the new extents.
  3182. */
  3183. ext_cnt = count;
  3184. ext_diff = MIN(ext_cnt, (int)XFS_LINEAR_EXTS - erp->er_extcount);
  3185. if (ext_diff) {
  3186. erp->er_extcount += ext_diff;
  3187. xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, ext_diff);
  3188. ext_cnt -= ext_diff;
  3189. }
  3190. while (ext_cnt) {
  3191. erp_idx++;
  3192. erp = xfs_iext_irec_new(ifp, erp_idx);
  3193. ext_diff = MIN(ext_cnt, (int)XFS_LINEAR_EXTS);
  3194. erp->er_extcount = ext_diff;
  3195. xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, ext_diff);
  3196. ext_cnt -= ext_diff;
  3197. }
  3198. /* Add nex2 extents back to indirection array */
  3199. if (nex2) {
  3200. xfs_extnum_t ext_avail;
  3201. int i;
  3202. byte_diff = nex2 * sizeof(xfs_bmbt_rec_t);
  3203. ext_avail = XFS_LINEAR_EXTS - erp->er_extcount;
  3204. i = 0;
  3205. /*
  3206. * If nex2 extents fit in the current page, append
  3207. * nex2_ep after the new extents.
  3208. */
  3209. if (nex2 <= ext_avail) {
  3210. i = erp->er_extcount;
  3211. }
  3212. /*
  3213. * Otherwise, check if space is available in the
  3214. * next page.
  3215. */
  3216. else if ((erp_idx < nlists - 1) &&
  3217. (nex2 <= (ext_avail = XFS_LINEAR_EXTS -
  3218. ifp->if_u1.if_ext_irec[erp_idx+1].er_extcount))) {
  3219. erp_idx++;
  3220. erp++;
  3221. /* Create a hole for nex2 extents */
  3222. memmove(&erp->er_extbuf[nex2], erp->er_extbuf,
  3223. erp->er_extcount * sizeof(xfs_bmbt_rec_t));
  3224. }
  3225. /*
  3226. * Final choice, create a new extent page for
  3227. * nex2 extents.
  3228. */
  3229. else {
  3230. erp_idx++;
  3231. erp = xfs_iext_irec_new(ifp, erp_idx);
  3232. }
  3233. memmove(&erp->er_extbuf[i], nex2_ep, byte_diff);
  3234. kmem_free(nex2_ep);
  3235. erp->er_extcount += nex2;
  3236. xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, nex2);
  3237. }
  3238. }
  3239. /*
  3240. * This is called when the amount of space required for incore file
  3241. * extents needs to be decreased. The ext_diff parameter stores the
  3242. * number of extents to be removed and the idx parameter contains
  3243. * the extent index where the extents will be removed from.
  3244. *
  3245. * If the amount of space needed has decreased below the linear
  3246. * limit, XFS_IEXT_BUFSZ, then switch to using the contiguous
  3247. * extent array. Otherwise, use kmem_realloc() to adjust the
  3248. * size to what is needed.
  3249. */
  3250. void
  3251. xfs_iext_remove(
  3252. xfs_inode_t *ip, /* incore inode pointer */
  3253. xfs_extnum_t idx, /* index to begin removing exts */
  3254. int ext_diff, /* number of extents to remove */
  3255. int state) /* type of extent conversion */
  3256. {
  3257. xfs_ifork_t *ifp = (state & BMAP_ATTRFORK) ? ip->i_afp : &ip->i_df;
  3258. xfs_extnum_t nextents; /* number of extents in file */
  3259. int new_size; /* size of extents after removal */
  3260. trace_xfs_iext_remove(ip, idx, state, _RET_IP_);
  3261. ASSERT(ext_diff > 0);
  3262. nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
  3263. new_size = (nextents - ext_diff) * sizeof(xfs_bmbt_rec_t);
  3264. if (new_size == 0) {
  3265. xfs_iext_destroy(ifp);
  3266. } else if (ifp->if_flags & XFS_IFEXTIREC) {
  3267. xfs_iext_remove_indirect(ifp, idx, ext_diff);
  3268. } else if (ifp->if_real_bytes) {
  3269. xfs_iext_remove_direct(ifp, idx, ext_diff);
  3270. } else {
  3271. xfs_iext_remove_inline(ifp, idx, ext_diff);
  3272. }
  3273. ifp->if_bytes = new_size;
  3274. }
  3275. /*
  3276. * This removes ext_diff extents from the inline buffer, beginning
  3277. * at extent index idx.
  3278. */
  3279. void
  3280. xfs_iext_remove_inline(
  3281. xfs_ifork_t *ifp, /* inode fork pointer */
  3282. xfs_extnum_t idx, /* index to begin removing exts */
  3283. int ext_diff) /* number of extents to remove */
  3284. {
  3285. int nextents; /* number of extents in file */
  3286. ASSERT(!(ifp->if_flags & XFS_IFEXTIREC));
  3287. ASSERT(idx < XFS_INLINE_EXTS);
  3288. nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
  3289. ASSERT(((nextents - ext_diff) > 0) &&
  3290. (nextents - ext_diff) < XFS_INLINE_EXTS);
  3291. if (idx + ext_diff < nextents) {
  3292. memmove(&ifp->if_u2.if_inline_ext[idx],
  3293. &ifp->if_u2.if_inline_ext[idx + ext_diff],
  3294. (nextents - (idx + ext_diff)) *
  3295. sizeof(xfs_bmbt_rec_t));
  3296. memset(&ifp->if_u2.if_inline_ext[nextents - ext_diff],
  3297. 0, ext_diff * sizeof(xfs_bmbt_rec_t));
  3298. } else {
  3299. memset(&ifp->if_u2.if_inline_ext[idx], 0,
  3300. ext_diff * sizeof(xfs_bmbt_rec_t));
  3301. }
  3302. }
  3303. /*
  3304. * This removes ext_diff extents from a linear (direct) extent list,
  3305. * beginning at extent index idx. If the extents are being removed
  3306. * from the end of the list (ie. truncate) then we just need to re-
  3307. * allocate the list to remove the extra space. Otherwise, if the
  3308. * extents are being removed from the middle of the existing extent
  3309. * entries, then we first need to move the extent records beginning
  3310. * at idx + ext_diff up in the list to overwrite the records being
  3311. * removed, then remove the extra space via kmem_realloc.
  3312. */
  3313. void
  3314. xfs_iext_remove_direct(
  3315. xfs_ifork_t *ifp, /* inode fork pointer */
  3316. xfs_extnum_t idx, /* index to begin removing exts */
  3317. int ext_diff) /* number of extents to remove */
  3318. {
  3319. xfs_extnum_t nextents; /* number of extents in file */
  3320. int new_size; /* size of extents after removal */
  3321. ASSERT(!(ifp->if_flags & XFS_IFEXTIREC));
  3322. new_size = ifp->if_bytes -
  3323. (ext_diff * sizeof(xfs_bmbt_rec_t));
  3324. nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
  3325. if (new_size == 0) {
  3326. xfs_iext_destroy(ifp);
  3327. return;
  3328. }
  3329. /* Move extents up in the list (if needed) */
  3330. if (idx + ext_diff < nextents) {
  3331. memmove(&ifp->if_u1.if_extents[idx],
  3332. &ifp->if_u1.if_extents[idx + ext_diff],
  3333. (nextents - (idx + ext_diff)) *
  3334. sizeof(xfs_bmbt_rec_t));
  3335. }
  3336. memset(&ifp->if_u1.if_extents[nextents - ext_diff],
  3337. 0, ext_diff * sizeof(xfs_bmbt_rec_t));
  3338. /*
  3339. * Reallocate the direct extent list. If the extents
  3340. * will fit inside the inode then xfs_iext_realloc_direct
  3341. * will switch from direct to inline extent allocation
  3342. * mode for us.
  3343. */
  3344. xfs_iext_realloc_direct(ifp, new_size);
  3345. ifp->if_bytes = new_size;
  3346. }
  3347. /*
  3348. * This is called when incore extents are being removed from the
  3349. * indirection array and the extents being removed span multiple extent
  3350. * buffers. The idx parameter contains the file extent index where we
  3351. * want to begin removing extents, and the count parameter contains
  3352. * how many extents need to be removed.
  3353. *
  3354. * |-------| |-------|
  3355. * | nex1 | | | nex1 - number of extents before idx
  3356. * |-------| | count |
  3357. * | | | | count - number of extents being removed at idx
  3358. * | count | |-------|
  3359. * | | | nex2 | nex2 - number of extents after idx + count
  3360. * |-------| |-------|
  3361. */
  3362. void
  3363. xfs_iext_remove_indirect(
  3364. xfs_ifork_t *ifp, /* inode fork pointer */
  3365. xfs_extnum_t idx, /* index to begin removing extents */
  3366. int count) /* number of extents to remove */
  3367. {
  3368. xfs_ext_irec_t *erp; /* indirection array pointer */
  3369. int erp_idx = 0; /* indirection array index */
  3370. xfs_extnum_t ext_cnt; /* extents left to remove */
  3371. xfs_extnum_t ext_diff; /* extents to remove in current list */
  3372. xfs_extnum_t nex1; /* number of extents before idx */
  3373. xfs_extnum_t nex2; /* extents after idx + count */
  3374. int nlists; /* entries in indirection array */
  3375. int page_idx = idx; /* index in target extent list */
  3376. ASSERT(ifp->if_flags & XFS_IFEXTIREC);
  3377. erp = xfs_iext_idx_to_irec(ifp, &page_idx, &erp_idx, 0);
  3378. ASSERT(erp != NULL);
  3379. nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
  3380. nex1 = page_idx;
  3381. ext_cnt = count;
  3382. while (ext_cnt) {
  3383. nex2 = MAX((erp->er_extcount - (nex1 + ext_cnt)), 0);
  3384. ext_diff = MIN(ext_cnt, (erp->er_extcount - nex1));
  3385. /*
  3386. * Check for deletion of entire list;
  3387. * xfs_iext_irec_remove() updates extent offsets.
  3388. */
  3389. if (ext_diff == erp->er_extcount) {
  3390. xfs_iext_irec_remove(ifp, erp_idx);
  3391. ext_cnt -= ext_diff;
  3392. nex1 = 0;
  3393. if (ext_cnt) {
  3394. ASSERT(erp_idx < ifp->if_real_bytes /
  3395. XFS_IEXT_BUFSZ);
  3396. erp = &ifp->if_u1.if_ext_irec[erp_idx];
  3397. nex1 = 0;
  3398. continue;
  3399. } else {
  3400. break;
  3401. }
  3402. }
  3403. /* Move extents up (if needed) */
  3404. if (nex2) {
  3405. memmove(&erp->er_extbuf[nex1],
  3406. &erp->er_extbuf[nex1 + ext_diff],
  3407. nex2 * sizeof(xfs_bmbt_rec_t));
  3408. }
  3409. /* Zero out rest of page */
  3410. memset(&erp->er_extbuf[nex1 + nex2], 0, (XFS_IEXT_BUFSZ -
  3411. ((nex1 + nex2) * sizeof(xfs_bmbt_rec_t))));
  3412. /* Update remaining counters */
  3413. erp->er_extcount -= ext_diff;
  3414. xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, -ext_diff);
  3415. ext_cnt -= ext_diff;
  3416. nex1 = 0;
  3417. erp_idx++;
  3418. erp++;
  3419. }
  3420. ifp->if_bytes -= count * sizeof(xfs_bmbt_rec_t);
  3421. xfs_iext_irec_compact(ifp);
  3422. }
  3423. /*
  3424. * Create, destroy, or resize a linear (direct) block of extents.
  3425. */
  3426. void
  3427. xfs_iext_realloc_direct(
  3428. xfs_ifork_t *ifp, /* inode fork pointer */
  3429. int new_size) /* new size of extents */
  3430. {
  3431. int rnew_size; /* real new size of extents */
  3432. rnew_size = new_size;
  3433. ASSERT(!(ifp->if_flags & XFS_IFEXTIREC) ||
  3434. ((new_size >= 0) && (new_size <= XFS_IEXT_BUFSZ) &&
  3435. (new_size != ifp->if_real_bytes)));
  3436. /* Free extent records */
  3437. if (new_size == 0) {
  3438. xfs_iext_destroy(ifp);
  3439. }
  3440. /* Resize direct extent list and zero any new bytes */
  3441. else if (ifp->if_real_bytes) {
  3442. /* Check if extents will fit inside the inode */
  3443. if (new_size <= XFS_INLINE_EXTS * sizeof(xfs_bmbt_rec_t)) {
  3444. xfs_iext_direct_to_inline(ifp, new_size /
  3445. (uint)sizeof(xfs_bmbt_rec_t));
  3446. ifp->if_bytes = new_size;
  3447. return;
  3448. }
  3449. if (!is_power_of_2(new_size)){
  3450. rnew_size = roundup_pow_of_two(new_size);
  3451. }
  3452. if (rnew_size != ifp->if_real_bytes) {
  3453. ifp->if_u1.if_extents =
  3454. kmem_realloc(ifp->if_u1.if_extents,
  3455. rnew_size,
  3456. ifp->if_real_bytes, KM_NOFS);
  3457. }
  3458. if (rnew_size > ifp->if_real_bytes) {
  3459. memset(&ifp->if_u1.if_extents[ifp->if_bytes /
  3460. (uint)sizeof(xfs_bmbt_rec_t)], 0,
  3461. rnew_size - ifp->if_real_bytes);
  3462. }
  3463. }
  3464. /*
  3465. * Switch from the inline extent buffer to a direct
  3466. * extent list. Be sure to include the inline extent
  3467. * bytes in new_size.
  3468. */
  3469. else {
  3470. new_size += ifp->if_bytes;
  3471. if (!is_power_of_2(new_size)) {
  3472. rnew_size = roundup_pow_of_two(new_size);
  3473. }
  3474. xfs_iext_inline_to_direct(ifp, rnew_size);
  3475. }
  3476. ifp->if_real_bytes = rnew_size;
  3477. ifp->if_bytes = new_size;
  3478. }
  3479. /*
  3480. * Switch from linear (direct) extent records to inline buffer.
  3481. */
  3482. void
  3483. xfs_iext_direct_to_inline(
  3484. xfs_ifork_t *ifp, /* inode fork pointer */
  3485. xfs_extnum_t nextents) /* number of extents in file */
  3486. {
  3487. ASSERT(ifp->if_flags & XFS_IFEXTENTS);
  3488. ASSERT(nextents <= XFS_INLINE_EXTS);
  3489. /*
  3490. * The inline buffer was zeroed when we switched
  3491. * from inline to direct extent allocation mode,
  3492. * so we don't need to clear it here.
  3493. */
  3494. memcpy(ifp->if_u2.if_inline_ext, ifp->if_u1.if_extents,
  3495. nextents * sizeof(xfs_bmbt_rec_t));
  3496. kmem_free(ifp->if_u1.if_extents);
  3497. ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext;
  3498. ifp->if_real_bytes = 0;
  3499. }
  3500. /*
  3501. * Switch from inline buffer to linear (direct) extent records.
  3502. * new_size should already be rounded up to the next power of 2
  3503. * by the caller (when appropriate), so use new_size as it is.
  3504. * However, since new_size may be rounded up, we can't update
  3505. * if_bytes here. It is the caller's responsibility to update
  3506. * if_bytes upon return.
  3507. */
  3508. void
  3509. xfs_iext_inline_to_direct(
  3510. xfs_ifork_t *ifp, /* inode fork pointer */
  3511. int new_size) /* number of extents in file */
  3512. {
  3513. ifp->if_u1.if_extents = kmem_alloc(new_size, KM_NOFS);
  3514. memset(ifp->if_u1.if_extents, 0, new_size);
  3515. if (ifp->if_bytes) {
  3516. memcpy(ifp->if_u1.if_extents, ifp->if_u2.if_inline_ext,
  3517. ifp->if_bytes);
  3518. memset(ifp->if_u2.if_inline_ext, 0, XFS_INLINE_EXTS *
  3519. sizeof(xfs_bmbt_rec_t));
  3520. }
  3521. ifp->if_real_bytes = new_size;
  3522. }
  3523. /*
  3524. * Resize an extent indirection array to new_size bytes.
  3525. */
  3526. STATIC void
  3527. xfs_iext_realloc_indirect(
  3528. xfs_ifork_t *ifp, /* inode fork pointer */
  3529. int new_size) /* new indirection array size */
  3530. {
  3531. int nlists; /* number of irec's (ex lists) */
  3532. int size; /* current indirection array size */
  3533. ASSERT(ifp->if_flags & XFS_IFEXTIREC);
  3534. nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
  3535. size = nlists * sizeof(xfs_ext_irec_t);
  3536. ASSERT(ifp->if_real_bytes);
  3537. ASSERT((new_size >= 0) && (new_size != size));
  3538. if (new_size == 0) {
  3539. xfs_iext_destroy(ifp);
  3540. } else {
  3541. ifp->if_u1.if_ext_irec = (xfs_ext_irec_t *)
  3542. kmem_realloc(ifp->if_u1.if_ext_irec,
  3543. new_size, size, KM_NOFS);
  3544. }
  3545. }
  3546. /*
  3547. * Switch from indirection array to linear (direct) extent allocations.
  3548. */
  3549. STATIC void
  3550. xfs_iext_indirect_to_direct(
  3551. xfs_ifork_t *ifp) /* inode fork pointer */
  3552. {
  3553. xfs_bmbt_rec_host_t *ep; /* extent record pointer */
  3554. xfs_extnum_t nextents; /* number of extents in file */
  3555. int size; /* size of file extents */
  3556. ASSERT(ifp->if_flags & XFS_IFEXTIREC);
  3557. nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
  3558. ASSERT(nextents <= XFS_LINEAR_EXTS);
  3559. size = nextents * sizeof(xfs_bmbt_rec_t);
  3560. xfs_iext_irec_compact_pages(ifp);
  3561. ASSERT(ifp->if_real_bytes == XFS_IEXT_BUFSZ);
  3562. ep = ifp->if_u1.if_ext_irec->er_extbuf;
  3563. kmem_free(ifp->if_u1.if_ext_irec);
  3564. ifp->if_flags &= ~XFS_IFEXTIREC;
  3565. ifp->if_u1.if_extents = ep;
  3566. ifp->if_bytes = size;
  3567. if (nextents < XFS_LINEAR_EXTS) {
  3568. xfs_iext_realloc_direct(ifp, size);
  3569. }
  3570. }
  3571. /*
  3572. * Free incore file extents.
  3573. */
  3574. void
  3575. xfs_iext_destroy(
  3576. xfs_ifork_t *ifp) /* inode fork pointer */
  3577. {
  3578. if (ifp->if_flags & XFS_IFEXTIREC) {
  3579. int erp_idx;
  3580. int nlists;
  3581. nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
  3582. for (erp_idx = nlists - 1; erp_idx >= 0 ; erp_idx--) {
  3583. xfs_iext_irec_remove(ifp, erp_idx);
  3584. }
  3585. ifp->if_flags &= ~XFS_IFEXTIREC;
  3586. } else if (ifp->if_real_bytes) {
  3587. kmem_free(ifp->if_u1.if_extents);
  3588. } else if (ifp->if_bytes) {
  3589. memset(ifp->if_u2.if_inline_ext, 0, XFS_INLINE_EXTS *
  3590. sizeof(xfs_bmbt_rec_t));
  3591. }
  3592. ifp->if_u1.if_extents = NULL;
  3593. ifp->if_real_bytes = 0;
  3594. ifp->if_bytes = 0;
  3595. }
  3596. /*
  3597. * Return a pointer to the extent record for file system block bno.
  3598. */
  3599. xfs_bmbt_rec_host_t * /* pointer to found extent record */
  3600. xfs_iext_bno_to_ext(
  3601. xfs_ifork_t *ifp, /* inode fork pointer */
  3602. xfs_fileoff_t bno, /* block number to search for */
  3603. xfs_extnum_t *idxp) /* index of target extent */
  3604. {
  3605. xfs_bmbt_rec_host_t *base; /* pointer to first extent */
  3606. xfs_filblks_t blockcount = 0; /* number of blocks in extent */
  3607. xfs_bmbt_rec_host_t *ep = NULL; /* pointer to target extent */
  3608. xfs_ext_irec_t *erp = NULL; /* indirection array pointer */
  3609. int high; /* upper boundary in search */
  3610. xfs_extnum_t idx = 0; /* index of target extent */
  3611. int low; /* lower boundary in search */
  3612. xfs_extnum_t nextents; /* number of file extents */
  3613. xfs_fileoff_t startoff = 0; /* start offset of extent */
  3614. nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
  3615. if (nextents == 0) {
  3616. *idxp = 0;
  3617. return NULL;
  3618. }
  3619. low = 0;
  3620. if (ifp->if_flags & XFS_IFEXTIREC) {
  3621. /* Find target extent list */
  3622. int erp_idx = 0;
  3623. erp = xfs_iext_bno_to_irec(ifp, bno, &erp_idx);
  3624. base = erp->er_extbuf;
  3625. high = erp->er_extcount - 1;
  3626. } else {
  3627. base = ifp->if_u1.if_extents;
  3628. high = nextents - 1;
  3629. }
  3630. /* Binary search extent records */
  3631. while (low <= high) {
  3632. idx = (low + high) >> 1;
  3633. ep = base + idx;
  3634. startoff = xfs_bmbt_get_startoff(ep);
  3635. blockcount = xfs_bmbt_get_blockcount(ep);
  3636. if (bno < startoff) {
  3637. high = idx - 1;
  3638. } else if (bno >= startoff + blockcount) {
  3639. low = idx + 1;
  3640. } else {
  3641. /* Convert back to file-based extent index */
  3642. if (ifp->if_flags & XFS_IFEXTIREC) {
  3643. idx += erp->er_extoff;
  3644. }
  3645. *idxp = idx;
  3646. return ep;
  3647. }
  3648. }
  3649. /* Convert back to file-based extent index */
  3650. if (ifp->if_flags & XFS_IFEXTIREC) {
  3651. idx += erp->er_extoff;
  3652. }
  3653. if (bno >= startoff + blockcount) {
  3654. if (++idx == nextents) {
  3655. ep = NULL;
  3656. } else {
  3657. ep = xfs_iext_get_ext(ifp, idx);
  3658. }
  3659. }
  3660. *idxp = idx;
  3661. return ep;
  3662. }
  3663. /*
  3664. * Return a pointer to the indirection array entry containing the
  3665. * extent record for filesystem block bno. Store the index of the
  3666. * target irec in *erp_idxp.
  3667. */
  3668. xfs_ext_irec_t * /* pointer to found extent record */
  3669. xfs_iext_bno_to_irec(
  3670. xfs_ifork_t *ifp, /* inode fork pointer */
  3671. xfs_fileoff_t bno, /* block number to search for */
  3672. int *erp_idxp) /* irec index of target ext list */
  3673. {
  3674. xfs_ext_irec_t *erp = NULL; /* indirection array pointer */
  3675. xfs_ext_irec_t *erp_next; /* next indirection array entry */
  3676. int erp_idx; /* indirection array index */
  3677. int nlists; /* number of extent irec's (lists) */
  3678. int high; /* binary search upper limit */
  3679. int low; /* binary search lower limit */
  3680. ASSERT(ifp->if_flags & XFS_IFEXTIREC);
  3681. nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
  3682. erp_idx = 0;
  3683. low = 0;
  3684. high = nlists - 1;
  3685. while (low <= high) {
  3686. erp_idx = (low + high) >> 1;
  3687. erp = &ifp->if_u1.if_ext_irec[erp_idx];
  3688. erp_next = erp_idx < nlists - 1 ? erp + 1 : NULL;
  3689. if (bno < xfs_bmbt_get_startoff(erp->er_extbuf)) {
  3690. high = erp_idx - 1;
  3691. } else if (erp_next && bno >=
  3692. xfs_bmbt_get_startoff(erp_next->er_extbuf)) {
  3693. low = erp_idx + 1;
  3694. } else {
  3695. break;
  3696. }
  3697. }
  3698. *erp_idxp = erp_idx;
  3699. return erp;
  3700. }
  3701. /*
  3702. * Return a pointer to the indirection array entry containing the
  3703. * extent record at file extent index *idxp. Store the index of the
  3704. * target irec in *erp_idxp and store the page index of the target
  3705. * extent record in *idxp.
  3706. */
  3707. xfs_ext_irec_t *
  3708. xfs_iext_idx_to_irec(
  3709. xfs_ifork_t *ifp, /* inode fork pointer */
  3710. xfs_extnum_t *idxp, /* extent index (file -> page) */
  3711. int *erp_idxp, /* pointer to target irec */
  3712. int realloc) /* new bytes were just added */
  3713. {
  3714. xfs_ext_irec_t *prev; /* pointer to previous irec */
  3715. xfs_ext_irec_t *erp = NULL; /* pointer to current irec */
  3716. int erp_idx; /* indirection array index */
  3717. int nlists; /* number of irec's (ex lists) */
  3718. int high; /* binary search upper limit */
  3719. int low; /* binary search lower limit */
  3720. xfs_extnum_t page_idx = *idxp; /* extent index in target list */
  3721. ASSERT(ifp->if_flags & XFS_IFEXTIREC);
  3722. ASSERT(page_idx >= 0 && page_idx <=
  3723. ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t));
  3724. nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
  3725. erp_idx = 0;
  3726. low = 0;
  3727. high = nlists - 1;
  3728. /* Binary search extent irec's */
  3729. while (low <= high) {
  3730. erp_idx = (low + high) >> 1;
  3731. erp = &ifp->if_u1.if_ext_irec[erp_idx];
  3732. prev = erp_idx > 0 ? erp - 1 : NULL;
  3733. if (page_idx < erp->er_extoff || (page_idx == erp->er_extoff &&
  3734. realloc && prev && prev->er_extcount < XFS_LINEAR_EXTS)) {
  3735. high = erp_idx - 1;
  3736. } else if (page_idx > erp->er_extoff + erp->er_extcount ||
  3737. (page_idx == erp->er_extoff + erp->er_extcount &&
  3738. !realloc)) {
  3739. low = erp_idx + 1;
  3740. } else if (page_idx == erp->er_extoff + erp->er_extcount &&
  3741. erp->er_extcount == XFS_LINEAR_EXTS) {
  3742. ASSERT(realloc);
  3743. page_idx = 0;
  3744. erp_idx++;
  3745. erp = erp_idx < nlists ? erp + 1 : NULL;
  3746. break;
  3747. } else {
  3748. page_idx -= erp->er_extoff;
  3749. break;
  3750. }
  3751. }
  3752. *idxp = page_idx;
  3753. *erp_idxp = erp_idx;
  3754. return(erp);
  3755. }
  3756. /*
  3757. * Allocate and initialize an indirection array once the space needed
  3758. * for incore extents increases above XFS_IEXT_BUFSZ.
  3759. */
  3760. void
  3761. xfs_iext_irec_init(
  3762. xfs_ifork_t *ifp) /* inode fork pointer */
  3763. {
  3764. xfs_ext_irec_t *erp; /* indirection array pointer */
  3765. xfs_extnum_t nextents; /* number of extents in file */
  3766. ASSERT(!(ifp->if_flags & XFS_IFEXTIREC));
  3767. nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
  3768. ASSERT(nextents <= XFS_LINEAR_EXTS);
  3769. erp = kmem_alloc(sizeof(xfs_ext_irec_t), KM_NOFS);
  3770. if (nextents == 0) {
  3771. ifp->if_u1.if_extents = kmem_alloc(XFS_IEXT_BUFSZ, KM_NOFS);
  3772. } else if (!ifp->if_real_bytes) {
  3773. xfs_iext_inline_to_direct(ifp, XFS_IEXT_BUFSZ);
  3774. } else if (ifp->if_real_bytes < XFS_IEXT_BUFSZ) {
  3775. xfs_iext_realloc_direct(ifp, XFS_IEXT_BUFSZ);
  3776. }
  3777. erp->er_extbuf = ifp->if_u1.if_extents;
  3778. erp->er_extcount = nextents;
  3779. erp->er_extoff = 0;
  3780. ifp->if_flags |= XFS_IFEXTIREC;
  3781. ifp->if_real_bytes = XFS_IEXT_BUFSZ;
  3782. ifp->if_bytes = nextents * sizeof(xfs_bmbt_rec_t);
  3783. ifp->if_u1.if_ext_irec = erp;
  3784. return;
  3785. }
  3786. /*
  3787. * Allocate and initialize a new entry in the indirection array.
  3788. */
  3789. xfs_ext_irec_t *
  3790. xfs_iext_irec_new(
  3791. xfs_ifork_t *ifp, /* inode fork pointer */
  3792. int erp_idx) /* index for new irec */
  3793. {
  3794. xfs_ext_irec_t *erp; /* indirection array pointer */
  3795. int i; /* loop counter */
  3796. int nlists; /* number of irec's (ex lists) */
  3797. ASSERT(ifp->if_flags & XFS_IFEXTIREC);
  3798. nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
  3799. /* Resize indirection array */
  3800. xfs_iext_realloc_indirect(ifp, ++nlists *
  3801. sizeof(xfs_ext_irec_t));
  3802. /*
  3803. * Move records down in the array so the
  3804. * new page can use erp_idx.
  3805. */
  3806. erp = ifp->if_u1.if_ext_irec;
  3807. for (i = nlists - 1; i > erp_idx; i--) {
  3808. memmove(&erp[i], &erp[i-1], sizeof(xfs_ext_irec_t));
  3809. }
  3810. ASSERT(i == erp_idx);
  3811. /* Initialize new extent record */
  3812. erp = ifp->if_u1.if_ext_irec;
  3813. erp[erp_idx].er_extbuf = kmem_alloc(XFS_IEXT_BUFSZ, KM_NOFS);
  3814. ifp->if_real_bytes = nlists * XFS_IEXT_BUFSZ;
  3815. memset(erp[erp_idx].er_extbuf, 0, XFS_IEXT_BUFSZ);
  3816. erp[erp_idx].er_extcount = 0;
  3817. erp[erp_idx].er_extoff = erp_idx > 0 ?
  3818. erp[erp_idx-1].er_extoff + erp[erp_idx-1].er_extcount : 0;
  3819. return (&erp[erp_idx]);
  3820. }
  3821. /*
  3822. * Remove a record from the indirection array.
  3823. */
  3824. void
  3825. xfs_iext_irec_remove(
  3826. xfs_ifork_t *ifp, /* inode fork pointer */
  3827. int erp_idx) /* irec index to remove */
  3828. {
  3829. xfs_ext_irec_t *erp; /* indirection array pointer */
  3830. int i; /* loop counter */
  3831. int nlists; /* number of irec's (ex lists) */
  3832. ASSERT(ifp->if_flags & XFS_IFEXTIREC);
  3833. nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
  3834. erp = &ifp->if_u1.if_ext_irec[erp_idx];
  3835. if (erp->er_extbuf) {
  3836. xfs_iext_irec_update_extoffs(ifp, erp_idx + 1,
  3837. -erp->er_extcount);
  3838. kmem_free(erp->er_extbuf);
  3839. }
  3840. /* Compact extent records */
  3841. erp = ifp->if_u1.if_ext_irec;
  3842. for (i = erp_idx; i < nlists - 1; i++) {
  3843. memmove(&erp[i], &erp[i+1], sizeof(xfs_ext_irec_t));
  3844. }
  3845. /*
  3846. * Manually free the last extent record from the indirection
  3847. * array. A call to xfs_iext_realloc_indirect() with a size
  3848. * of zero would result in a call to xfs_iext_destroy() which
  3849. * would in turn call this function again, creating a nasty
  3850. * infinite loop.
  3851. */
  3852. if (--nlists) {
  3853. xfs_iext_realloc_indirect(ifp,
  3854. nlists * sizeof(xfs_ext_irec_t));
  3855. } else {
  3856. kmem_free(ifp->if_u1.if_ext_irec);
  3857. }
  3858. ifp->if_real_bytes = nlists * XFS_IEXT_BUFSZ;
  3859. }
  3860. /*
  3861. * This is called to clean up large amounts of unused memory allocated
  3862. * by the indirection array. Before compacting anything though, verify
  3863. * that the indirection array is still needed and switch back to the
  3864. * linear extent list (or even the inline buffer) if possible. The
  3865. * compaction policy is as follows:
  3866. *
  3867. * Full Compaction: Extents fit into a single page (or inline buffer)
  3868. * Partial Compaction: Extents occupy less than 50% of allocated space
  3869. * No Compaction: Extents occupy at least 50% of allocated space
  3870. */
  3871. void
  3872. xfs_iext_irec_compact(
  3873. xfs_ifork_t *ifp) /* inode fork pointer */
  3874. {
  3875. xfs_extnum_t nextents; /* number of extents in file */
  3876. int nlists; /* number of irec's (ex lists) */
  3877. ASSERT(ifp->if_flags & XFS_IFEXTIREC);
  3878. nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
  3879. nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
  3880. if (nextents == 0) {
  3881. xfs_iext_destroy(ifp);
  3882. } else if (nextents <= XFS_INLINE_EXTS) {
  3883. xfs_iext_indirect_to_direct(ifp);
  3884. xfs_iext_direct_to_inline(ifp, nextents);
  3885. } else if (nextents <= XFS_LINEAR_EXTS) {
  3886. xfs_iext_indirect_to_direct(ifp);
  3887. } else if (nextents < (nlists * XFS_LINEAR_EXTS) >> 1) {
  3888. xfs_iext_irec_compact_pages(ifp);
  3889. }
  3890. }
  3891. /*
  3892. * Combine extents from neighboring extent pages.
  3893. */
  3894. void
  3895. xfs_iext_irec_compact_pages(
  3896. xfs_ifork_t *ifp) /* inode fork pointer */
  3897. {
  3898. xfs_ext_irec_t *erp, *erp_next;/* pointers to irec entries */
  3899. int erp_idx = 0; /* indirection array index */
  3900. int nlists; /* number of irec's (ex lists) */
  3901. ASSERT(ifp->if_flags & XFS_IFEXTIREC);
  3902. nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
  3903. while (erp_idx < nlists - 1) {
  3904. erp = &ifp->if_u1.if_ext_irec[erp_idx];
  3905. erp_next = erp + 1;
  3906. if (erp_next->er_extcount <=
  3907. (XFS_LINEAR_EXTS - erp->er_extcount)) {
  3908. memcpy(&erp->er_extbuf[erp->er_extcount],
  3909. erp_next->er_extbuf, erp_next->er_extcount *
  3910. sizeof(xfs_bmbt_rec_t));
  3911. erp->er_extcount += erp_next->er_extcount;
  3912. /*
  3913. * Free page before removing extent record
  3914. * so er_extoffs don't get modified in
  3915. * xfs_iext_irec_remove.
  3916. */
  3917. kmem_free(erp_next->er_extbuf);
  3918. erp_next->er_extbuf = NULL;
  3919. xfs_iext_irec_remove(ifp, erp_idx + 1);
  3920. nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
  3921. } else {
  3922. erp_idx++;
  3923. }
  3924. }
  3925. }
  3926. /*
  3927. * This is called to update the er_extoff field in the indirection
  3928. * array when extents have been added or removed from one of the
  3929. * extent lists. erp_idx contains the irec index to begin updating
  3930. * at and ext_diff contains the number of extents that were added
  3931. * or removed.
  3932. */
  3933. void
  3934. xfs_iext_irec_update_extoffs(
  3935. xfs_ifork_t *ifp, /* inode fork pointer */
  3936. int erp_idx, /* irec index to update */
  3937. int ext_diff) /* number of new extents */
  3938. {
  3939. int i; /* loop counter */
  3940. int nlists; /* number of irec's (ex lists */
  3941. ASSERT(ifp->if_flags & XFS_IFEXTIREC);
  3942. nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
  3943. for (i = erp_idx; i < nlists; i++) {
  3944. ifp->if_u1.if_ext_irec[i].er_extoff += ext_diff;
  3945. }
  3946. }