super.c 83 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070
  1. /*
  2. * linux/fs/ext3/super.c
  3. *
  4. * Copyright (C) 1992, 1993, 1994, 1995
  5. * Remy Card (card@masi.ibp.fr)
  6. * Laboratoire MASI - Institut Blaise Pascal
  7. * Universite Pierre et Marie Curie (Paris VI)
  8. *
  9. * from
  10. *
  11. * linux/fs/minix/inode.c
  12. *
  13. * Copyright (C) 1991, 1992 Linus Torvalds
  14. *
  15. * Big-endian to little-endian byte-swapping/bitmaps by
  16. * David S. Miller (davem@caip.rutgers.edu), 1995
  17. */
  18. #include <linux/module.h>
  19. #include <linux/string.h>
  20. #include <linux/fs.h>
  21. #include <linux/time.h>
  22. #include <linux/jbd.h>
  23. #include <linux/ext3_fs.h>
  24. #include <linux/ext3_jbd.h>
  25. #include <linux/slab.h>
  26. #include <linux/init.h>
  27. #include <linux/blkdev.h>
  28. #include <linux/parser.h>
  29. #include <linux/smp_lock.h>
  30. #include <linux/buffer_head.h>
  31. #include <linux/exportfs.h>
  32. #include <linux/vfs.h>
  33. #include <linux/random.h>
  34. #include <linux/mount.h>
  35. #include <linux/namei.h>
  36. #include <linux/quotaops.h>
  37. #include <linux/seq_file.h>
  38. #include <linux/log2.h>
  39. #include <asm/uaccess.h>
  40. #include "xattr.h"
  41. #include "acl.h"
  42. #include "namei.h"
  43. #ifdef CONFIG_EXT3_DEFAULTS_TO_ORDERED
  44. #define EXT3_MOUNT_DEFAULT_DATA_MODE EXT3_MOUNT_ORDERED_DATA
  45. #else
  46. #define EXT3_MOUNT_DEFAULT_DATA_MODE EXT3_MOUNT_WRITEBACK_DATA
  47. #endif
  48. static int ext3_load_journal(struct super_block *, struct ext3_super_block *,
  49. unsigned long journal_devnum);
  50. static int ext3_create_journal(struct super_block *, struct ext3_super_block *,
  51. unsigned int);
  52. static int ext3_commit_super(struct super_block *sb,
  53. struct ext3_super_block *es,
  54. int sync);
  55. static void ext3_mark_recovery_complete(struct super_block * sb,
  56. struct ext3_super_block * es);
  57. static void ext3_clear_journal_err(struct super_block * sb,
  58. struct ext3_super_block * es);
  59. static int ext3_sync_fs(struct super_block *sb, int wait);
  60. static const char *ext3_decode_error(struct super_block * sb, int errno,
  61. char nbuf[16]);
  62. static int ext3_remount (struct super_block * sb, int * flags, char * data);
  63. static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf);
  64. static int ext3_unfreeze(struct super_block *sb);
  65. static int ext3_freeze(struct super_block *sb);
  66. /*
  67. * Wrappers for journal_start/end.
  68. *
  69. * The only special thing we need to do here is to make sure that all
  70. * journal_end calls result in the superblock being marked dirty, so
  71. * that sync() will call the filesystem's write_super callback if
  72. * appropriate.
  73. */
  74. handle_t *ext3_journal_start_sb(struct super_block *sb, int nblocks)
  75. {
  76. journal_t *journal;
  77. if (sb->s_flags & MS_RDONLY)
  78. return ERR_PTR(-EROFS);
  79. /* Special case here: if the journal has aborted behind our
  80. * backs (eg. EIO in the commit thread), then we still need to
  81. * take the FS itself readonly cleanly. */
  82. journal = EXT3_SB(sb)->s_journal;
  83. if (is_journal_aborted(journal)) {
  84. ext3_abort(sb, __func__,
  85. "Detected aborted journal");
  86. return ERR_PTR(-EROFS);
  87. }
  88. return journal_start(journal, nblocks);
  89. }
  90. /*
  91. * The only special thing we need to do here is to make sure that all
  92. * journal_stop calls result in the superblock being marked dirty, so
  93. * that sync() will call the filesystem's write_super callback if
  94. * appropriate.
  95. */
  96. int __ext3_journal_stop(const char *where, handle_t *handle)
  97. {
  98. struct super_block *sb;
  99. int err;
  100. int rc;
  101. sb = handle->h_transaction->t_journal->j_private;
  102. err = handle->h_err;
  103. rc = journal_stop(handle);
  104. if (!err)
  105. err = rc;
  106. if (err)
  107. __ext3_std_error(sb, where, err);
  108. return err;
  109. }
  110. void ext3_journal_abort_handle(const char *caller, const char *err_fn,
  111. struct buffer_head *bh, handle_t *handle, int err)
  112. {
  113. char nbuf[16];
  114. const char *errstr = ext3_decode_error(NULL, err, nbuf);
  115. if (bh)
  116. BUFFER_TRACE(bh, "abort");
  117. if (!handle->h_err)
  118. handle->h_err = err;
  119. if (is_handle_aborted(handle))
  120. return;
  121. printk(KERN_ERR "EXT3-fs: %s: aborting transaction: %s in %s\n",
  122. caller, errstr, err_fn);
  123. journal_abort_handle(handle);
  124. }
  125. void ext3_msg(struct super_block *sb, const char *prefix,
  126. const char *fmt, ...)
  127. {
  128. va_list args;
  129. va_start(args, fmt);
  130. printk("%sEXT3-fs (%s): ", prefix, sb->s_id);
  131. vprintk(fmt, args);
  132. printk("\n");
  133. va_end(args);
  134. }
  135. /* Deal with the reporting of failure conditions on a filesystem such as
  136. * inconsistencies detected or read IO failures.
  137. *
  138. * On ext2, we can store the error state of the filesystem in the
  139. * superblock. That is not possible on ext3, because we may have other
  140. * write ordering constraints on the superblock which prevent us from
  141. * writing it out straight away; and given that the journal is about to
  142. * be aborted, we can't rely on the current, or future, transactions to
  143. * write out the superblock safely.
  144. *
  145. * We'll just use the journal_abort() error code to record an error in
  146. * the journal instead. On recovery, the journal will complain about
  147. * that error until we've noted it down and cleared it.
  148. */
  149. static void ext3_handle_error(struct super_block *sb)
  150. {
  151. struct ext3_super_block *es = EXT3_SB(sb)->s_es;
  152. EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
  153. es->s_state |= cpu_to_le16(EXT3_ERROR_FS);
  154. if (sb->s_flags & MS_RDONLY)
  155. return;
  156. if (!test_opt (sb, ERRORS_CONT)) {
  157. journal_t *journal = EXT3_SB(sb)->s_journal;
  158. set_opt(EXT3_SB(sb)->s_mount_opt, ABORT);
  159. if (journal)
  160. journal_abort(journal, -EIO);
  161. }
  162. if (test_opt (sb, ERRORS_RO)) {
  163. ext3_msg(sb, KERN_CRIT,
  164. "error: remounting filesystem read-only");
  165. sb->s_flags |= MS_RDONLY;
  166. }
  167. ext3_commit_super(sb, es, 1);
  168. if (test_opt(sb, ERRORS_PANIC))
  169. panic("EXT3-fs (%s): panic forced after error\n",
  170. sb->s_id);
  171. }
  172. void ext3_error (struct super_block * sb, const char * function,
  173. const char * fmt, ...)
  174. {
  175. va_list args;
  176. va_start(args, fmt);
  177. printk(KERN_CRIT "EXT3-fs error (device %s): %s: ",sb->s_id, function);
  178. vprintk(fmt, args);
  179. printk("\n");
  180. va_end(args);
  181. ext3_handle_error(sb);
  182. }
  183. static const char *ext3_decode_error(struct super_block * sb, int errno,
  184. char nbuf[16])
  185. {
  186. char *errstr = NULL;
  187. switch (errno) {
  188. case -EIO:
  189. errstr = "IO failure";
  190. break;
  191. case -ENOMEM:
  192. errstr = "Out of memory";
  193. break;
  194. case -EROFS:
  195. if (!sb || EXT3_SB(sb)->s_journal->j_flags & JFS_ABORT)
  196. errstr = "Journal has aborted";
  197. else
  198. errstr = "Readonly filesystem";
  199. break;
  200. default:
  201. /* If the caller passed in an extra buffer for unknown
  202. * errors, textualise them now. Else we just return
  203. * NULL. */
  204. if (nbuf) {
  205. /* Check for truncated error codes... */
  206. if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
  207. errstr = nbuf;
  208. }
  209. break;
  210. }
  211. return errstr;
  212. }
  213. /* __ext3_std_error decodes expected errors from journaling functions
  214. * automatically and invokes the appropriate error response. */
  215. void __ext3_std_error (struct super_block * sb, const char * function,
  216. int errno)
  217. {
  218. char nbuf[16];
  219. const char *errstr;
  220. /* Special case: if the error is EROFS, and we're not already
  221. * inside a transaction, then there's really no point in logging
  222. * an error. */
  223. if (errno == -EROFS && journal_current_handle() == NULL &&
  224. (sb->s_flags & MS_RDONLY))
  225. return;
  226. errstr = ext3_decode_error(sb, errno, nbuf);
  227. ext3_msg(sb, KERN_CRIT, "error in %s: %s", function, errstr);
  228. ext3_handle_error(sb);
  229. }
  230. /*
  231. * ext3_abort is a much stronger failure handler than ext3_error. The
  232. * abort function may be used to deal with unrecoverable failures such
  233. * as journal IO errors or ENOMEM at a critical moment in log management.
  234. *
  235. * We unconditionally force the filesystem into an ABORT|READONLY state,
  236. * unless the error response on the fs has been set to panic in which
  237. * case we take the easy way out and panic immediately.
  238. */
  239. void ext3_abort (struct super_block * sb, const char * function,
  240. const char * fmt, ...)
  241. {
  242. va_list args;
  243. va_start(args, fmt);
  244. printk(KERN_CRIT "EXT3-fs (%s): error: %s: ", sb->s_id, function);
  245. vprintk(fmt, args);
  246. printk("\n");
  247. va_end(args);
  248. if (test_opt(sb, ERRORS_PANIC))
  249. panic("EXT3-fs: panic from previous error\n");
  250. if (sb->s_flags & MS_RDONLY)
  251. return;
  252. ext3_msg(sb, KERN_CRIT,
  253. "error: remounting filesystem read-only");
  254. EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
  255. sb->s_flags |= MS_RDONLY;
  256. set_opt(EXT3_SB(sb)->s_mount_opt, ABORT);
  257. if (EXT3_SB(sb)->s_journal)
  258. journal_abort(EXT3_SB(sb)->s_journal, -EIO);
  259. }
  260. void ext3_warning (struct super_block * sb, const char * function,
  261. const char * fmt, ...)
  262. {
  263. va_list args;
  264. va_start(args, fmt);
  265. printk(KERN_WARNING "EXT3-fs (%s): warning: %s: ",
  266. sb->s_id, function);
  267. vprintk(fmt, args);
  268. printk("\n");
  269. va_end(args);
  270. }
  271. void ext3_update_dynamic_rev(struct super_block *sb)
  272. {
  273. struct ext3_super_block *es = EXT3_SB(sb)->s_es;
  274. if (le32_to_cpu(es->s_rev_level) > EXT3_GOOD_OLD_REV)
  275. return;
  276. ext3_msg(sb, KERN_WARNING,
  277. "warning: updating to rev %d because of "
  278. "new feature flag, running e2fsck is recommended",
  279. EXT3_DYNAMIC_REV);
  280. es->s_first_ino = cpu_to_le32(EXT3_GOOD_OLD_FIRST_INO);
  281. es->s_inode_size = cpu_to_le16(EXT3_GOOD_OLD_INODE_SIZE);
  282. es->s_rev_level = cpu_to_le32(EXT3_DYNAMIC_REV);
  283. /* leave es->s_feature_*compat flags alone */
  284. /* es->s_uuid will be set by e2fsck if empty */
  285. /*
  286. * The rest of the superblock fields should be zero, and if not it
  287. * means they are likely already in use, so leave them alone. We
  288. * can leave it up to e2fsck to clean up any inconsistencies there.
  289. */
  290. }
  291. /*
  292. * Open the external journal device
  293. */
  294. static struct block_device *ext3_blkdev_get(dev_t dev, struct super_block *sb)
  295. {
  296. struct block_device *bdev;
  297. char b[BDEVNAME_SIZE];
  298. bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
  299. if (IS_ERR(bdev))
  300. goto fail;
  301. return bdev;
  302. fail:
  303. ext3_msg(sb, "error: failed to open journal device %s: %ld",
  304. __bdevname(dev, b), PTR_ERR(bdev));
  305. return NULL;
  306. }
  307. /*
  308. * Release the journal device
  309. */
  310. static int ext3_blkdev_put(struct block_device *bdev)
  311. {
  312. bd_release(bdev);
  313. return blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
  314. }
  315. static int ext3_blkdev_remove(struct ext3_sb_info *sbi)
  316. {
  317. struct block_device *bdev;
  318. int ret = -ENODEV;
  319. bdev = sbi->journal_bdev;
  320. if (bdev) {
  321. ret = ext3_blkdev_put(bdev);
  322. sbi->journal_bdev = NULL;
  323. }
  324. return ret;
  325. }
  326. static inline struct inode *orphan_list_entry(struct list_head *l)
  327. {
  328. return &list_entry(l, struct ext3_inode_info, i_orphan)->vfs_inode;
  329. }
  330. static void dump_orphan_list(struct super_block *sb, struct ext3_sb_info *sbi)
  331. {
  332. struct list_head *l;
  333. ext3_msg(sb, KERN_ERR, "error: sb orphan head is %d",
  334. le32_to_cpu(sbi->s_es->s_last_orphan));
  335. ext3_msg(sb, KERN_ERR, "sb_info orphan list:");
  336. list_for_each(l, &sbi->s_orphan) {
  337. struct inode *inode = orphan_list_entry(l);
  338. ext3_msg(sb, KERN_ERR, " "
  339. "inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
  340. inode->i_sb->s_id, inode->i_ino, inode,
  341. inode->i_mode, inode->i_nlink,
  342. NEXT_ORPHAN(inode));
  343. }
  344. }
  345. static void ext3_put_super (struct super_block * sb)
  346. {
  347. struct ext3_sb_info *sbi = EXT3_SB(sb);
  348. struct ext3_super_block *es = sbi->s_es;
  349. int i, err;
  350. lock_kernel();
  351. ext3_xattr_put_super(sb);
  352. err = journal_destroy(sbi->s_journal);
  353. sbi->s_journal = NULL;
  354. if (err < 0)
  355. ext3_abort(sb, __func__, "Couldn't clean up the journal");
  356. if (!(sb->s_flags & MS_RDONLY)) {
  357. EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
  358. es->s_state = cpu_to_le16(sbi->s_mount_state);
  359. BUFFER_TRACE(sbi->s_sbh, "marking dirty");
  360. mark_buffer_dirty(sbi->s_sbh);
  361. ext3_commit_super(sb, es, 1);
  362. }
  363. for (i = 0; i < sbi->s_gdb_count; i++)
  364. brelse(sbi->s_group_desc[i]);
  365. kfree(sbi->s_group_desc);
  366. percpu_counter_destroy(&sbi->s_freeblocks_counter);
  367. percpu_counter_destroy(&sbi->s_freeinodes_counter);
  368. percpu_counter_destroy(&sbi->s_dirs_counter);
  369. brelse(sbi->s_sbh);
  370. #ifdef CONFIG_QUOTA
  371. for (i = 0; i < MAXQUOTAS; i++)
  372. kfree(sbi->s_qf_names[i]);
  373. #endif
  374. /* Debugging code just in case the in-memory inode orphan list
  375. * isn't empty. The on-disk one can be non-empty if we've
  376. * detected an error and taken the fs readonly, but the
  377. * in-memory list had better be clean by this point. */
  378. if (!list_empty(&sbi->s_orphan))
  379. dump_orphan_list(sb, sbi);
  380. J_ASSERT(list_empty(&sbi->s_orphan));
  381. invalidate_bdev(sb->s_bdev);
  382. if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) {
  383. /*
  384. * Invalidate the journal device's buffers. We don't want them
  385. * floating about in memory - the physical journal device may
  386. * hotswapped, and it breaks the `ro-after' testing code.
  387. */
  388. sync_blockdev(sbi->journal_bdev);
  389. invalidate_bdev(sbi->journal_bdev);
  390. ext3_blkdev_remove(sbi);
  391. }
  392. sb->s_fs_info = NULL;
  393. kfree(sbi->s_blockgroup_lock);
  394. kfree(sbi);
  395. unlock_kernel();
  396. }
  397. static struct kmem_cache *ext3_inode_cachep;
  398. /*
  399. * Called inside transaction, so use GFP_NOFS
  400. */
  401. static struct inode *ext3_alloc_inode(struct super_block *sb)
  402. {
  403. struct ext3_inode_info *ei;
  404. ei = kmem_cache_alloc(ext3_inode_cachep, GFP_NOFS);
  405. if (!ei)
  406. return NULL;
  407. ei->i_block_alloc_info = NULL;
  408. ei->vfs_inode.i_version = 1;
  409. atomic_set(&ei->i_datasync_tid, 0);
  410. atomic_set(&ei->i_sync_tid, 0);
  411. return &ei->vfs_inode;
  412. }
  413. static void ext3_destroy_inode(struct inode *inode)
  414. {
  415. if (!list_empty(&(EXT3_I(inode)->i_orphan))) {
  416. printk("EXT3 Inode %p: orphan list check failed!\n",
  417. EXT3_I(inode));
  418. print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
  419. EXT3_I(inode), sizeof(struct ext3_inode_info),
  420. false);
  421. dump_stack();
  422. }
  423. kmem_cache_free(ext3_inode_cachep, EXT3_I(inode));
  424. }
  425. static void init_once(void *foo)
  426. {
  427. struct ext3_inode_info *ei = (struct ext3_inode_info *) foo;
  428. INIT_LIST_HEAD(&ei->i_orphan);
  429. #ifdef CONFIG_EXT3_FS_XATTR
  430. init_rwsem(&ei->xattr_sem);
  431. #endif
  432. mutex_init(&ei->truncate_mutex);
  433. inode_init_once(&ei->vfs_inode);
  434. }
  435. static int init_inodecache(void)
  436. {
  437. ext3_inode_cachep = kmem_cache_create("ext3_inode_cache",
  438. sizeof(struct ext3_inode_info),
  439. 0, (SLAB_RECLAIM_ACCOUNT|
  440. SLAB_MEM_SPREAD),
  441. init_once);
  442. if (ext3_inode_cachep == NULL)
  443. return -ENOMEM;
  444. return 0;
  445. }
  446. static void destroy_inodecache(void)
  447. {
  448. kmem_cache_destroy(ext3_inode_cachep);
  449. }
  450. static void ext3_clear_inode(struct inode *inode)
  451. {
  452. struct ext3_block_alloc_info *rsv = EXT3_I(inode)->i_block_alloc_info;
  453. dquot_drop(inode);
  454. ext3_discard_reservation(inode);
  455. EXT3_I(inode)->i_block_alloc_info = NULL;
  456. if (unlikely(rsv))
  457. kfree(rsv);
  458. }
  459. static inline void ext3_show_quota_options(struct seq_file *seq, struct super_block *sb)
  460. {
  461. #if defined(CONFIG_QUOTA)
  462. struct ext3_sb_info *sbi = EXT3_SB(sb);
  463. if (sbi->s_jquota_fmt) {
  464. char *fmtname = "";
  465. switch (sbi->s_jquota_fmt) {
  466. case QFMT_VFS_OLD:
  467. fmtname = "vfsold";
  468. break;
  469. case QFMT_VFS_V0:
  470. fmtname = "vfsv0";
  471. break;
  472. case QFMT_VFS_V1:
  473. fmtname = "vfsv1";
  474. break;
  475. }
  476. seq_printf(seq, ",jqfmt=%s", fmtname);
  477. }
  478. if (sbi->s_qf_names[USRQUOTA])
  479. seq_printf(seq, ",usrjquota=%s", sbi->s_qf_names[USRQUOTA]);
  480. if (sbi->s_qf_names[GRPQUOTA])
  481. seq_printf(seq, ",grpjquota=%s", sbi->s_qf_names[GRPQUOTA]);
  482. if (test_opt(sb, USRQUOTA))
  483. seq_puts(seq, ",usrquota");
  484. if (test_opt(sb, GRPQUOTA))
  485. seq_puts(seq, ",grpquota");
  486. #endif
  487. }
  488. static char *data_mode_string(unsigned long mode)
  489. {
  490. switch (mode) {
  491. case EXT3_MOUNT_JOURNAL_DATA:
  492. return "journal";
  493. case EXT3_MOUNT_ORDERED_DATA:
  494. return "ordered";
  495. case EXT3_MOUNT_WRITEBACK_DATA:
  496. return "writeback";
  497. }
  498. return "unknown";
  499. }
  500. /*
  501. * Show an option if
  502. * - it's set to a non-default value OR
  503. * - if the per-sb default is different from the global default
  504. */
  505. static int ext3_show_options(struct seq_file *seq, struct vfsmount *vfs)
  506. {
  507. struct super_block *sb = vfs->mnt_sb;
  508. struct ext3_sb_info *sbi = EXT3_SB(sb);
  509. struct ext3_super_block *es = sbi->s_es;
  510. unsigned long def_mount_opts;
  511. def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
  512. if (sbi->s_sb_block != 1)
  513. seq_printf(seq, ",sb=%lu", sbi->s_sb_block);
  514. if (test_opt(sb, MINIX_DF))
  515. seq_puts(seq, ",minixdf");
  516. if (test_opt(sb, GRPID))
  517. seq_puts(seq, ",grpid");
  518. if (!test_opt(sb, GRPID) && (def_mount_opts & EXT3_DEFM_BSDGROUPS))
  519. seq_puts(seq, ",nogrpid");
  520. if (sbi->s_resuid != EXT3_DEF_RESUID ||
  521. le16_to_cpu(es->s_def_resuid) != EXT3_DEF_RESUID) {
  522. seq_printf(seq, ",resuid=%u", sbi->s_resuid);
  523. }
  524. if (sbi->s_resgid != EXT3_DEF_RESGID ||
  525. le16_to_cpu(es->s_def_resgid) != EXT3_DEF_RESGID) {
  526. seq_printf(seq, ",resgid=%u", sbi->s_resgid);
  527. }
  528. if (test_opt(sb, ERRORS_RO)) {
  529. int def_errors = le16_to_cpu(es->s_errors);
  530. if (def_errors == EXT3_ERRORS_PANIC ||
  531. def_errors == EXT3_ERRORS_CONTINUE) {
  532. seq_puts(seq, ",errors=remount-ro");
  533. }
  534. }
  535. if (test_opt(sb, ERRORS_CONT))
  536. seq_puts(seq, ",errors=continue");
  537. if (test_opt(sb, ERRORS_PANIC))
  538. seq_puts(seq, ",errors=panic");
  539. if (test_opt(sb, NO_UID32))
  540. seq_puts(seq, ",nouid32");
  541. if (test_opt(sb, DEBUG))
  542. seq_puts(seq, ",debug");
  543. if (test_opt(sb, OLDALLOC))
  544. seq_puts(seq, ",oldalloc");
  545. #ifdef CONFIG_EXT3_FS_XATTR
  546. if (test_opt(sb, XATTR_USER))
  547. seq_puts(seq, ",user_xattr");
  548. if (!test_opt(sb, XATTR_USER) &&
  549. (def_mount_opts & EXT3_DEFM_XATTR_USER)) {
  550. seq_puts(seq, ",nouser_xattr");
  551. }
  552. #endif
  553. #ifdef CONFIG_EXT3_FS_POSIX_ACL
  554. if (test_opt(sb, POSIX_ACL))
  555. seq_puts(seq, ",acl");
  556. if (!test_opt(sb, POSIX_ACL) && (def_mount_opts & EXT3_DEFM_ACL))
  557. seq_puts(seq, ",noacl");
  558. #endif
  559. if (!test_opt(sb, RESERVATION))
  560. seq_puts(seq, ",noreservation");
  561. if (sbi->s_commit_interval) {
  562. seq_printf(seq, ",commit=%u",
  563. (unsigned) (sbi->s_commit_interval / HZ));
  564. }
  565. /*
  566. * Always display barrier state so it's clear what the status is.
  567. */
  568. seq_puts(seq, ",barrier=");
  569. seq_puts(seq, test_opt(sb, BARRIER) ? "1" : "0");
  570. if (test_opt(sb, NOBH))
  571. seq_puts(seq, ",nobh");
  572. seq_printf(seq, ",data=%s", data_mode_string(test_opt(sb, DATA_FLAGS)));
  573. if (test_opt(sb, DATA_ERR_ABORT))
  574. seq_puts(seq, ",data_err=abort");
  575. if (test_opt(sb, NOLOAD))
  576. seq_puts(seq, ",norecovery");
  577. ext3_show_quota_options(seq, sb);
  578. return 0;
  579. }
  580. static struct inode *ext3_nfs_get_inode(struct super_block *sb,
  581. u64 ino, u32 generation)
  582. {
  583. struct inode *inode;
  584. if (ino < EXT3_FIRST_INO(sb) && ino != EXT3_ROOT_INO)
  585. return ERR_PTR(-ESTALE);
  586. if (ino > le32_to_cpu(EXT3_SB(sb)->s_es->s_inodes_count))
  587. return ERR_PTR(-ESTALE);
  588. /* iget isn't really right if the inode is currently unallocated!!
  589. *
  590. * ext3_read_inode will return a bad_inode if the inode had been
  591. * deleted, so we should be safe.
  592. *
  593. * Currently we don't know the generation for parent directory, so
  594. * a generation of 0 means "accept any"
  595. */
  596. inode = ext3_iget(sb, ino);
  597. if (IS_ERR(inode))
  598. return ERR_CAST(inode);
  599. if (generation && inode->i_generation != generation) {
  600. iput(inode);
  601. return ERR_PTR(-ESTALE);
  602. }
  603. return inode;
  604. }
  605. static struct dentry *ext3_fh_to_dentry(struct super_block *sb, struct fid *fid,
  606. int fh_len, int fh_type)
  607. {
  608. return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
  609. ext3_nfs_get_inode);
  610. }
  611. static struct dentry *ext3_fh_to_parent(struct super_block *sb, struct fid *fid,
  612. int fh_len, int fh_type)
  613. {
  614. return generic_fh_to_parent(sb, fid, fh_len, fh_type,
  615. ext3_nfs_get_inode);
  616. }
  617. /*
  618. * Try to release metadata pages (indirect blocks, directories) which are
  619. * mapped via the block device. Since these pages could have journal heads
  620. * which would prevent try_to_free_buffers() from freeing them, we must use
  621. * jbd layer's try_to_free_buffers() function to release them.
  622. */
  623. static int bdev_try_to_free_page(struct super_block *sb, struct page *page,
  624. gfp_t wait)
  625. {
  626. journal_t *journal = EXT3_SB(sb)->s_journal;
  627. WARN_ON(PageChecked(page));
  628. if (!page_has_buffers(page))
  629. return 0;
  630. if (journal)
  631. return journal_try_to_free_buffers(journal, page,
  632. wait & ~__GFP_WAIT);
  633. return try_to_free_buffers(page);
  634. }
  635. #ifdef CONFIG_QUOTA
  636. #define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")
  637. #define QTYPE2MOPT(on, t) ((t)==USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA))
  638. static int ext3_write_dquot(struct dquot *dquot);
  639. static int ext3_acquire_dquot(struct dquot *dquot);
  640. static int ext3_release_dquot(struct dquot *dquot);
  641. static int ext3_mark_dquot_dirty(struct dquot *dquot);
  642. static int ext3_write_info(struct super_block *sb, int type);
  643. static int ext3_quota_on(struct super_block *sb, int type, int format_id,
  644. char *path, int remount);
  645. static int ext3_quota_on_mount(struct super_block *sb, int type);
  646. static ssize_t ext3_quota_read(struct super_block *sb, int type, char *data,
  647. size_t len, loff_t off);
  648. static ssize_t ext3_quota_write(struct super_block *sb, int type,
  649. const char *data, size_t len, loff_t off);
  650. static const struct dquot_operations ext3_quota_operations = {
  651. .write_dquot = ext3_write_dquot,
  652. .acquire_dquot = ext3_acquire_dquot,
  653. .release_dquot = ext3_release_dquot,
  654. .mark_dirty = ext3_mark_dquot_dirty,
  655. .write_info = ext3_write_info,
  656. .alloc_dquot = dquot_alloc,
  657. .destroy_dquot = dquot_destroy,
  658. };
  659. static const struct quotactl_ops ext3_qctl_operations = {
  660. .quota_on = ext3_quota_on,
  661. .quota_off = vfs_quota_off,
  662. .quota_sync = vfs_quota_sync,
  663. .get_info = vfs_get_dqinfo,
  664. .set_info = vfs_set_dqinfo,
  665. .get_dqblk = vfs_get_dqblk,
  666. .set_dqblk = vfs_set_dqblk
  667. };
  668. #endif
  669. static const struct super_operations ext3_sops = {
  670. .alloc_inode = ext3_alloc_inode,
  671. .destroy_inode = ext3_destroy_inode,
  672. .write_inode = ext3_write_inode,
  673. .dirty_inode = ext3_dirty_inode,
  674. .delete_inode = ext3_delete_inode,
  675. .put_super = ext3_put_super,
  676. .sync_fs = ext3_sync_fs,
  677. .freeze_fs = ext3_freeze,
  678. .unfreeze_fs = ext3_unfreeze,
  679. .statfs = ext3_statfs,
  680. .remount_fs = ext3_remount,
  681. .clear_inode = ext3_clear_inode,
  682. .show_options = ext3_show_options,
  683. #ifdef CONFIG_QUOTA
  684. .quota_read = ext3_quota_read,
  685. .quota_write = ext3_quota_write,
  686. #endif
  687. .bdev_try_to_free_page = bdev_try_to_free_page,
  688. };
  689. static const struct export_operations ext3_export_ops = {
  690. .fh_to_dentry = ext3_fh_to_dentry,
  691. .fh_to_parent = ext3_fh_to_parent,
  692. .get_parent = ext3_get_parent,
  693. };
  694. enum {
  695. Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
  696. Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic, Opt_err_ro,
  697. Opt_nouid32, Opt_nocheck, Opt_debug, Opt_oldalloc, Opt_orlov,
  698. Opt_user_xattr, Opt_nouser_xattr, Opt_acl, Opt_noacl,
  699. Opt_reservation, Opt_noreservation, Opt_noload, Opt_nobh, Opt_bh,
  700. Opt_commit, Opt_journal_update, Opt_journal_inum, Opt_journal_dev,
  701. Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
  702. Opt_data_err_abort, Opt_data_err_ignore,
  703. Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
  704. Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_jqfmt_vfsv1, Opt_quota,
  705. Opt_noquota, Opt_ignore, Opt_barrier, Opt_nobarrier, Opt_err,
  706. Opt_resize, Opt_usrquota, Opt_grpquota
  707. };
  708. static const match_table_t tokens = {
  709. {Opt_bsd_df, "bsddf"},
  710. {Opt_minix_df, "minixdf"},
  711. {Opt_grpid, "grpid"},
  712. {Opt_grpid, "bsdgroups"},
  713. {Opt_nogrpid, "nogrpid"},
  714. {Opt_nogrpid, "sysvgroups"},
  715. {Opt_resgid, "resgid=%u"},
  716. {Opt_resuid, "resuid=%u"},
  717. {Opt_sb, "sb=%u"},
  718. {Opt_err_cont, "errors=continue"},
  719. {Opt_err_panic, "errors=panic"},
  720. {Opt_err_ro, "errors=remount-ro"},
  721. {Opt_nouid32, "nouid32"},
  722. {Opt_nocheck, "nocheck"},
  723. {Opt_nocheck, "check=none"},
  724. {Opt_debug, "debug"},
  725. {Opt_oldalloc, "oldalloc"},
  726. {Opt_orlov, "orlov"},
  727. {Opt_user_xattr, "user_xattr"},
  728. {Opt_nouser_xattr, "nouser_xattr"},
  729. {Opt_acl, "acl"},
  730. {Opt_noacl, "noacl"},
  731. {Opt_reservation, "reservation"},
  732. {Opt_noreservation, "noreservation"},
  733. {Opt_noload, "noload"},
  734. {Opt_noload, "norecovery"},
  735. {Opt_nobh, "nobh"},
  736. {Opt_bh, "bh"},
  737. {Opt_commit, "commit=%u"},
  738. {Opt_journal_update, "journal=update"},
  739. {Opt_journal_inum, "journal=%u"},
  740. {Opt_journal_dev, "journal_dev=%u"},
  741. {Opt_abort, "abort"},
  742. {Opt_data_journal, "data=journal"},
  743. {Opt_data_ordered, "data=ordered"},
  744. {Opt_data_writeback, "data=writeback"},
  745. {Opt_data_err_abort, "data_err=abort"},
  746. {Opt_data_err_ignore, "data_err=ignore"},
  747. {Opt_offusrjquota, "usrjquota="},
  748. {Opt_usrjquota, "usrjquota=%s"},
  749. {Opt_offgrpjquota, "grpjquota="},
  750. {Opt_grpjquota, "grpjquota=%s"},
  751. {Opt_jqfmt_vfsold, "jqfmt=vfsold"},
  752. {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
  753. {Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
  754. {Opt_grpquota, "grpquota"},
  755. {Opt_noquota, "noquota"},
  756. {Opt_quota, "quota"},
  757. {Opt_usrquota, "usrquota"},
  758. {Opt_barrier, "barrier=%u"},
  759. {Opt_barrier, "barrier"},
  760. {Opt_nobarrier, "nobarrier"},
  761. {Opt_resize, "resize"},
  762. {Opt_err, NULL},
  763. };
  764. static ext3_fsblk_t get_sb_block(void **data, struct super_block *sb)
  765. {
  766. ext3_fsblk_t sb_block;
  767. char *options = (char *) *data;
  768. if (!options || strncmp(options, "sb=", 3) != 0)
  769. return 1; /* Default location */
  770. options += 3;
  771. /*todo: use simple_strtoll with >32bit ext3 */
  772. sb_block = simple_strtoul(options, &options, 0);
  773. if (*options && *options != ',') {
  774. ext3_msg(sb, "error: invalid sb specification: %s",
  775. (char *) *data);
  776. return 1;
  777. }
  778. if (*options == ',')
  779. options++;
  780. *data = (void *) options;
  781. return sb_block;
  782. }
  783. #ifdef CONFIG_QUOTA
  784. static int set_qf_name(struct super_block *sb, int qtype, substring_t *args)
  785. {
  786. struct ext3_sb_info *sbi = EXT3_SB(sb);
  787. char *qname;
  788. if (sb_any_quota_loaded(sb) &&
  789. !sbi->s_qf_names[qtype]) {
  790. ext3_msg(sb, KERN_ERR,
  791. "Cannot change journaled "
  792. "quota options when quota turned on");
  793. return 0;
  794. }
  795. qname = match_strdup(args);
  796. if (!qname) {
  797. ext3_msg(sb, KERN_ERR,
  798. "Not enough memory for storing quotafile name");
  799. return 0;
  800. }
  801. if (sbi->s_qf_names[qtype] &&
  802. strcmp(sbi->s_qf_names[qtype], qname)) {
  803. ext3_msg(sb, KERN_ERR,
  804. "%s quota file already specified", QTYPE2NAME(qtype));
  805. kfree(qname);
  806. return 0;
  807. }
  808. sbi->s_qf_names[qtype] = qname;
  809. if (strchr(sbi->s_qf_names[qtype], '/')) {
  810. ext3_msg(sb, KERN_ERR,
  811. "quotafile must be on filesystem root");
  812. kfree(sbi->s_qf_names[qtype]);
  813. sbi->s_qf_names[qtype] = NULL;
  814. return 0;
  815. }
  816. set_opt(sbi->s_mount_opt, QUOTA);
  817. return 1;
  818. }
  819. static int clear_qf_name(struct super_block *sb, int qtype) {
  820. struct ext3_sb_info *sbi = EXT3_SB(sb);
  821. if (sb_any_quota_loaded(sb) &&
  822. sbi->s_qf_names[qtype]) {
  823. ext3_msg(sb, KERN_ERR, "Cannot change journaled quota options"
  824. " when quota turned on");
  825. return 0;
  826. }
  827. /*
  828. * The space will be released later when all options are confirmed
  829. * to be correct
  830. */
  831. sbi->s_qf_names[qtype] = NULL;
  832. return 1;
  833. }
  834. #endif
  835. static int parse_options (char *options, struct super_block *sb,
  836. unsigned int *inum, unsigned long *journal_devnum,
  837. ext3_fsblk_t *n_blocks_count, int is_remount)
  838. {
  839. struct ext3_sb_info *sbi = EXT3_SB(sb);
  840. char * p;
  841. substring_t args[MAX_OPT_ARGS];
  842. int data_opt = 0;
  843. int option;
  844. #ifdef CONFIG_QUOTA
  845. int qfmt;
  846. #endif
  847. if (!options)
  848. return 1;
  849. while ((p = strsep (&options, ",")) != NULL) {
  850. int token;
  851. if (!*p)
  852. continue;
  853. /*
  854. * Initialize args struct so we know whether arg was
  855. * found; some options take optional arguments.
  856. */
  857. args[0].to = args[0].from = 0;
  858. token = match_token(p, tokens, args);
  859. switch (token) {
  860. case Opt_bsd_df:
  861. clear_opt (sbi->s_mount_opt, MINIX_DF);
  862. break;
  863. case Opt_minix_df:
  864. set_opt (sbi->s_mount_opt, MINIX_DF);
  865. break;
  866. case Opt_grpid:
  867. set_opt (sbi->s_mount_opt, GRPID);
  868. break;
  869. case Opt_nogrpid:
  870. clear_opt (sbi->s_mount_opt, GRPID);
  871. break;
  872. case Opt_resuid:
  873. if (match_int(&args[0], &option))
  874. return 0;
  875. sbi->s_resuid = option;
  876. break;
  877. case Opt_resgid:
  878. if (match_int(&args[0], &option))
  879. return 0;
  880. sbi->s_resgid = option;
  881. break;
  882. case Opt_sb:
  883. /* handled by get_sb_block() instead of here */
  884. /* *sb_block = match_int(&args[0]); */
  885. break;
  886. case Opt_err_panic:
  887. clear_opt (sbi->s_mount_opt, ERRORS_CONT);
  888. clear_opt (sbi->s_mount_opt, ERRORS_RO);
  889. set_opt (sbi->s_mount_opt, ERRORS_PANIC);
  890. break;
  891. case Opt_err_ro:
  892. clear_opt (sbi->s_mount_opt, ERRORS_CONT);
  893. clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
  894. set_opt (sbi->s_mount_opt, ERRORS_RO);
  895. break;
  896. case Opt_err_cont:
  897. clear_opt (sbi->s_mount_opt, ERRORS_RO);
  898. clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
  899. set_opt (sbi->s_mount_opt, ERRORS_CONT);
  900. break;
  901. case Opt_nouid32:
  902. set_opt (sbi->s_mount_opt, NO_UID32);
  903. break;
  904. case Opt_nocheck:
  905. clear_opt (sbi->s_mount_opt, CHECK);
  906. break;
  907. case Opt_debug:
  908. set_opt (sbi->s_mount_opt, DEBUG);
  909. break;
  910. case Opt_oldalloc:
  911. set_opt (sbi->s_mount_opt, OLDALLOC);
  912. break;
  913. case Opt_orlov:
  914. clear_opt (sbi->s_mount_opt, OLDALLOC);
  915. break;
  916. #ifdef CONFIG_EXT3_FS_XATTR
  917. case Opt_user_xattr:
  918. set_opt (sbi->s_mount_opt, XATTR_USER);
  919. break;
  920. case Opt_nouser_xattr:
  921. clear_opt (sbi->s_mount_opt, XATTR_USER);
  922. break;
  923. #else
  924. case Opt_user_xattr:
  925. case Opt_nouser_xattr:
  926. ext3_msg(sb, KERN_INFO,
  927. "(no)user_xattr options not supported");
  928. break;
  929. #endif
  930. #ifdef CONFIG_EXT3_FS_POSIX_ACL
  931. case Opt_acl:
  932. set_opt(sbi->s_mount_opt, POSIX_ACL);
  933. break;
  934. case Opt_noacl:
  935. clear_opt(sbi->s_mount_opt, POSIX_ACL);
  936. break;
  937. #else
  938. case Opt_acl:
  939. case Opt_noacl:
  940. ext3_msg(sb, KERN_INFO,
  941. "(no)acl options not supported");
  942. break;
  943. #endif
  944. case Opt_reservation:
  945. set_opt(sbi->s_mount_opt, RESERVATION);
  946. break;
  947. case Opt_noreservation:
  948. clear_opt(sbi->s_mount_opt, RESERVATION);
  949. break;
  950. case Opt_journal_update:
  951. /* @@@ FIXME */
  952. /* Eventually we will want to be able to create
  953. a journal file here. For now, only allow the
  954. user to specify an existing inode to be the
  955. journal file. */
  956. if (is_remount) {
  957. ext3_msg(sb, KERN_ERR, "error: cannot specify "
  958. "journal on remount");
  959. return 0;
  960. }
  961. set_opt (sbi->s_mount_opt, UPDATE_JOURNAL);
  962. break;
  963. case Opt_journal_inum:
  964. if (is_remount) {
  965. ext3_msg(sb, KERN_ERR, "error: cannot specify "
  966. "journal on remount");
  967. return 0;
  968. }
  969. if (match_int(&args[0], &option))
  970. return 0;
  971. *inum = option;
  972. break;
  973. case Opt_journal_dev:
  974. if (is_remount) {
  975. ext3_msg(sb, KERN_ERR, "error: cannot specify "
  976. "journal on remount");
  977. return 0;
  978. }
  979. if (match_int(&args[0], &option))
  980. return 0;
  981. *journal_devnum = option;
  982. break;
  983. case Opt_noload:
  984. set_opt (sbi->s_mount_opt, NOLOAD);
  985. break;
  986. case Opt_commit:
  987. if (match_int(&args[0], &option))
  988. return 0;
  989. if (option < 0)
  990. return 0;
  991. if (option == 0)
  992. option = JBD_DEFAULT_MAX_COMMIT_AGE;
  993. sbi->s_commit_interval = HZ * option;
  994. break;
  995. case Opt_data_journal:
  996. data_opt = EXT3_MOUNT_JOURNAL_DATA;
  997. goto datacheck;
  998. case Opt_data_ordered:
  999. data_opt = EXT3_MOUNT_ORDERED_DATA;
  1000. goto datacheck;
  1001. case Opt_data_writeback:
  1002. data_opt = EXT3_MOUNT_WRITEBACK_DATA;
  1003. datacheck:
  1004. if (is_remount) {
  1005. if (test_opt(sb, DATA_FLAGS) == data_opt)
  1006. break;
  1007. ext3_msg(sb, KERN_ERR,
  1008. "error: cannot change "
  1009. "data mode on remount. The filesystem "
  1010. "is mounted in data=%s mode and you "
  1011. "try to remount it in data=%s mode.",
  1012. data_mode_string(test_opt(sb,
  1013. DATA_FLAGS)),
  1014. data_mode_string(data_opt));
  1015. return 0;
  1016. } else {
  1017. clear_opt(sbi->s_mount_opt, DATA_FLAGS);
  1018. sbi->s_mount_opt |= data_opt;
  1019. }
  1020. break;
  1021. case Opt_data_err_abort:
  1022. set_opt(sbi->s_mount_opt, DATA_ERR_ABORT);
  1023. break;
  1024. case Opt_data_err_ignore:
  1025. clear_opt(sbi->s_mount_opt, DATA_ERR_ABORT);
  1026. break;
  1027. #ifdef CONFIG_QUOTA
  1028. case Opt_usrjquota:
  1029. if (!set_qf_name(sb, USRQUOTA, &args[0]))
  1030. return 0;
  1031. break;
  1032. case Opt_grpjquota:
  1033. if (!set_qf_name(sb, GRPQUOTA, &args[0]))
  1034. return 0;
  1035. break;
  1036. case Opt_offusrjquota:
  1037. if (!clear_qf_name(sb, USRQUOTA))
  1038. return 0;
  1039. break;
  1040. case Opt_offgrpjquota:
  1041. if (!clear_qf_name(sb, GRPQUOTA))
  1042. return 0;
  1043. break;
  1044. case Opt_jqfmt_vfsold:
  1045. qfmt = QFMT_VFS_OLD;
  1046. goto set_qf_format;
  1047. case Opt_jqfmt_vfsv0:
  1048. qfmt = QFMT_VFS_V0;
  1049. goto set_qf_format;
  1050. case Opt_jqfmt_vfsv1:
  1051. qfmt = QFMT_VFS_V1;
  1052. set_qf_format:
  1053. if (sb_any_quota_loaded(sb) &&
  1054. sbi->s_jquota_fmt != qfmt) {
  1055. ext3_msg(sb, KERN_ERR, "error: cannot change "
  1056. "journaled quota options when "
  1057. "quota turned on.");
  1058. return 0;
  1059. }
  1060. sbi->s_jquota_fmt = qfmt;
  1061. break;
  1062. case Opt_quota:
  1063. case Opt_usrquota:
  1064. set_opt(sbi->s_mount_opt, QUOTA);
  1065. set_opt(sbi->s_mount_opt, USRQUOTA);
  1066. break;
  1067. case Opt_grpquota:
  1068. set_opt(sbi->s_mount_opt, QUOTA);
  1069. set_opt(sbi->s_mount_opt, GRPQUOTA);
  1070. break;
  1071. case Opt_noquota:
  1072. if (sb_any_quota_loaded(sb)) {
  1073. ext3_msg(sb, KERN_ERR, "error: cannot change "
  1074. "quota options when quota turned on.");
  1075. return 0;
  1076. }
  1077. clear_opt(sbi->s_mount_opt, QUOTA);
  1078. clear_opt(sbi->s_mount_opt, USRQUOTA);
  1079. clear_opt(sbi->s_mount_opt, GRPQUOTA);
  1080. break;
  1081. #else
  1082. case Opt_quota:
  1083. case Opt_usrquota:
  1084. case Opt_grpquota:
  1085. ext3_msg(sb, KERN_ERR,
  1086. "error: quota options not supported.");
  1087. break;
  1088. case Opt_usrjquota:
  1089. case Opt_grpjquota:
  1090. case Opt_offusrjquota:
  1091. case Opt_offgrpjquota:
  1092. case Opt_jqfmt_vfsold:
  1093. case Opt_jqfmt_vfsv0:
  1094. case Opt_jqfmt_vfsv1:
  1095. ext3_msg(sb, KERN_ERR,
  1096. "error: journaled quota options not "
  1097. "supported.");
  1098. break;
  1099. case Opt_noquota:
  1100. break;
  1101. #endif
  1102. case Opt_abort:
  1103. set_opt(sbi->s_mount_opt, ABORT);
  1104. break;
  1105. case Opt_nobarrier:
  1106. clear_opt(sbi->s_mount_opt, BARRIER);
  1107. break;
  1108. case Opt_barrier:
  1109. if (args[0].from) {
  1110. if (match_int(&args[0], &option))
  1111. return 0;
  1112. } else
  1113. option = 1; /* No argument, default to 1 */
  1114. if (option)
  1115. set_opt(sbi->s_mount_opt, BARRIER);
  1116. else
  1117. clear_opt(sbi->s_mount_opt, BARRIER);
  1118. break;
  1119. case Opt_ignore:
  1120. break;
  1121. case Opt_resize:
  1122. if (!is_remount) {
  1123. ext3_msg(sb, KERN_ERR,
  1124. "error: resize option only available "
  1125. "for remount");
  1126. return 0;
  1127. }
  1128. if (match_int(&args[0], &option) != 0)
  1129. return 0;
  1130. *n_blocks_count = option;
  1131. break;
  1132. case Opt_nobh:
  1133. set_opt(sbi->s_mount_opt, NOBH);
  1134. break;
  1135. case Opt_bh:
  1136. clear_opt(sbi->s_mount_opt, NOBH);
  1137. break;
  1138. default:
  1139. ext3_msg(sb, KERN_ERR,
  1140. "error: unrecognized mount option \"%s\" "
  1141. "or missing value", p);
  1142. return 0;
  1143. }
  1144. }
  1145. #ifdef CONFIG_QUOTA
  1146. if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) {
  1147. if (test_opt(sb, USRQUOTA) && sbi->s_qf_names[USRQUOTA])
  1148. clear_opt(sbi->s_mount_opt, USRQUOTA);
  1149. if (test_opt(sb, GRPQUOTA) && sbi->s_qf_names[GRPQUOTA])
  1150. clear_opt(sbi->s_mount_opt, GRPQUOTA);
  1151. if (test_opt(sb, GRPQUOTA) || test_opt(sb, USRQUOTA)) {
  1152. ext3_msg(sb, KERN_ERR, "error: old and new quota "
  1153. "format mixing.");
  1154. return 0;
  1155. }
  1156. if (!sbi->s_jquota_fmt) {
  1157. ext3_msg(sb, KERN_ERR, "error: journaled quota format "
  1158. "not specified.");
  1159. return 0;
  1160. }
  1161. } else {
  1162. if (sbi->s_jquota_fmt) {
  1163. ext3_msg(sb, KERN_ERR, "error: journaled quota format "
  1164. "specified with no journaling "
  1165. "enabled.");
  1166. return 0;
  1167. }
  1168. }
  1169. #endif
  1170. return 1;
  1171. }
  1172. static int ext3_setup_super(struct super_block *sb, struct ext3_super_block *es,
  1173. int read_only)
  1174. {
  1175. struct ext3_sb_info *sbi = EXT3_SB(sb);
  1176. int res = 0;
  1177. if (le32_to_cpu(es->s_rev_level) > EXT3_MAX_SUPP_REV) {
  1178. ext3_msg(sb, KERN_ERR,
  1179. "error: revision level too high, "
  1180. "forcing read-only mode");
  1181. res = MS_RDONLY;
  1182. }
  1183. if (read_only)
  1184. return res;
  1185. if (!(sbi->s_mount_state & EXT3_VALID_FS))
  1186. ext3_msg(sb, KERN_WARNING,
  1187. "warning: mounting unchecked fs, "
  1188. "running e2fsck is recommended");
  1189. else if ((sbi->s_mount_state & EXT3_ERROR_FS))
  1190. ext3_msg(sb, KERN_WARNING,
  1191. "warning: mounting fs with errors, "
  1192. "running e2fsck is recommended");
  1193. else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
  1194. le16_to_cpu(es->s_mnt_count) >=
  1195. (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
  1196. ext3_msg(sb, KERN_WARNING,
  1197. "warning: maximal mount count reached, "
  1198. "running e2fsck is recommended");
  1199. else if (le32_to_cpu(es->s_checkinterval) &&
  1200. (le32_to_cpu(es->s_lastcheck) +
  1201. le32_to_cpu(es->s_checkinterval) <= get_seconds()))
  1202. ext3_msg(sb, KERN_WARNING,
  1203. "warning: checktime reached, "
  1204. "running e2fsck is recommended");
  1205. #if 0
  1206. /* @@@ We _will_ want to clear the valid bit if we find
  1207. inconsistencies, to force a fsck at reboot. But for
  1208. a plain journaled filesystem we can keep it set as
  1209. valid forever! :) */
  1210. es->s_state &= cpu_to_le16(~EXT3_VALID_FS);
  1211. #endif
  1212. if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
  1213. es->s_max_mnt_count = cpu_to_le16(EXT3_DFL_MAX_MNT_COUNT);
  1214. le16_add_cpu(&es->s_mnt_count, 1);
  1215. es->s_mtime = cpu_to_le32(get_seconds());
  1216. ext3_update_dynamic_rev(sb);
  1217. EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
  1218. ext3_commit_super(sb, es, 1);
  1219. if (test_opt(sb, DEBUG))
  1220. ext3_msg(sb, KERN_INFO, "[bs=%lu, gc=%lu, "
  1221. "bpg=%lu, ipg=%lu, mo=%04lx]",
  1222. sb->s_blocksize,
  1223. sbi->s_groups_count,
  1224. EXT3_BLOCKS_PER_GROUP(sb),
  1225. EXT3_INODES_PER_GROUP(sb),
  1226. sbi->s_mount_opt);
  1227. if (EXT3_SB(sb)->s_journal->j_inode == NULL) {
  1228. char b[BDEVNAME_SIZE];
  1229. ext3_msg(sb, KERN_INFO, "using external journal on %s",
  1230. bdevname(EXT3_SB(sb)->s_journal->j_dev, b));
  1231. } else {
  1232. ext3_msg(sb, KERN_INFO, "using internal journal");
  1233. }
  1234. return res;
  1235. }
  1236. /* Called at mount-time, super-block is locked */
  1237. static int ext3_check_descriptors(struct super_block *sb)
  1238. {
  1239. struct ext3_sb_info *sbi = EXT3_SB(sb);
  1240. int i;
  1241. ext3_debug ("Checking group descriptors");
  1242. for (i = 0; i < sbi->s_groups_count; i++) {
  1243. struct ext3_group_desc *gdp = ext3_get_group_desc(sb, i, NULL);
  1244. ext3_fsblk_t first_block = ext3_group_first_block_no(sb, i);
  1245. ext3_fsblk_t last_block;
  1246. if (i == sbi->s_groups_count - 1)
  1247. last_block = le32_to_cpu(sbi->s_es->s_blocks_count) - 1;
  1248. else
  1249. last_block = first_block +
  1250. (EXT3_BLOCKS_PER_GROUP(sb) - 1);
  1251. if (le32_to_cpu(gdp->bg_block_bitmap) < first_block ||
  1252. le32_to_cpu(gdp->bg_block_bitmap) > last_block)
  1253. {
  1254. ext3_error (sb, "ext3_check_descriptors",
  1255. "Block bitmap for group %d"
  1256. " not in group (block %lu)!",
  1257. i, (unsigned long)
  1258. le32_to_cpu(gdp->bg_block_bitmap));
  1259. return 0;
  1260. }
  1261. if (le32_to_cpu(gdp->bg_inode_bitmap) < first_block ||
  1262. le32_to_cpu(gdp->bg_inode_bitmap) > last_block)
  1263. {
  1264. ext3_error (sb, "ext3_check_descriptors",
  1265. "Inode bitmap for group %d"
  1266. " not in group (block %lu)!",
  1267. i, (unsigned long)
  1268. le32_to_cpu(gdp->bg_inode_bitmap));
  1269. return 0;
  1270. }
  1271. if (le32_to_cpu(gdp->bg_inode_table) < first_block ||
  1272. le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group - 1 >
  1273. last_block)
  1274. {
  1275. ext3_error (sb, "ext3_check_descriptors",
  1276. "Inode table for group %d"
  1277. " not in group (block %lu)!",
  1278. i, (unsigned long)
  1279. le32_to_cpu(gdp->bg_inode_table));
  1280. return 0;
  1281. }
  1282. }
  1283. sbi->s_es->s_free_blocks_count=cpu_to_le32(ext3_count_free_blocks(sb));
  1284. sbi->s_es->s_free_inodes_count=cpu_to_le32(ext3_count_free_inodes(sb));
  1285. return 1;
  1286. }
  1287. /* ext3_orphan_cleanup() walks a singly-linked list of inodes (starting at
  1288. * the superblock) which were deleted from all directories, but held open by
  1289. * a process at the time of a crash. We walk the list and try to delete these
  1290. * inodes at recovery time (only with a read-write filesystem).
  1291. *
  1292. * In order to keep the orphan inode chain consistent during traversal (in
  1293. * case of crash during recovery), we link each inode into the superblock
  1294. * orphan list_head and handle it the same way as an inode deletion during
  1295. * normal operation (which journals the operations for us).
  1296. *
  1297. * We only do an iget() and an iput() on each inode, which is very safe if we
  1298. * accidentally point at an in-use or already deleted inode. The worst that
  1299. * can happen in this case is that we get a "bit already cleared" message from
  1300. * ext3_free_inode(). The only reason we would point at a wrong inode is if
  1301. * e2fsck was run on this filesystem, and it must have already done the orphan
  1302. * inode cleanup for us, so we can safely abort without any further action.
  1303. */
  1304. static void ext3_orphan_cleanup (struct super_block * sb,
  1305. struct ext3_super_block * es)
  1306. {
  1307. unsigned int s_flags = sb->s_flags;
  1308. int nr_orphans = 0, nr_truncates = 0;
  1309. #ifdef CONFIG_QUOTA
  1310. int i;
  1311. #endif
  1312. if (!es->s_last_orphan) {
  1313. jbd_debug(4, "no orphan inodes to clean up\n");
  1314. return;
  1315. }
  1316. if (bdev_read_only(sb->s_bdev)) {
  1317. ext3_msg(sb, KERN_ERR, "error: write access "
  1318. "unavailable, skipping orphan cleanup.");
  1319. return;
  1320. }
  1321. if (EXT3_SB(sb)->s_mount_state & EXT3_ERROR_FS) {
  1322. if (es->s_last_orphan)
  1323. jbd_debug(1, "Errors on filesystem, "
  1324. "clearing orphan list.\n");
  1325. es->s_last_orphan = 0;
  1326. jbd_debug(1, "Skipping orphan recovery on fs with errors.\n");
  1327. return;
  1328. }
  1329. if (s_flags & MS_RDONLY) {
  1330. ext3_msg(sb, KERN_INFO, "orphan cleanup on readonly fs");
  1331. sb->s_flags &= ~MS_RDONLY;
  1332. }
  1333. #ifdef CONFIG_QUOTA
  1334. /* Needed for iput() to work correctly and not trash data */
  1335. sb->s_flags |= MS_ACTIVE;
  1336. /* Turn on quotas so that they are updated correctly */
  1337. for (i = 0; i < MAXQUOTAS; i++) {
  1338. if (EXT3_SB(sb)->s_qf_names[i]) {
  1339. int ret = ext3_quota_on_mount(sb, i);
  1340. if (ret < 0)
  1341. ext3_msg(sb, KERN_ERR,
  1342. "error: cannot turn on journaled "
  1343. "quota: %d", ret);
  1344. }
  1345. }
  1346. #endif
  1347. while (es->s_last_orphan) {
  1348. struct inode *inode;
  1349. inode = ext3_orphan_get(sb, le32_to_cpu(es->s_last_orphan));
  1350. if (IS_ERR(inode)) {
  1351. es->s_last_orphan = 0;
  1352. break;
  1353. }
  1354. list_add(&EXT3_I(inode)->i_orphan, &EXT3_SB(sb)->s_orphan);
  1355. dquot_initialize(inode);
  1356. if (inode->i_nlink) {
  1357. printk(KERN_DEBUG
  1358. "%s: truncating inode %lu to %Ld bytes\n",
  1359. __func__, inode->i_ino, inode->i_size);
  1360. jbd_debug(2, "truncating inode %lu to %Ld bytes\n",
  1361. inode->i_ino, inode->i_size);
  1362. ext3_truncate(inode);
  1363. nr_truncates++;
  1364. } else {
  1365. printk(KERN_DEBUG
  1366. "%s: deleting unreferenced inode %lu\n",
  1367. __func__, inode->i_ino);
  1368. jbd_debug(2, "deleting unreferenced inode %lu\n",
  1369. inode->i_ino);
  1370. nr_orphans++;
  1371. }
  1372. iput(inode); /* The delete magic happens here! */
  1373. }
  1374. #define PLURAL(x) (x), ((x)==1) ? "" : "s"
  1375. if (nr_orphans)
  1376. ext3_msg(sb, KERN_INFO, "%d orphan inode%s deleted",
  1377. PLURAL(nr_orphans));
  1378. if (nr_truncates)
  1379. ext3_msg(sb, KERN_INFO, "%d truncate%s cleaned up",
  1380. PLURAL(nr_truncates));
  1381. #ifdef CONFIG_QUOTA
  1382. /* Turn quotas off */
  1383. for (i = 0; i < MAXQUOTAS; i++) {
  1384. if (sb_dqopt(sb)->files[i])
  1385. vfs_quota_off(sb, i, 0);
  1386. }
  1387. #endif
  1388. sb->s_flags = s_flags; /* Restore MS_RDONLY status */
  1389. }
  1390. /*
  1391. * Maximal file size. There is a direct, and {,double-,triple-}indirect
  1392. * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks.
  1393. * We need to be 1 filesystem block less than the 2^32 sector limit.
  1394. */
  1395. static loff_t ext3_max_size(int bits)
  1396. {
  1397. loff_t res = EXT3_NDIR_BLOCKS;
  1398. int meta_blocks;
  1399. loff_t upper_limit;
  1400. /* This is calculated to be the largest file size for a
  1401. * dense, file such that the total number of
  1402. * sectors in the file, including data and all indirect blocks,
  1403. * does not exceed 2^32 -1
  1404. * __u32 i_blocks representing the total number of
  1405. * 512 bytes blocks of the file
  1406. */
  1407. upper_limit = (1LL << 32) - 1;
  1408. /* total blocks in file system block size */
  1409. upper_limit >>= (bits - 9);
  1410. /* indirect blocks */
  1411. meta_blocks = 1;
  1412. /* double indirect blocks */
  1413. meta_blocks += 1 + (1LL << (bits-2));
  1414. /* tripple indirect blocks */
  1415. meta_blocks += 1 + (1LL << (bits-2)) + (1LL << (2*(bits-2)));
  1416. upper_limit -= meta_blocks;
  1417. upper_limit <<= bits;
  1418. res += 1LL << (bits-2);
  1419. res += 1LL << (2*(bits-2));
  1420. res += 1LL << (3*(bits-2));
  1421. res <<= bits;
  1422. if (res > upper_limit)
  1423. res = upper_limit;
  1424. if (res > MAX_LFS_FILESIZE)
  1425. res = MAX_LFS_FILESIZE;
  1426. return res;
  1427. }
  1428. static ext3_fsblk_t descriptor_loc(struct super_block *sb,
  1429. ext3_fsblk_t logic_sb_block,
  1430. int nr)
  1431. {
  1432. struct ext3_sb_info *sbi = EXT3_SB(sb);
  1433. unsigned long bg, first_meta_bg;
  1434. int has_super = 0;
  1435. first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
  1436. if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_META_BG) ||
  1437. nr < first_meta_bg)
  1438. return (logic_sb_block + nr + 1);
  1439. bg = sbi->s_desc_per_block * nr;
  1440. if (ext3_bg_has_super(sb, bg))
  1441. has_super = 1;
  1442. return (has_super + ext3_group_first_block_no(sb, bg));
  1443. }
  1444. static int ext3_fill_super (struct super_block *sb, void *data, int silent)
  1445. {
  1446. struct buffer_head * bh;
  1447. struct ext3_super_block *es = NULL;
  1448. struct ext3_sb_info *sbi;
  1449. ext3_fsblk_t block;
  1450. ext3_fsblk_t sb_block = get_sb_block(&data, sb);
  1451. ext3_fsblk_t logic_sb_block;
  1452. unsigned long offset = 0;
  1453. unsigned int journal_inum = 0;
  1454. unsigned long journal_devnum = 0;
  1455. unsigned long def_mount_opts;
  1456. struct inode *root;
  1457. int blocksize;
  1458. int hblock;
  1459. int db_count;
  1460. int i;
  1461. int needs_recovery;
  1462. int ret = -EINVAL;
  1463. __le32 features;
  1464. int err;
  1465. sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
  1466. if (!sbi)
  1467. return -ENOMEM;
  1468. sbi->s_blockgroup_lock =
  1469. kzalloc(sizeof(struct blockgroup_lock), GFP_KERNEL);
  1470. if (!sbi->s_blockgroup_lock) {
  1471. kfree(sbi);
  1472. return -ENOMEM;
  1473. }
  1474. sb->s_fs_info = sbi;
  1475. sbi->s_mount_opt = 0;
  1476. sbi->s_resuid = EXT3_DEF_RESUID;
  1477. sbi->s_resgid = EXT3_DEF_RESGID;
  1478. sbi->s_sb_block = sb_block;
  1479. unlock_kernel();
  1480. blocksize = sb_min_blocksize(sb, EXT3_MIN_BLOCK_SIZE);
  1481. if (!blocksize) {
  1482. ext3_msg(sb, KERN_ERR, "error: unable to set blocksize");
  1483. goto out_fail;
  1484. }
  1485. /*
  1486. * The ext3 superblock will not be buffer aligned for other than 1kB
  1487. * block sizes. We need to calculate the offset from buffer start.
  1488. */
  1489. if (blocksize != EXT3_MIN_BLOCK_SIZE) {
  1490. logic_sb_block = (sb_block * EXT3_MIN_BLOCK_SIZE) / blocksize;
  1491. offset = (sb_block * EXT3_MIN_BLOCK_SIZE) % blocksize;
  1492. } else {
  1493. logic_sb_block = sb_block;
  1494. }
  1495. if (!(bh = sb_bread(sb, logic_sb_block))) {
  1496. ext3_msg(sb, KERN_ERR, "error: unable to read superblock");
  1497. goto out_fail;
  1498. }
  1499. /*
  1500. * Note: s_es must be initialized as soon as possible because
  1501. * some ext3 macro-instructions depend on its value
  1502. */
  1503. es = (struct ext3_super_block *) (((char *)bh->b_data) + offset);
  1504. sbi->s_es = es;
  1505. sb->s_magic = le16_to_cpu(es->s_magic);
  1506. if (sb->s_magic != EXT3_SUPER_MAGIC)
  1507. goto cantfind_ext3;
  1508. /* Set defaults before we parse the mount options */
  1509. def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
  1510. if (def_mount_opts & EXT3_DEFM_DEBUG)
  1511. set_opt(sbi->s_mount_opt, DEBUG);
  1512. if (def_mount_opts & EXT3_DEFM_BSDGROUPS)
  1513. set_opt(sbi->s_mount_opt, GRPID);
  1514. if (def_mount_opts & EXT3_DEFM_UID16)
  1515. set_opt(sbi->s_mount_opt, NO_UID32);
  1516. #ifdef CONFIG_EXT3_FS_XATTR
  1517. if (def_mount_opts & EXT3_DEFM_XATTR_USER)
  1518. set_opt(sbi->s_mount_opt, XATTR_USER);
  1519. #endif
  1520. #ifdef CONFIG_EXT3_FS_POSIX_ACL
  1521. if (def_mount_opts & EXT3_DEFM_ACL)
  1522. set_opt(sbi->s_mount_opt, POSIX_ACL);
  1523. #endif
  1524. if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_DATA)
  1525. set_opt(sbi->s_mount_opt, JOURNAL_DATA);
  1526. else if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_ORDERED)
  1527. set_opt(sbi->s_mount_opt, ORDERED_DATA);
  1528. else if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_WBACK)
  1529. set_opt(sbi->s_mount_opt, WRITEBACK_DATA);
  1530. if (le16_to_cpu(sbi->s_es->s_errors) == EXT3_ERRORS_PANIC)
  1531. set_opt(sbi->s_mount_opt, ERRORS_PANIC);
  1532. else if (le16_to_cpu(sbi->s_es->s_errors) == EXT3_ERRORS_CONTINUE)
  1533. set_opt(sbi->s_mount_opt, ERRORS_CONT);
  1534. else
  1535. set_opt(sbi->s_mount_opt, ERRORS_RO);
  1536. sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
  1537. sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
  1538. set_opt(sbi->s_mount_opt, RESERVATION);
  1539. if (!parse_options ((char *) data, sb, &journal_inum, &journal_devnum,
  1540. NULL, 0))
  1541. goto failed_mount;
  1542. sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
  1543. (test_opt(sb, POSIX_ACL) ? MS_POSIXACL : 0);
  1544. if (le32_to_cpu(es->s_rev_level) == EXT3_GOOD_OLD_REV &&
  1545. (EXT3_HAS_COMPAT_FEATURE(sb, ~0U) ||
  1546. EXT3_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
  1547. EXT3_HAS_INCOMPAT_FEATURE(sb, ~0U)))
  1548. ext3_msg(sb, KERN_WARNING,
  1549. "warning: feature flags set on rev 0 fs, "
  1550. "running e2fsck is recommended");
  1551. /*
  1552. * Check feature flags regardless of the revision level, since we
  1553. * previously didn't change the revision level when setting the flags,
  1554. * so there is a chance incompat flags are set on a rev 0 filesystem.
  1555. */
  1556. features = EXT3_HAS_INCOMPAT_FEATURE(sb, ~EXT3_FEATURE_INCOMPAT_SUPP);
  1557. if (features) {
  1558. ext3_msg(sb, KERN_ERR,
  1559. "error: couldn't mount because of unsupported "
  1560. "optional features (%x)", le32_to_cpu(features));
  1561. goto failed_mount;
  1562. }
  1563. features = EXT3_HAS_RO_COMPAT_FEATURE(sb, ~EXT3_FEATURE_RO_COMPAT_SUPP);
  1564. if (!(sb->s_flags & MS_RDONLY) && features) {
  1565. ext3_msg(sb, KERN_ERR,
  1566. "error: couldn't mount RDWR because of unsupported "
  1567. "optional features (%x)", le32_to_cpu(features));
  1568. goto failed_mount;
  1569. }
  1570. blocksize = BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
  1571. if (blocksize < EXT3_MIN_BLOCK_SIZE ||
  1572. blocksize > EXT3_MAX_BLOCK_SIZE) {
  1573. ext3_msg(sb, KERN_ERR,
  1574. "error: couldn't mount because of unsupported "
  1575. "filesystem blocksize %d", blocksize);
  1576. goto failed_mount;
  1577. }
  1578. hblock = bdev_logical_block_size(sb->s_bdev);
  1579. if (sb->s_blocksize != blocksize) {
  1580. /*
  1581. * Make sure the blocksize for the filesystem is larger
  1582. * than the hardware sectorsize for the machine.
  1583. */
  1584. if (blocksize < hblock) {
  1585. ext3_msg(sb, KERN_ERR,
  1586. "error: fsblocksize %d too small for "
  1587. "hardware sectorsize %d", blocksize, hblock);
  1588. goto failed_mount;
  1589. }
  1590. brelse (bh);
  1591. if (!sb_set_blocksize(sb, blocksize)) {
  1592. ext3_msg(sb, KERN_ERR,
  1593. "error: bad blocksize %d", blocksize);
  1594. goto out_fail;
  1595. }
  1596. logic_sb_block = (sb_block * EXT3_MIN_BLOCK_SIZE) / blocksize;
  1597. offset = (sb_block * EXT3_MIN_BLOCK_SIZE) % blocksize;
  1598. bh = sb_bread(sb, logic_sb_block);
  1599. if (!bh) {
  1600. ext3_msg(sb, KERN_ERR,
  1601. "error: can't read superblock on 2nd try");
  1602. goto failed_mount;
  1603. }
  1604. es = (struct ext3_super_block *)(((char *)bh->b_data) + offset);
  1605. sbi->s_es = es;
  1606. if (es->s_magic != cpu_to_le16(EXT3_SUPER_MAGIC)) {
  1607. ext3_msg(sb, KERN_ERR,
  1608. "error: magic mismatch");
  1609. goto failed_mount;
  1610. }
  1611. }
  1612. sb->s_maxbytes = ext3_max_size(sb->s_blocksize_bits);
  1613. if (le32_to_cpu(es->s_rev_level) == EXT3_GOOD_OLD_REV) {
  1614. sbi->s_inode_size = EXT3_GOOD_OLD_INODE_SIZE;
  1615. sbi->s_first_ino = EXT3_GOOD_OLD_FIRST_INO;
  1616. } else {
  1617. sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
  1618. sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
  1619. if ((sbi->s_inode_size < EXT3_GOOD_OLD_INODE_SIZE) ||
  1620. (!is_power_of_2(sbi->s_inode_size)) ||
  1621. (sbi->s_inode_size > blocksize)) {
  1622. ext3_msg(sb, KERN_ERR,
  1623. "error: unsupported inode size: %d",
  1624. sbi->s_inode_size);
  1625. goto failed_mount;
  1626. }
  1627. }
  1628. sbi->s_frag_size = EXT3_MIN_FRAG_SIZE <<
  1629. le32_to_cpu(es->s_log_frag_size);
  1630. if (blocksize != sbi->s_frag_size) {
  1631. ext3_msg(sb, KERN_ERR,
  1632. "error: fragsize %lu != blocksize %u (unsupported)",
  1633. sbi->s_frag_size, blocksize);
  1634. goto failed_mount;
  1635. }
  1636. sbi->s_frags_per_block = 1;
  1637. sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
  1638. sbi->s_frags_per_group = le32_to_cpu(es->s_frags_per_group);
  1639. sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
  1640. if (EXT3_INODE_SIZE(sb) == 0 || EXT3_INODES_PER_GROUP(sb) == 0)
  1641. goto cantfind_ext3;
  1642. sbi->s_inodes_per_block = blocksize / EXT3_INODE_SIZE(sb);
  1643. if (sbi->s_inodes_per_block == 0)
  1644. goto cantfind_ext3;
  1645. sbi->s_itb_per_group = sbi->s_inodes_per_group /
  1646. sbi->s_inodes_per_block;
  1647. sbi->s_desc_per_block = blocksize / sizeof(struct ext3_group_desc);
  1648. sbi->s_sbh = bh;
  1649. sbi->s_mount_state = le16_to_cpu(es->s_state);
  1650. sbi->s_addr_per_block_bits = ilog2(EXT3_ADDR_PER_BLOCK(sb));
  1651. sbi->s_desc_per_block_bits = ilog2(EXT3_DESC_PER_BLOCK(sb));
  1652. for (i=0; i < 4; i++)
  1653. sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
  1654. sbi->s_def_hash_version = es->s_def_hash_version;
  1655. i = le32_to_cpu(es->s_flags);
  1656. if (i & EXT2_FLAGS_UNSIGNED_HASH)
  1657. sbi->s_hash_unsigned = 3;
  1658. else if ((i & EXT2_FLAGS_SIGNED_HASH) == 0) {
  1659. #ifdef __CHAR_UNSIGNED__
  1660. es->s_flags |= cpu_to_le32(EXT2_FLAGS_UNSIGNED_HASH);
  1661. sbi->s_hash_unsigned = 3;
  1662. #else
  1663. es->s_flags |= cpu_to_le32(EXT2_FLAGS_SIGNED_HASH);
  1664. #endif
  1665. }
  1666. if (sbi->s_blocks_per_group > blocksize * 8) {
  1667. ext3_msg(sb, KERN_ERR,
  1668. "#blocks per group too big: %lu",
  1669. sbi->s_blocks_per_group);
  1670. goto failed_mount;
  1671. }
  1672. if (sbi->s_frags_per_group > blocksize * 8) {
  1673. ext3_msg(sb, KERN_ERR,
  1674. "error: #fragments per group too big: %lu",
  1675. sbi->s_frags_per_group);
  1676. goto failed_mount;
  1677. }
  1678. if (sbi->s_inodes_per_group > blocksize * 8) {
  1679. ext3_msg(sb, KERN_ERR,
  1680. "error: #inodes per group too big: %lu",
  1681. sbi->s_inodes_per_group);
  1682. goto failed_mount;
  1683. }
  1684. if (le32_to_cpu(es->s_blocks_count) >
  1685. (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) {
  1686. ext3_msg(sb, KERN_ERR,
  1687. "error: filesystem is too large to mount safely");
  1688. if (sizeof(sector_t) < 8)
  1689. ext3_msg(sb, KERN_ERR,
  1690. "error: CONFIG_LBDAF not enabled");
  1691. goto failed_mount;
  1692. }
  1693. if (EXT3_BLOCKS_PER_GROUP(sb) == 0)
  1694. goto cantfind_ext3;
  1695. sbi->s_groups_count = ((le32_to_cpu(es->s_blocks_count) -
  1696. le32_to_cpu(es->s_first_data_block) - 1)
  1697. / EXT3_BLOCKS_PER_GROUP(sb)) + 1;
  1698. db_count = (sbi->s_groups_count + EXT3_DESC_PER_BLOCK(sb) - 1) /
  1699. EXT3_DESC_PER_BLOCK(sb);
  1700. sbi->s_group_desc = kmalloc(db_count * sizeof (struct buffer_head *),
  1701. GFP_KERNEL);
  1702. if (sbi->s_group_desc == NULL) {
  1703. ext3_msg(sb, KERN_ERR,
  1704. "error: not enough memory");
  1705. goto failed_mount;
  1706. }
  1707. bgl_lock_init(sbi->s_blockgroup_lock);
  1708. for (i = 0; i < db_count; i++) {
  1709. block = descriptor_loc(sb, logic_sb_block, i);
  1710. sbi->s_group_desc[i] = sb_bread(sb, block);
  1711. if (!sbi->s_group_desc[i]) {
  1712. ext3_msg(sb, KERN_ERR,
  1713. "error: can't read group descriptor %d", i);
  1714. db_count = i;
  1715. goto failed_mount2;
  1716. }
  1717. }
  1718. if (!ext3_check_descriptors (sb)) {
  1719. ext3_msg(sb, KERN_ERR,
  1720. "error: group descriptors corrupted");
  1721. goto failed_mount2;
  1722. }
  1723. sbi->s_gdb_count = db_count;
  1724. get_random_bytes(&sbi->s_next_generation, sizeof(u32));
  1725. spin_lock_init(&sbi->s_next_gen_lock);
  1726. /* per fileystem reservation list head & lock */
  1727. spin_lock_init(&sbi->s_rsv_window_lock);
  1728. sbi->s_rsv_window_root = RB_ROOT;
  1729. /* Add a single, static dummy reservation to the start of the
  1730. * reservation window list --- it gives us a placeholder for
  1731. * append-at-start-of-list which makes the allocation logic
  1732. * _much_ simpler. */
  1733. sbi->s_rsv_window_head.rsv_start = EXT3_RESERVE_WINDOW_NOT_ALLOCATED;
  1734. sbi->s_rsv_window_head.rsv_end = EXT3_RESERVE_WINDOW_NOT_ALLOCATED;
  1735. sbi->s_rsv_window_head.rsv_alloc_hit = 0;
  1736. sbi->s_rsv_window_head.rsv_goal_size = 0;
  1737. ext3_rsv_window_add(sb, &sbi->s_rsv_window_head);
  1738. /*
  1739. * set up enough so that it can read an inode
  1740. */
  1741. sb->s_op = &ext3_sops;
  1742. sb->s_export_op = &ext3_export_ops;
  1743. sb->s_xattr = ext3_xattr_handlers;
  1744. #ifdef CONFIG_QUOTA
  1745. sb->s_qcop = &ext3_qctl_operations;
  1746. sb->dq_op = &ext3_quota_operations;
  1747. #endif
  1748. INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
  1749. mutex_init(&sbi->s_orphan_lock);
  1750. mutex_init(&sbi->s_resize_lock);
  1751. sb->s_root = NULL;
  1752. needs_recovery = (es->s_last_orphan != 0 ||
  1753. EXT3_HAS_INCOMPAT_FEATURE(sb,
  1754. EXT3_FEATURE_INCOMPAT_RECOVER));
  1755. /*
  1756. * The first inode we look at is the journal inode. Don't try
  1757. * root first: it may be modified in the journal!
  1758. */
  1759. if (!test_opt(sb, NOLOAD) &&
  1760. EXT3_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
  1761. if (ext3_load_journal(sb, es, journal_devnum))
  1762. goto failed_mount2;
  1763. } else if (journal_inum) {
  1764. if (ext3_create_journal(sb, es, journal_inum))
  1765. goto failed_mount2;
  1766. } else {
  1767. if (!silent)
  1768. ext3_msg(sb, KERN_ERR,
  1769. "error: no journal found. "
  1770. "mounting ext3 over ext2?");
  1771. goto failed_mount2;
  1772. }
  1773. err = percpu_counter_init(&sbi->s_freeblocks_counter,
  1774. ext3_count_free_blocks(sb));
  1775. if (!err) {
  1776. err = percpu_counter_init(&sbi->s_freeinodes_counter,
  1777. ext3_count_free_inodes(sb));
  1778. }
  1779. if (!err) {
  1780. err = percpu_counter_init(&sbi->s_dirs_counter,
  1781. ext3_count_dirs(sb));
  1782. }
  1783. if (err) {
  1784. ext3_msg(sb, KERN_ERR, "error: insufficient memory");
  1785. goto failed_mount3;
  1786. }
  1787. /* We have now updated the journal if required, so we can
  1788. * validate the data journaling mode. */
  1789. switch (test_opt(sb, DATA_FLAGS)) {
  1790. case 0:
  1791. /* No mode set, assume a default based on the journal
  1792. capabilities: ORDERED_DATA if the journal can
  1793. cope, else JOURNAL_DATA */
  1794. if (journal_check_available_features
  1795. (sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE))
  1796. set_opt(sbi->s_mount_opt, DEFAULT_DATA_MODE);
  1797. else
  1798. set_opt(sbi->s_mount_opt, JOURNAL_DATA);
  1799. break;
  1800. case EXT3_MOUNT_ORDERED_DATA:
  1801. case EXT3_MOUNT_WRITEBACK_DATA:
  1802. if (!journal_check_available_features
  1803. (sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE)) {
  1804. ext3_msg(sb, KERN_ERR,
  1805. "error: journal does not support "
  1806. "requested data journaling mode");
  1807. goto failed_mount3;
  1808. }
  1809. default:
  1810. break;
  1811. }
  1812. if (test_opt(sb, NOBH)) {
  1813. if (!(test_opt(sb, DATA_FLAGS) == EXT3_MOUNT_WRITEBACK_DATA)) {
  1814. ext3_msg(sb, KERN_WARNING,
  1815. "warning: ignoring nobh option - "
  1816. "it is supported only with writeback mode");
  1817. clear_opt(sbi->s_mount_opt, NOBH);
  1818. }
  1819. }
  1820. /*
  1821. * The journal_load will have done any necessary log recovery,
  1822. * so we can safely mount the rest of the filesystem now.
  1823. */
  1824. root = ext3_iget(sb, EXT3_ROOT_INO);
  1825. if (IS_ERR(root)) {
  1826. ext3_msg(sb, KERN_ERR, "error: get root inode failed");
  1827. ret = PTR_ERR(root);
  1828. goto failed_mount3;
  1829. }
  1830. if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
  1831. iput(root);
  1832. ext3_msg(sb, KERN_ERR, "error: corrupt root inode, run e2fsck");
  1833. goto failed_mount3;
  1834. }
  1835. sb->s_root = d_alloc_root(root);
  1836. if (!sb->s_root) {
  1837. ext3_msg(sb, KERN_ERR, "error: get root dentry failed");
  1838. iput(root);
  1839. ret = -ENOMEM;
  1840. goto failed_mount3;
  1841. }
  1842. ext3_setup_super (sb, es, sb->s_flags & MS_RDONLY);
  1843. EXT3_SB(sb)->s_mount_state |= EXT3_ORPHAN_FS;
  1844. ext3_orphan_cleanup(sb, es);
  1845. EXT3_SB(sb)->s_mount_state &= ~EXT3_ORPHAN_FS;
  1846. if (needs_recovery)
  1847. ext3_msg(sb, KERN_INFO, "recovery complete");
  1848. ext3_mark_recovery_complete(sb, es);
  1849. ext3_msg(sb, KERN_INFO, "mounted filesystem with %s data mode",
  1850. test_opt(sb,DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA ? "journal":
  1851. test_opt(sb,DATA_FLAGS) == EXT3_MOUNT_ORDERED_DATA ? "ordered":
  1852. "writeback");
  1853. lock_kernel();
  1854. return 0;
  1855. cantfind_ext3:
  1856. if (!silent)
  1857. ext3_msg(sb, KERN_INFO,
  1858. "error: can't find ext3 filesystem on dev %s.",
  1859. sb->s_id);
  1860. goto failed_mount;
  1861. failed_mount3:
  1862. percpu_counter_destroy(&sbi->s_freeblocks_counter);
  1863. percpu_counter_destroy(&sbi->s_freeinodes_counter);
  1864. percpu_counter_destroy(&sbi->s_dirs_counter);
  1865. journal_destroy(sbi->s_journal);
  1866. failed_mount2:
  1867. for (i = 0; i < db_count; i++)
  1868. brelse(sbi->s_group_desc[i]);
  1869. kfree(sbi->s_group_desc);
  1870. failed_mount:
  1871. #ifdef CONFIG_QUOTA
  1872. for (i = 0; i < MAXQUOTAS; i++)
  1873. kfree(sbi->s_qf_names[i]);
  1874. #endif
  1875. ext3_blkdev_remove(sbi);
  1876. brelse(bh);
  1877. out_fail:
  1878. sb->s_fs_info = NULL;
  1879. kfree(sbi->s_blockgroup_lock);
  1880. kfree(sbi);
  1881. lock_kernel();
  1882. return ret;
  1883. }
  1884. /*
  1885. * Setup any per-fs journal parameters now. We'll do this both on
  1886. * initial mount, once the journal has been initialised but before we've
  1887. * done any recovery; and again on any subsequent remount.
  1888. */
  1889. static void ext3_init_journal_params(struct super_block *sb, journal_t *journal)
  1890. {
  1891. struct ext3_sb_info *sbi = EXT3_SB(sb);
  1892. if (sbi->s_commit_interval)
  1893. journal->j_commit_interval = sbi->s_commit_interval;
  1894. /* We could also set up an ext3-specific default for the commit
  1895. * interval here, but for now we'll just fall back to the jbd
  1896. * default. */
  1897. spin_lock(&journal->j_state_lock);
  1898. if (test_opt(sb, BARRIER))
  1899. journal->j_flags |= JFS_BARRIER;
  1900. else
  1901. journal->j_flags &= ~JFS_BARRIER;
  1902. if (test_opt(sb, DATA_ERR_ABORT))
  1903. journal->j_flags |= JFS_ABORT_ON_SYNCDATA_ERR;
  1904. else
  1905. journal->j_flags &= ~JFS_ABORT_ON_SYNCDATA_ERR;
  1906. spin_unlock(&journal->j_state_lock);
  1907. }
  1908. static journal_t *ext3_get_journal(struct super_block *sb,
  1909. unsigned int journal_inum)
  1910. {
  1911. struct inode *journal_inode;
  1912. journal_t *journal;
  1913. /* First, test for the existence of a valid inode on disk. Bad
  1914. * things happen if we iget() an unused inode, as the subsequent
  1915. * iput() will try to delete it. */
  1916. journal_inode = ext3_iget(sb, journal_inum);
  1917. if (IS_ERR(journal_inode)) {
  1918. ext3_msg(sb, KERN_ERR, "error: no journal found");
  1919. return NULL;
  1920. }
  1921. if (!journal_inode->i_nlink) {
  1922. make_bad_inode(journal_inode);
  1923. iput(journal_inode);
  1924. ext3_msg(sb, KERN_ERR, "error: journal inode is deleted");
  1925. return NULL;
  1926. }
  1927. jbd_debug(2, "Journal inode found at %p: %Ld bytes\n",
  1928. journal_inode, journal_inode->i_size);
  1929. if (!S_ISREG(journal_inode->i_mode)) {
  1930. ext3_msg(sb, KERN_ERR, "error: invalid journal inode");
  1931. iput(journal_inode);
  1932. return NULL;
  1933. }
  1934. journal = journal_init_inode(journal_inode);
  1935. if (!journal) {
  1936. ext3_msg(sb, KERN_ERR, "error: could not load journal inode");
  1937. iput(journal_inode);
  1938. return NULL;
  1939. }
  1940. journal->j_private = sb;
  1941. ext3_init_journal_params(sb, journal);
  1942. return journal;
  1943. }
  1944. static journal_t *ext3_get_dev_journal(struct super_block *sb,
  1945. dev_t j_dev)
  1946. {
  1947. struct buffer_head * bh;
  1948. journal_t *journal;
  1949. ext3_fsblk_t start;
  1950. ext3_fsblk_t len;
  1951. int hblock, blocksize;
  1952. ext3_fsblk_t sb_block;
  1953. unsigned long offset;
  1954. struct ext3_super_block * es;
  1955. struct block_device *bdev;
  1956. bdev = ext3_blkdev_get(j_dev, sb);
  1957. if (bdev == NULL)
  1958. return NULL;
  1959. if (bd_claim(bdev, sb)) {
  1960. ext3_msg(sb, KERN_ERR,
  1961. "error: failed to claim external journal device");
  1962. blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
  1963. return NULL;
  1964. }
  1965. blocksize = sb->s_blocksize;
  1966. hblock = bdev_logical_block_size(bdev);
  1967. if (blocksize < hblock) {
  1968. ext3_msg(sb, KERN_ERR,
  1969. "error: blocksize too small for journal device");
  1970. goto out_bdev;
  1971. }
  1972. sb_block = EXT3_MIN_BLOCK_SIZE / blocksize;
  1973. offset = EXT3_MIN_BLOCK_SIZE % blocksize;
  1974. set_blocksize(bdev, blocksize);
  1975. if (!(bh = __bread(bdev, sb_block, blocksize))) {
  1976. ext3_msg(sb, KERN_ERR, "error: couldn't read superblock of "
  1977. "external journal");
  1978. goto out_bdev;
  1979. }
  1980. es = (struct ext3_super_block *) (((char *)bh->b_data) + offset);
  1981. if ((le16_to_cpu(es->s_magic) != EXT3_SUPER_MAGIC) ||
  1982. !(le32_to_cpu(es->s_feature_incompat) &
  1983. EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
  1984. ext3_msg(sb, KERN_ERR, "error: external journal has "
  1985. "bad superblock");
  1986. brelse(bh);
  1987. goto out_bdev;
  1988. }
  1989. if (memcmp(EXT3_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
  1990. ext3_msg(sb, KERN_ERR, "error: journal UUID does not match");
  1991. brelse(bh);
  1992. goto out_bdev;
  1993. }
  1994. len = le32_to_cpu(es->s_blocks_count);
  1995. start = sb_block + 1;
  1996. brelse(bh); /* we're done with the superblock */
  1997. journal = journal_init_dev(bdev, sb->s_bdev,
  1998. start, len, blocksize);
  1999. if (!journal) {
  2000. ext3_msg(sb, KERN_ERR,
  2001. "error: failed to create device journal");
  2002. goto out_bdev;
  2003. }
  2004. journal->j_private = sb;
  2005. ll_rw_block(READ, 1, &journal->j_sb_buffer);
  2006. wait_on_buffer(journal->j_sb_buffer);
  2007. if (!buffer_uptodate(journal->j_sb_buffer)) {
  2008. ext3_msg(sb, KERN_ERR, "I/O error on journal device");
  2009. goto out_journal;
  2010. }
  2011. if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
  2012. ext3_msg(sb, KERN_ERR,
  2013. "error: external journal has more than one "
  2014. "user (unsupported) - %d",
  2015. be32_to_cpu(journal->j_superblock->s_nr_users));
  2016. goto out_journal;
  2017. }
  2018. EXT3_SB(sb)->journal_bdev = bdev;
  2019. ext3_init_journal_params(sb, journal);
  2020. return journal;
  2021. out_journal:
  2022. journal_destroy(journal);
  2023. out_bdev:
  2024. ext3_blkdev_put(bdev);
  2025. return NULL;
  2026. }
  2027. static int ext3_load_journal(struct super_block *sb,
  2028. struct ext3_super_block *es,
  2029. unsigned long journal_devnum)
  2030. {
  2031. journal_t *journal;
  2032. unsigned int journal_inum = le32_to_cpu(es->s_journal_inum);
  2033. dev_t journal_dev;
  2034. int err = 0;
  2035. int really_read_only;
  2036. if (journal_devnum &&
  2037. journal_devnum != le32_to_cpu(es->s_journal_dev)) {
  2038. ext3_msg(sb, KERN_INFO, "external journal device major/minor "
  2039. "numbers have changed");
  2040. journal_dev = new_decode_dev(journal_devnum);
  2041. } else
  2042. journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
  2043. really_read_only = bdev_read_only(sb->s_bdev);
  2044. /*
  2045. * Are we loading a blank journal or performing recovery after a
  2046. * crash? For recovery, we need to check in advance whether we
  2047. * can get read-write access to the device.
  2048. */
  2049. if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER)) {
  2050. if (sb->s_flags & MS_RDONLY) {
  2051. ext3_msg(sb, KERN_INFO,
  2052. "recovery required on readonly filesystem");
  2053. if (really_read_only) {
  2054. ext3_msg(sb, KERN_ERR, "error: write access "
  2055. "unavailable, cannot proceed");
  2056. return -EROFS;
  2057. }
  2058. ext3_msg(sb, KERN_INFO,
  2059. "write access will be enabled during recovery");
  2060. }
  2061. }
  2062. if (journal_inum && journal_dev) {
  2063. ext3_msg(sb, KERN_ERR, "error: filesystem has both journal "
  2064. "and inode journals");
  2065. return -EINVAL;
  2066. }
  2067. if (journal_inum) {
  2068. if (!(journal = ext3_get_journal(sb, journal_inum)))
  2069. return -EINVAL;
  2070. } else {
  2071. if (!(journal = ext3_get_dev_journal(sb, journal_dev)))
  2072. return -EINVAL;
  2073. }
  2074. if (!(journal->j_flags & JFS_BARRIER))
  2075. printk(KERN_INFO "EXT3-fs: barriers not enabled\n");
  2076. if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) {
  2077. err = journal_update_format(journal);
  2078. if (err) {
  2079. ext3_msg(sb, KERN_ERR, "error updating journal");
  2080. journal_destroy(journal);
  2081. return err;
  2082. }
  2083. }
  2084. if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER))
  2085. err = journal_wipe(journal, !really_read_only);
  2086. if (!err)
  2087. err = journal_load(journal);
  2088. if (err) {
  2089. ext3_msg(sb, KERN_ERR, "error loading journal");
  2090. journal_destroy(journal);
  2091. return err;
  2092. }
  2093. EXT3_SB(sb)->s_journal = journal;
  2094. ext3_clear_journal_err(sb, es);
  2095. if (journal_devnum &&
  2096. journal_devnum != le32_to_cpu(es->s_journal_dev)) {
  2097. es->s_journal_dev = cpu_to_le32(journal_devnum);
  2098. /* Make sure we flush the recovery flag to disk. */
  2099. ext3_commit_super(sb, es, 1);
  2100. }
  2101. return 0;
  2102. }
  2103. static int ext3_create_journal(struct super_block *sb,
  2104. struct ext3_super_block *es,
  2105. unsigned int journal_inum)
  2106. {
  2107. journal_t *journal;
  2108. int err;
  2109. if (sb->s_flags & MS_RDONLY) {
  2110. ext3_msg(sb, KERN_ERR,
  2111. "error: readonly filesystem when trying to "
  2112. "create journal");
  2113. return -EROFS;
  2114. }
  2115. journal = ext3_get_journal(sb, journal_inum);
  2116. if (!journal)
  2117. return -EINVAL;
  2118. ext3_msg(sb, KERN_INFO, "creating new journal on inode %u",
  2119. journal_inum);
  2120. err = journal_create(journal);
  2121. if (err) {
  2122. ext3_msg(sb, KERN_ERR, "error creating journal");
  2123. journal_destroy(journal);
  2124. return -EIO;
  2125. }
  2126. EXT3_SB(sb)->s_journal = journal;
  2127. ext3_update_dynamic_rev(sb);
  2128. EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
  2129. EXT3_SET_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL);
  2130. es->s_journal_inum = cpu_to_le32(journal_inum);
  2131. /* Make sure we flush the recovery flag to disk. */
  2132. ext3_commit_super(sb, es, 1);
  2133. return 0;
  2134. }
  2135. static int ext3_commit_super(struct super_block *sb,
  2136. struct ext3_super_block *es,
  2137. int sync)
  2138. {
  2139. struct buffer_head *sbh = EXT3_SB(sb)->s_sbh;
  2140. int error = 0;
  2141. if (!sbh)
  2142. return error;
  2143. /*
  2144. * If the file system is mounted read-only, don't update the
  2145. * superblock write time. This avoids updating the superblock
  2146. * write time when we are mounting the root file system
  2147. * read/only but we need to replay the journal; at that point,
  2148. * for people who are east of GMT and who make their clock
  2149. * tick in localtime for Windows bug-for-bug compatibility,
  2150. * the clock is set in the future, and this will cause e2fsck
  2151. * to complain and force a full file system check.
  2152. */
  2153. if (!(sb->s_flags & MS_RDONLY))
  2154. es->s_wtime = cpu_to_le32(get_seconds());
  2155. es->s_free_blocks_count = cpu_to_le32(ext3_count_free_blocks(sb));
  2156. es->s_free_inodes_count = cpu_to_le32(ext3_count_free_inodes(sb));
  2157. BUFFER_TRACE(sbh, "marking dirty");
  2158. mark_buffer_dirty(sbh);
  2159. if (sync)
  2160. error = sync_dirty_buffer(sbh);
  2161. return error;
  2162. }
  2163. /*
  2164. * Have we just finished recovery? If so, and if we are mounting (or
  2165. * remounting) the filesystem readonly, then we will end up with a
  2166. * consistent fs on disk. Record that fact.
  2167. */
  2168. static void ext3_mark_recovery_complete(struct super_block * sb,
  2169. struct ext3_super_block * es)
  2170. {
  2171. journal_t *journal = EXT3_SB(sb)->s_journal;
  2172. journal_lock_updates(journal);
  2173. if (journal_flush(journal) < 0)
  2174. goto out;
  2175. if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER) &&
  2176. sb->s_flags & MS_RDONLY) {
  2177. EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
  2178. ext3_commit_super(sb, es, 1);
  2179. }
  2180. out:
  2181. journal_unlock_updates(journal);
  2182. }
  2183. /*
  2184. * If we are mounting (or read-write remounting) a filesystem whose journal
  2185. * has recorded an error from a previous lifetime, move that error to the
  2186. * main filesystem now.
  2187. */
  2188. static void ext3_clear_journal_err(struct super_block *sb,
  2189. struct ext3_super_block *es)
  2190. {
  2191. journal_t *journal;
  2192. int j_errno;
  2193. const char *errstr;
  2194. journal = EXT3_SB(sb)->s_journal;
  2195. /*
  2196. * Now check for any error status which may have been recorded in the
  2197. * journal by a prior ext3_error() or ext3_abort()
  2198. */
  2199. j_errno = journal_errno(journal);
  2200. if (j_errno) {
  2201. char nbuf[16];
  2202. errstr = ext3_decode_error(sb, j_errno, nbuf);
  2203. ext3_warning(sb, __func__, "Filesystem error recorded "
  2204. "from previous mount: %s", errstr);
  2205. ext3_warning(sb, __func__, "Marking fs in need of "
  2206. "filesystem check.");
  2207. EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
  2208. es->s_state |= cpu_to_le16(EXT3_ERROR_FS);
  2209. ext3_commit_super (sb, es, 1);
  2210. journal_clear_err(journal);
  2211. }
  2212. }
  2213. /*
  2214. * Force the running and committing transactions to commit,
  2215. * and wait on the commit.
  2216. */
  2217. int ext3_force_commit(struct super_block *sb)
  2218. {
  2219. journal_t *journal;
  2220. int ret;
  2221. if (sb->s_flags & MS_RDONLY)
  2222. return 0;
  2223. journal = EXT3_SB(sb)->s_journal;
  2224. ret = ext3_journal_force_commit(journal);
  2225. return ret;
  2226. }
  2227. static int ext3_sync_fs(struct super_block *sb, int wait)
  2228. {
  2229. tid_t target;
  2230. if (journal_start_commit(EXT3_SB(sb)->s_journal, &target)) {
  2231. if (wait)
  2232. log_wait_commit(EXT3_SB(sb)->s_journal, target);
  2233. }
  2234. return 0;
  2235. }
  2236. /*
  2237. * LVM calls this function before a (read-only) snapshot is created. This
  2238. * gives us a chance to flush the journal completely and mark the fs clean.
  2239. */
  2240. static int ext3_freeze(struct super_block *sb)
  2241. {
  2242. int error = 0;
  2243. journal_t *journal;
  2244. if (!(sb->s_flags & MS_RDONLY)) {
  2245. journal = EXT3_SB(sb)->s_journal;
  2246. /* Now we set up the journal barrier. */
  2247. journal_lock_updates(journal);
  2248. /*
  2249. * We don't want to clear needs_recovery flag when we failed
  2250. * to flush the journal.
  2251. */
  2252. error = journal_flush(journal);
  2253. if (error < 0)
  2254. goto out;
  2255. /* Journal blocked and flushed, clear needs_recovery flag. */
  2256. EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
  2257. error = ext3_commit_super(sb, EXT3_SB(sb)->s_es, 1);
  2258. if (error)
  2259. goto out;
  2260. }
  2261. return 0;
  2262. out:
  2263. journal_unlock_updates(journal);
  2264. return error;
  2265. }
  2266. /*
  2267. * Called by LVM after the snapshot is done. We need to reset the RECOVER
  2268. * flag here, even though the filesystem is not technically dirty yet.
  2269. */
  2270. static int ext3_unfreeze(struct super_block *sb)
  2271. {
  2272. if (!(sb->s_flags & MS_RDONLY)) {
  2273. lock_super(sb);
  2274. /* Reser the needs_recovery flag before the fs is unlocked. */
  2275. EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
  2276. ext3_commit_super(sb, EXT3_SB(sb)->s_es, 1);
  2277. unlock_super(sb);
  2278. journal_unlock_updates(EXT3_SB(sb)->s_journal);
  2279. }
  2280. return 0;
  2281. }
  2282. static int ext3_remount (struct super_block * sb, int * flags, char * data)
  2283. {
  2284. struct ext3_super_block * es;
  2285. struct ext3_sb_info *sbi = EXT3_SB(sb);
  2286. ext3_fsblk_t n_blocks_count = 0;
  2287. unsigned long old_sb_flags;
  2288. struct ext3_mount_options old_opts;
  2289. int err;
  2290. #ifdef CONFIG_QUOTA
  2291. int i;
  2292. #endif
  2293. lock_kernel();
  2294. /* Store the original options */
  2295. lock_super(sb);
  2296. old_sb_flags = sb->s_flags;
  2297. old_opts.s_mount_opt = sbi->s_mount_opt;
  2298. old_opts.s_resuid = sbi->s_resuid;
  2299. old_opts.s_resgid = sbi->s_resgid;
  2300. old_opts.s_commit_interval = sbi->s_commit_interval;
  2301. #ifdef CONFIG_QUOTA
  2302. old_opts.s_jquota_fmt = sbi->s_jquota_fmt;
  2303. for (i = 0; i < MAXQUOTAS; i++)
  2304. old_opts.s_qf_names[i] = sbi->s_qf_names[i];
  2305. #endif
  2306. /*
  2307. * Allow the "check" option to be passed as a remount option.
  2308. */
  2309. if (!parse_options(data, sb, NULL, NULL, &n_blocks_count, 1)) {
  2310. err = -EINVAL;
  2311. goto restore_opts;
  2312. }
  2313. if (test_opt(sb, ABORT))
  2314. ext3_abort(sb, __func__, "Abort forced by user");
  2315. sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
  2316. (test_opt(sb, POSIX_ACL) ? MS_POSIXACL : 0);
  2317. es = sbi->s_es;
  2318. ext3_init_journal_params(sb, sbi->s_journal);
  2319. if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY) ||
  2320. n_blocks_count > le32_to_cpu(es->s_blocks_count)) {
  2321. if (test_opt(sb, ABORT)) {
  2322. err = -EROFS;
  2323. goto restore_opts;
  2324. }
  2325. if (*flags & MS_RDONLY) {
  2326. /*
  2327. * First of all, the unconditional stuff we have to do
  2328. * to disable replay of the journal when we next remount
  2329. */
  2330. sb->s_flags |= MS_RDONLY;
  2331. /*
  2332. * OK, test if we are remounting a valid rw partition
  2333. * readonly, and if so set the rdonly flag and then
  2334. * mark the partition as valid again.
  2335. */
  2336. if (!(es->s_state & cpu_to_le16(EXT3_VALID_FS)) &&
  2337. (sbi->s_mount_state & EXT3_VALID_FS))
  2338. es->s_state = cpu_to_le16(sbi->s_mount_state);
  2339. ext3_mark_recovery_complete(sb, es);
  2340. } else {
  2341. __le32 ret;
  2342. if ((ret = EXT3_HAS_RO_COMPAT_FEATURE(sb,
  2343. ~EXT3_FEATURE_RO_COMPAT_SUPP))) {
  2344. ext3_msg(sb, KERN_WARNING,
  2345. "warning: couldn't remount RDWR "
  2346. "because of unsupported optional "
  2347. "features (%x)", le32_to_cpu(ret));
  2348. err = -EROFS;
  2349. goto restore_opts;
  2350. }
  2351. /*
  2352. * If we have an unprocessed orphan list hanging
  2353. * around from a previously readonly bdev mount,
  2354. * require a full umount/remount for now.
  2355. */
  2356. if (es->s_last_orphan) {
  2357. ext3_msg(sb, KERN_WARNING, "warning: couldn't "
  2358. "remount RDWR because of unprocessed "
  2359. "orphan inode list. Please "
  2360. "umount/remount instead.");
  2361. err = -EINVAL;
  2362. goto restore_opts;
  2363. }
  2364. /*
  2365. * Mounting a RDONLY partition read-write, so reread
  2366. * and store the current valid flag. (It may have
  2367. * been changed by e2fsck since we originally mounted
  2368. * the partition.)
  2369. */
  2370. ext3_clear_journal_err(sb, es);
  2371. sbi->s_mount_state = le16_to_cpu(es->s_state);
  2372. if ((err = ext3_group_extend(sb, es, n_blocks_count)))
  2373. goto restore_opts;
  2374. if (!ext3_setup_super (sb, es, 0))
  2375. sb->s_flags &= ~MS_RDONLY;
  2376. }
  2377. }
  2378. #ifdef CONFIG_QUOTA
  2379. /* Release old quota file names */
  2380. for (i = 0; i < MAXQUOTAS; i++)
  2381. if (old_opts.s_qf_names[i] &&
  2382. old_opts.s_qf_names[i] != sbi->s_qf_names[i])
  2383. kfree(old_opts.s_qf_names[i]);
  2384. #endif
  2385. unlock_super(sb);
  2386. unlock_kernel();
  2387. return 0;
  2388. restore_opts:
  2389. sb->s_flags = old_sb_flags;
  2390. sbi->s_mount_opt = old_opts.s_mount_opt;
  2391. sbi->s_resuid = old_opts.s_resuid;
  2392. sbi->s_resgid = old_opts.s_resgid;
  2393. sbi->s_commit_interval = old_opts.s_commit_interval;
  2394. #ifdef CONFIG_QUOTA
  2395. sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
  2396. for (i = 0; i < MAXQUOTAS; i++) {
  2397. if (sbi->s_qf_names[i] &&
  2398. old_opts.s_qf_names[i] != sbi->s_qf_names[i])
  2399. kfree(sbi->s_qf_names[i]);
  2400. sbi->s_qf_names[i] = old_opts.s_qf_names[i];
  2401. }
  2402. #endif
  2403. unlock_super(sb);
  2404. unlock_kernel();
  2405. return err;
  2406. }
  2407. static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf)
  2408. {
  2409. struct super_block *sb = dentry->d_sb;
  2410. struct ext3_sb_info *sbi = EXT3_SB(sb);
  2411. struct ext3_super_block *es = sbi->s_es;
  2412. u64 fsid;
  2413. if (test_opt(sb, MINIX_DF)) {
  2414. sbi->s_overhead_last = 0;
  2415. } else if (sbi->s_blocks_last != le32_to_cpu(es->s_blocks_count)) {
  2416. unsigned long ngroups = sbi->s_groups_count, i;
  2417. ext3_fsblk_t overhead = 0;
  2418. smp_rmb();
  2419. /*
  2420. * Compute the overhead (FS structures). This is constant
  2421. * for a given filesystem unless the number of block groups
  2422. * changes so we cache the previous value until it does.
  2423. */
  2424. /*
  2425. * All of the blocks before first_data_block are
  2426. * overhead
  2427. */
  2428. overhead = le32_to_cpu(es->s_first_data_block);
  2429. /*
  2430. * Add the overhead attributed to the superblock and
  2431. * block group descriptors. If the sparse superblocks
  2432. * feature is turned on, then not all groups have this.
  2433. */
  2434. for (i = 0; i < ngroups; i++) {
  2435. overhead += ext3_bg_has_super(sb, i) +
  2436. ext3_bg_num_gdb(sb, i);
  2437. cond_resched();
  2438. }
  2439. /*
  2440. * Every block group has an inode bitmap, a block
  2441. * bitmap, and an inode table.
  2442. */
  2443. overhead += ngroups * (2 + sbi->s_itb_per_group);
  2444. sbi->s_overhead_last = overhead;
  2445. smp_wmb();
  2446. sbi->s_blocks_last = le32_to_cpu(es->s_blocks_count);
  2447. }
  2448. buf->f_type = EXT3_SUPER_MAGIC;
  2449. buf->f_bsize = sb->s_blocksize;
  2450. buf->f_blocks = le32_to_cpu(es->s_blocks_count) - sbi->s_overhead_last;
  2451. buf->f_bfree = percpu_counter_sum_positive(&sbi->s_freeblocks_counter);
  2452. buf->f_bavail = buf->f_bfree - le32_to_cpu(es->s_r_blocks_count);
  2453. if (buf->f_bfree < le32_to_cpu(es->s_r_blocks_count))
  2454. buf->f_bavail = 0;
  2455. buf->f_files = le32_to_cpu(es->s_inodes_count);
  2456. buf->f_ffree = percpu_counter_sum_positive(&sbi->s_freeinodes_counter);
  2457. buf->f_namelen = EXT3_NAME_LEN;
  2458. fsid = le64_to_cpup((void *)es->s_uuid) ^
  2459. le64_to_cpup((void *)es->s_uuid + sizeof(u64));
  2460. buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
  2461. buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
  2462. return 0;
  2463. }
  2464. /* Helper function for writing quotas on sync - we need to start transaction before quota file
  2465. * is locked for write. Otherwise the are possible deadlocks:
  2466. * Process 1 Process 2
  2467. * ext3_create() quota_sync()
  2468. * journal_start() write_dquot()
  2469. * dquot_initialize() down(dqio_mutex)
  2470. * down(dqio_mutex) journal_start()
  2471. *
  2472. */
  2473. #ifdef CONFIG_QUOTA
  2474. static inline struct inode *dquot_to_inode(struct dquot *dquot)
  2475. {
  2476. return sb_dqopt(dquot->dq_sb)->files[dquot->dq_type];
  2477. }
  2478. static int ext3_write_dquot(struct dquot *dquot)
  2479. {
  2480. int ret, err;
  2481. handle_t *handle;
  2482. struct inode *inode;
  2483. inode = dquot_to_inode(dquot);
  2484. handle = ext3_journal_start(inode,
  2485. EXT3_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
  2486. if (IS_ERR(handle))
  2487. return PTR_ERR(handle);
  2488. ret = dquot_commit(dquot);
  2489. err = ext3_journal_stop(handle);
  2490. if (!ret)
  2491. ret = err;
  2492. return ret;
  2493. }
  2494. static int ext3_acquire_dquot(struct dquot *dquot)
  2495. {
  2496. int ret, err;
  2497. handle_t *handle;
  2498. handle = ext3_journal_start(dquot_to_inode(dquot),
  2499. EXT3_QUOTA_INIT_BLOCKS(dquot->dq_sb));
  2500. if (IS_ERR(handle))
  2501. return PTR_ERR(handle);
  2502. ret = dquot_acquire(dquot);
  2503. err = ext3_journal_stop(handle);
  2504. if (!ret)
  2505. ret = err;
  2506. return ret;
  2507. }
  2508. static int ext3_release_dquot(struct dquot *dquot)
  2509. {
  2510. int ret, err;
  2511. handle_t *handle;
  2512. handle = ext3_journal_start(dquot_to_inode(dquot),
  2513. EXT3_QUOTA_DEL_BLOCKS(dquot->dq_sb));
  2514. if (IS_ERR(handle)) {
  2515. /* Release dquot anyway to avoid endless cycle in dqput() */
  2516. dquot_release(dquot);
  2517. return PTR_ERR(handle);
  2518. }
  2519. ret = dquot_release(dquot);
  2520. err = ext3_journal_stop(handle);
  2521. if (!ret)
  2522. ret = err;
  2523. return ret;
  2524. }
  2525. static int ext3_mark_dquot_dirty(struct dquot *dquot)
  2526. {
  2527. /* Are we journaling quotas? */
  2528. if (EXT3_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
  2529. EXT3_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
  2530. dquot_mark_dquot_dirty(dquot);
  2531. return ext3_write_dquot(dquot);
  2532. } else {
  2533. return dquot_mark_dquot_dirty(dquot);
  2534. }
  2535. }
  2536. static int ext3_write_info(struct super_block *sb, int type)
  2537. {
  2538. int ret, err;
  2539. handle_t *handle;
  2540. /* Data block + inode block */
  2541. handle = ext3_journal_start(sb->s_root->d_inode, 2);
  2542. if (IS_ERR(handle))
  2543. return PTR_ERR(handle);
  2544. ret = dquot_commit_info(sb, type);
  2545. err = ext3_journal_stop(handle);
  2546. if (!ret)
  2547. ret = err;
  2548. return ret;
  2549. }
  2550. /*
  2551. * Turn on quotas during mount time - we need to find
  2552. * the quota file and such...
  2553. */
  2554. static int ext3_quota_on_mount(struct super_block *sb, int type)
  2555. {
  2556. return vfs_quota_on_mount(sb, EXT3_SB(sb)->s_qf_names[type],
  2557. EXT3_SB(sb)->s_jquota_fmt, type);
  2558. }
  2559. /*
  2560. * Standard function to be called on quota_on
  2561. */
  2562. static int ext3_quota_on(struct super_block *sb, int type, int format_id,
  2563. char *name, int remount)
  2564. {
  2565. int err;
  2566. struct path path;
  2567. if (!test_opt(sb, QUOTA))
  2568. return -EINVAL;
  2569. /* When remounting, no checks are needed and in fact, name is NULL */
  2570. if (remount)
  2571. return vfs_quota_on(sb, type, format_id, name, remount);
  2572. err = kern_path(name, LOOKUP_FOLLOW, &path);
  2573. if (err)
  2574. return err;
  2575. /* Quotafile not on the same filesystem? */
  2576. if (path.mnt->mnt_sb != sb) {
  2577. path_put(&path);
  2578. return -EXDEV;
  2579. }
  2580. /* Journaling quota? */
  2581. if (EXT3_SB(sb)->s_qf_names[type]) {
  2582. /* Quotafile not of fs root? */
  2583. if (path.dentry->d_parent != sb->s_root)
  2584. ext3_msg(sb, KERN_WARNING,
  2585. "warning: Quota file not on filesystem root. "
  2586. "Journaled quota will not work.");
  2587. }
  2588. /*
  2589. * When we journal data on quota file, we have to flush journal to see
  2590. * all updates to the file when we bypass pagecache...
  2591. */
  2592. if (ext3_should_journal_data(path.dentry->d_inode)) {
  2593. /*
  2594. * We don't need to lock updates but journal_flush() could
  2595. * otherwise be livelocked...
  2596. */
  2597. journal_lock_updates(EXT3_SB(sb)->s_journal);
  2598. err = journal_flush(EXT3_SB(sb)->s_journal);
  2599. journal_unlock_updates(EXT3_SB(sb)->s_journal);
  2600. if (err) {
  2601. path_put(&path);
  2602. return err;
  2603. }
  2604. }
  2605. err = vfs_quota_on_path(sb, type, format_id, &path);
  2606. path_put(&path);
  2607. return err;
  2608. }
  2609. /* Read data from quotafile - avoid pagecache and such because we cannot afford
  2610. * acquiring the locks... As quota files are never truncated and quota code
  2611. * itself serializes the operations (and noone else should touch the files)
  2612. * we don't have to be afraid of races */
  2613. static ssize_t ext3_quota_read(struct super_block *sb, int type, char *data,
  2614. size_t len, loff_t off)
  2615. {
  2616. struct inode *inode = sb_dqopt(sb)->files[type];
  2617. sector_t blk = off >> EXT3_BLOCK_SIZE_BITS(sb);
  2618. int err = 0;
  2619. int offset = off & (sb->s_blocksize - 1);
  2620. int tocopy;
  2621. size_t toread;
  2622. struct buffer_head *bh;
  2623. loff_t i_size = i_size_read(inode);
  2624. if (off > i_size)
  2625. return 0;
  2626. if (off+len > i_size)
  2627. len = i_size-off;
  2628. toread = len;
  2629. while (toread > 0) {
  2630. tocopy = sb->s_blocksize - offset < toread ?
  2631. sb->s_blocksize - offset : toread;
  2632. bh = ext3_bread(NULL, inode, blk, 0, &err);
  2633. if (err)
  2634. return err;
  2635. if (!bh) /* A hole? */
  2636. memset(data, 0, tocopy);
  2637. else
  2638. memcpy(data, bh->b_data+offset, tocopy);
  2639. brelse(bh);
  2640. offset = 0;
  2641. toread -= tocopy;
  2642. data += tocopy;
  2643. blk++;
  2644. }
  2645. return len;
  2646. }
  2647. /* Write to quotafile (we know the transaction is already started and has
  2648. * enough credits) */
  2649. static ssize_t ext3_quota_write(struct super_block *sb, int type,
  2650. const char *data, size_t len, loff_t off)
  2651. {
  2652. struct inode *inode = sb_dqopt(sb)->files[type];
  2653. sector_t blk = off >> EXT3_BLOCK_SIZE_BITS(sb);
  2654. int err = 0;
  2655. int offset = off & (sb->s_blocksize - 1);
  2656. int journal_quota = EXT3_SB(sb)->s_qf_names[type] != NULL;
  2657. struct buffer_head *bh;
  2658. handle_t *handle = journal_current_handle();
  2659. if (!handle) {
  2660. ext3_msg(sb, KERN_WARNING,
  2661. "warning: quota write (off=%llu, len=%llu)"
  2662. " cancelled because transaction is not started.",
  2663. (unsigned long long)off, (unsigned long long)len);
  2664. return -EIO;
  2665. }
  2666. /*
  2667. * Since we account only one data block in transaction credits,
  2668. * then it is impossible to cross a block boundary.
  2669. */
  2670. if (sb->s_blocksize - offset < len) {
  2671. ext3_msg(sb, KERN_WARNING, "Quota write (off=%llu, len=%llu)"
  2672. " cancelled because not block aligned",
  2673. (unsigned long long)off, (unsigned long long)len);
  2674. return -EIO;
  2675. }
  2676. mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
  2677. bh = ext3_bread(handle, inode, blk, 1, &err);
  2678. if (!bh)
  2679. goto out;
  2680. if (journal_quota) {
  2681. err = ext3_journal_get_write_access(handle, bh);
  2682. if (err) {
  2683. brelse(bh);
  2684. goto out;
  2685. }
  2686. }
  2687. lock_buffer(bh);
  2688. memcpy(bh->b_data+offset, data, len);
  2689. flush_dcache_page(bh->b_page);
  2690. unlock_buffer(bh);
  2691. if (journal_quota)
  2692. err = ext3_journal_dirty_metadata(handle, bh);
  2693. else {
  2694. /* Always do at least ordered writes for quotas */
  2695. err = ext3_journal_dirty_data(handle, bh);
  2696. mark_buffer_dirty(bh);
  2697. }
  2698. brelse(bh);
  2699. out:
  2700. if (err) {
  2701. mutex_unlock(&inode->i_mutex);
  2702. return err;
  2703. }
  2704. if (inode->i_size < off + len) {
  2705. i_size_write(inode, off + len);
  2706. EXT3_I(inode)->i_disksize = inode->i_size;
  2707. }
  2708. inode->i_version++;
  2709. inode->i_mtime = inode->i_ctime = CURRENT_TIME;
  2710. ext3_mark_inode_dirty(handle, inode);
  2711. mutex_unlock(&inode->i_mutex);
  2712. return len;
  2713. }
  2714. #endif
  2715. static int ext3_get_sb(struct file_system_type *fs_type,
  2716. int flags, const char *dev_name, void *data, struct vfsmount *mnt)
  2717. {
  2718. return get_sb_bdev(fs_type, flags, dev_name, data, ext3_fill_super, mnt);
  2719. }
  2720. static struct file_system_type ext3_fs_type = {
  2721. .owner = THIS_MODULE,
  2722. .name = "ext3",
  2723. .get_sb = ext3_get_sb,
  2724. .kill_sb = kill_block_super,
  2725. .fs_flags = FS_REQUIRES_DEV,
  2726. };
  2727. static int __init init_ext3_fs(void)
  2728. {
  2729. int err = init_ext3_xattr();
  2730. if (err)
  2731. return err;
  2732. err = init_inodecache();
  2733. if (err)
  2734. goto out1;
  2735. err = register_filesystem(&ext3_fs_type);
  2736. if (err)
  2737. goto out;
  2738. return 0;
  2739. out:
  2740. destroy_inodecache();
  2741. out1:
  2742. exit_ext3_xattr();
  2743. return err;
  2744. }
  2745. static void __exit exit_ext3_fs(void)
  2746. {
  2747. unregister_filesystem(&ext3_fs_type);
  2748. destroy_inodecache();
  2749. exit_ext3_xattr();
  2750. }
  2751. MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
  2752. MODULE_DESCRIPTION("Second Extended Filesystem with journaling extensions");
  2753. MODULE_LICENSE("GPL");
  2754. module_init(init_ext3_fs)
  2755. module_exit(exit_ext3_fs)