super.c 44 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * linux/fs/ufs/super.c
  4. *
  5. * Copyright (C) 1998
  6. * Daniel Pirkl <daniel.pirkl@email.cz>
  7. * Charles University, Faculty of Mathematics and Physics
  8. */
  9. /* Derived from
  10. *
  11. * linux/fs/ext2/super.c
  12. *
  13. * Copyright (C) 1992, 1993, 1994, 1995
  14. * Remy Card (card@masi.ibp.fr)
  15. * Laboratoire MASI - Institut Blaise Pascal
  16. * Universite Pierre et Marie Curie (Paris VI)
  17. *
  18. * from
  19. *
  20. * linux/fs/minix/inode.c
  21. *
  22. * Copyright (C) 1991, 1992 Linus Torvalds
  23. *
  24. * Big-endian to little-endian byte-swapping/bitmaps by
  25. * David S. Miller (davem@caip.rutgers.edu), 1995
  26. */
  27. /*
  28. * Inspired by
  29. *
  30. * linux/fs/ufs/super.c
  31. *
  32. * Copyright (C) 1996
  33. * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
  34. * Laboratory for Computer Science Research Computing Facility
  35. * Rutgers, The State University of New Jersey
  36. *
  37. * Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
  38. *
  39. * Kernel module support added on 96/04/26 by
  40. * Stefan Reinauer <stepan@home.culture.mipt.ru>
  41. *
  42. * Module usage counts added on 96/04/29 by
  43. * Gertjan van Wingerde <gwingerde@gmail.com>
  44. *
  45. * Clean swab support on 19970406 by
  46. * Francois-Rene Rideau <fare@tunes.org>
  47. *
  48. * 4.4BSD (FreeBSD) support added on February 1st 1998 by
  49. * Niels Kristian Bech Jensen <nkbj@image.dk> partially based
  50. * on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>.
  51. *
  52. * NeXTstep support added on February 5th 1998 by
  53. * Niels Kristian Bech Jensen <nkbj@image.dk>.
  54. *
  55. * write support Daniel Pirkl <daniel.pirkl@email.cz> 1998
  56. *
  57. * HP/UX hfs filesystem support added by
  58. * Martin K. Petersen <mkp@mkp.net>, August 1999
  59. *
  60. * UFS2 (of FreeBSD 5.x) support added by
  61. * Niraj Kumar <niraj17@iitbombay.org>, Jan 2004
  62. *
  63. * UFS2 write support added by
  64. * Evgeniy Dushistov <dushistov@mail.ru>, 2007
  65. */
  66. #include <linux/exportfs.h>
  67. #include <linux/module.h>
  68. #include <linux/bitops.h>
  69. #include <stdarg.h>
  70. #include <linux/uaccess.h>
  71. #include <linux/errno.h>
  72. #include <linux/fs.h>
  73. #include <linux/slab.h>
  74. #include <linux/time.h>
  75. #include <linux/stat.h>
  76. #include <linux/string.h>
  77. #include <linux/blkdev.h>
  78. #include <linux/backing-dev.h>
  79. #include <linux/init.h>
  80. #include <linux/parser.h>
  81. #include <linux/buffer_head.h>
  82. #include <linux/vfs.h>
  83. #include <linux/log2.h>
  84. #include <linux/mount.h>
  85. #include <linux/seq_file.h>
  86. #include <linux/iversion.h>
  87. #include "ufs_fs.h"
  88. #include "ufs.h"
  89. #include "swab.h"
  90. #include "util.h"
  91. static struct inode *ufs_nfs_get_inode(struct super_block *sb, u64 ino, u32 generation)
  92. {
  93. struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
  94. struct inode *inode;
  95. if (ino < UFS_ROOTINO || ino > (u64)uspi->s_ncg * uspi->s_ipg)
  96. return ERR_PTR(-ESTALE);
  97. inode = ufs_iget(sb, ino);
  98. if (IS_ERR(inode))
  99. return ERR_CAST(inode);
  100. if (generation && inode->i_generation != generation) {
  101. iput(inode);
  102. return ERR_PTR(-ESTALE);
  103. }
  104. return inode;
  105. }
  106. static struct dentry *ufs_fh_to_dentry(struct super_block *sb, struct fid *fid,
  107. int fh_len, int fh_type)
  108. {
  109. return generic_fh_to_dentry(sb, fid, fh_len, fh_type, ufs_nfs_get_inode);
  110. }
  111. static struct dentry *ufs_fh_to_parent(struct super_block *sb, struct fid *fid,
  112. int fh_len, int fh_type)
  113. {
  114. return generic_fh_to_parent(sb, fid, fh_len, fh_type, ufs_nfs_get_inode);
  115. }
  116. static struct dentry *ufs_get_parent(struct dentry *child)
  117. {
  118. struct qstr dot_dot = QSTR_INIT("..", 2);
  119. ino_t ino;
  120. ino = ufs_inode_by_name(d_inode(child), &dot_dot);
  121. if (!ino)
  122. return ERR_PTR(-ENOENT);
  123. return d_obtain_alias(ufs_iget(child->d_sb, ino));
  124. }
  125. static const struct export_operations ufs_export_ops = {
  126. .fh_to_dentry = ufs_fh_to_dentry,
  127. .fh_to_parent = ufs_fh_to_parent,
  128. .get_parent = ufs_get_parent,
  129. };
  130. #ifdef CONFIG_UFS_DEBUG
  131. /*
  132. * Print contents of ufs_super_block, useful for debugging
  133. */
  134. static void ufs_print_super_stuff(struct super_block *sb,
  135. struct ufs_super_block_first *usb1,
  136. struct ufs_super_block_second *usb2,
  137. struct ufs_super_block_third *usb3)
  138. {
  139. u32 magic = fs32_to_cpu(sb, usb3->fs_magic);
  140. pr_debug("ufs_print_super_stuff\n");
  141. pr_debug(" magic: 0x%x\n", magic);
  142. if (fs32_to_cpu(sb, usb3->fs_magic) == UFS2_MAGIC) {
  143. pr_debug(" fs_size: %llu\n", (unsigned long long)
  144. fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size));
  145. pr_debug(" fs_dsize: %llu\n", (unsigned long long)
  146. fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize));
  147. pr_debug(" bsize: %u\n",
  148. fs32_to_cpu(sb, usb1->fs_bsize));
  149. pr_debug(" fsize: %u\n",
  150. fs32_to_cpu(sb, usb1->fs_fsize));
  151. pr_debug(" fs_volname: %s\n", usb2->fs_un.fs_u2.fs_volname);
  152. pr_debug(" fs_sblockloc: %llu\n", (unsigned long long)
  153. fs64_to_cpu(sb, usb2->fs_un.fs_u2.fs_sblockloc));
  154. pr_debug(" cs_ndir(No of dirs): %llu\n", (unsigned long long)
  155. fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir));
  156. pr_debug(" cs_nbfree(No of free blocks): %llu\n",
  157. (unsigned long long)
  158. fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_nbfree));
  159. pr_info(" cs_nifree(Num of free inodes): %llu\n",
  160. (unsigned long long)
  161. fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nifree));
  162. pr_info(" cs_nffree(Num of free frags): %llu\n",
  163. (unsigned long long)
  164. fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nffree));
  165. pr_info(" fs_maxsymlinklen: %u\n",
  166. fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen));
  167. } else {
  168. pr_debug(" sblkno: %u\n", fs32_to_cpu(sb, usb1->fs_sblkno));
  169. pr_debug(" cblkno: %u\n", fs32_to_cpu(sb, usb1->fs_cblkno));
  170. pr_debug(" iblkno: %u\n", fs32_to_cpu(sb, usb1->fs_iblkno));
  171. pr_debug(" dblkno: %u\n", fs32_to_cpu(sb, usb1->fs_dblkno));
  172. pr_debug(" cgoffset: %u\n",
  173. fs32_to_cpu(sb, usb1->fs_cgoffset));
  174. pr_debug(" ~cgmask: 0x%x\n",
  175. ~fs32_to_cpu(sb, usb1->fs_cgmask));
  176. pr_debug(" size: %u\n", fs32_to_cpu(sb, usb1->fs_size));
  177. pr_debug(" dsize: %u\n", fs32_to_cpu(sb, usb1->fs_dsize));
  178. pr_debug(" ncg: %u\n", fs32_to_cpu(sb, usb1->fs_ncg));
  179. pr_debug(" bsize: %u\n", fs32_to_cpu(sb, usb1->fs_bsize));
  180. pr_debug(" fsize: %u\n", fs32_to_cpu(sb, usb1->fs_fsize));
  181. pr_debug(" frag: %u\n", fs32_to_cpu(sb, usb1->fs_frag));
  182. pr_debug(" fragshift: %u\n",
  183. fs32_to_cpu(sb, usb1->fs_fragshift));
  184. pr_debug(" ~fmask: %u\n", ~fs32_to_cpu(sb, usb1->fs_fmask));
  185. pr_debug(" fshift: %u\n", fs32_to_cpu(sb, usb1->fs_fshift));
  186. pr_debug(" sbsize: %u\n", fs32_to_cpu(sb, usb1->fs_sbsize));
  187. pr_debug(" spc: %u\n", fs32_to_cpu(sb, usb1->fs_spc));
  188. pr_debug(" cpg: %u\n", fs32_to_cpu(sb, usb1->fs_cpg));
  189. pr_debug(" ipg: %u\n", fs32_to_cpu(sb, usb1->fs_ipg));
  190. pr_debug(" fpg: %u\n", fs32_to_cpu(sb, usb1->fs_fpg));
  191. pr_debug(" csaddr: %u\n", fs32_to_cpu(sb, usb1->fs_csaddr));
  192. pr_debug(" cssize: %u\n", fs32_to_cpu(sb, usb1->fs_cssize));
  193. pr_debug(" cgsize: %u\n", fs32_to_cpu(sb, usb1->fs_cgsize));
  194. pr_debug(" fstodb: %u\n",
  195. fs32_to_cpu(sb, usb1->fs_fsbtodb));
  196. pr_debug(" nrpos: %u\n", fs32_to_cpu(sb, usb3->fs_nrpos));
  197. pr_debug(" ndir %u\n",
  198. fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir));
  199. pr_debug(" nifree %u\n",
  200. fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree));
  201. pr_debug(" nbfree %u\n",
  202. fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree));
  203. pr_debug(" nffree %u\n",
  204. fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree));
  205. }
  206. pr_debug("\n");
  207. }
  208. /*
  209. * Print contents of ufs_cylinder_group, useful for debugging
  210. */
  211. static void ufs_print_cylinder_stuff(struct super_block *sb,
  212. struct ufs_cylinder_group *cg)
  213. {
  214. pr_debug("\nufs_print_cylinder_stuff\n");
  215. pr_debug("size of ucg: %zu\n", sizeof(struct ufs_cylinder_group));
  216. pr_debug(" magic: %x\n", fs32_to_cpu(sb, cg->cg_magic));
  217. pr_debug(" time: %u\n", fs32_to_cpu(sb, cg->cg_time));
  218. pr_debug(" cgx: %u\n", fs32_to_cpu(sb, cg->cg_cgx));
  219. pr_debug(" ncyl: %u\n", fs16_to_cpu(sb, cg->cg_ncyl));
  220. pr_debug(" niblk: %u\n", fs16_to_cpu(sb, cg->cg_niblk));
  221. pr_debug(" ndblk: %u\n", fs32_to_cpu(sb, cg->cg_ndblk));
  222. pr_debug(" cs_ndir: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_ndir));
  223. pr_debug(" cs_nbfree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nbfree));
  224. pr_debug(" cs_nifree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nifree));
  225. pr_debug(" cs_nffree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nffree));
  226. pr_debug(" rotor: %u\n", fs32_to_cpu(sb, cg->cg_rotor));
  227. pr_debug(" frotor: %u\n", fs32_to_cpu(sb, cg->cg_frotor));
  228. pr_debug(" irotor: %u\n", fs32_to_cpu(sb, cg->cg_irotor));
  229. pr_debug(" frsum: %u, %u, %u, %u, %u, %u, %u, %u\n",
  230. fs32_to_cpu(sb, cg->cg_frsum[0]), fs32_to_cpu(sb, cg->cg_frsum[1]),
  231. fs32_to_cpu(sb, cg->cg_frsum[2]), fs32_to_cpu(sb, cg->cg_frsum[3]),
  232. fs32_to_cpu(sb, cg->cg_frsum[4]), fs32_to_cpu(sb, cg->cg_frsum[5]),
  233. fs32_to_cpu(sb, cg->cg_frsum[6]), fs32_to_cpu(sb, cg->cg_frsum[7]));
  234. pr_debug(" btotoff: %u\n", fs32_to_cpu(sb, cg->cg_btotoff));
  235. pr_debug(" boff: %u\n", fs32_to_cpu(sb, cg->cg_boff));
  236. pr_debug(" iuseoff: %u\n", fs32_to_cpu(sb, cg->cg_iusedoff));
  237. pr_debug(" freeoff: %u\n", fs32_to_cpu(sb, cg->cg_freeoff));
  238. pr_debug(" nextfreeoff: %u\n", fs32_to_cpu(sb, cg->cg_nextfreeoff));
  239. pr_debug(" clustersumoff %u\n",
  240. fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clustersumoff));
  241. pr_debug(" clusteroff %u\n",
  242. fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clusteroff));
  243. pr_debug(" nclusterblks %u\n",
  244. fs32_to_cpu(sb, cg->cg_u.cg_44.cg_nclusterblks));
  245. pr_debug("\n");
  246. }
  247. #else
  248. # define ufs_print_super_stuff(sb, usb1, usb2, usb3) /**/
  249. # define ufs_print_cylinder_stuff(sb, cg) /**/
  250. #endif /* CONFIG_UFS_DEBUG */
  251. static const struct super_operations ufs_super_ops;
  252. void ufs_error (struct super_block * sb, const char * function,
  253. const char * fmt, ...)
  254. {
  255. struct ufs_sb_private_info * uspi;
  256. struct ufs_super_block_first * usb1;
  257. struct va_format vaf;
  258. va_list args;
  259. uspi = UFS_SB(sb)->s_uspi;
  260. usb1 = ubh_get_usb_first(uspi);
  261. if (!sb_rdonly(sb)) {
  262. usb1->fs_clean = UFS_FSBAD;
  263. ubh_mark_buffer_dirty(USPI_UBH(uspi));
  264. ufs_mark_sb_dirty(sb);
  265. sb->s_flags |= SB_RDONLY;
  266. }
  267. va_start(args, fmt);
  268. vaf.fmt = fmt;
  269. vaf.va = &args;
  270. switch (UFS_SB(sb)->s_mount_opt & UFS_MOUNT_ONERROR) {
  271. case UFS_MOUNT_ONERROR_PANIC:
  272. panic("panic (device %s): %s: %pV\n",
  273. sb->s_id, function, &vaf);
  274. case UFS_MOUNT_ONERROR_LOCK:
  275. case UFS_MOUNT_ONERROR_UMOUNT:
  276. case UFS_MOUNT_ONERROR_REPAIR:
  277. pr_crit("error (device %s): %s: %pV\n",
  278. sb->s_id, function, &vaf);
  279. }
  280. va_end(args);
  281. }
  282. void ufs_panic (struct super_block * sb, const char * function,
  283. const char * fmt, ...)
  284. {
  285. struct ufs_sb_private_info * uspi;
  286. struct ufs_super_block_first * usb1;
  287. struct va_format vaf;
  288. va_list args;
  289. uspi = UFS_SB(sb)->s_uspi;
  290. usb1 = ubh_get_usb_first(uspi);
  291. if (!sb_rdonly(sb)) {
  292. usb1->fs_clean = UFS_FSBAD;
  293. ubh_mark_buffer_dirty(USPI_UBH(uspi));
  294. ufs_mark_sb_dirty(sb);
  295. }
  296. va_start(args, fmt);
  297. vaf.fmt = fmt;
  298. vaf.va = &args;
  299. sb->s_flags |= SB_RDONLY;
  300. pr_crit("panic (device %s): %s: %pV\n",
  301. sb->s_id, function, &vaf);
  302. va_end(args);
  303. }
  304. void ufs_warning (struct super_block * sb, const char * function,
  305. const char * fmt, ...)
  306. {
  307. struct va_format vaf;
  308. va_list args;
  309. va_start(args, fmt);
  310. vaf.fmt = fmt;
  311. vaf.va = &args;
  312. pr_warn("(device %s): %s: %pV\n",
  313. sb->s_id, function, &vaf);
  314. va_end(args);
  315. }
  316. enum {
  317. Opt_type_old = UFS_MOUNT_UFSTYPE_OLD,
  318. Opt_type_sunx86 = UFS_MOUNT_UFSTYPE_SUNx86,
  319. Opt_type_sun = UFS_MOUNT_UFSTYPE_SUN,
  320. Opt_type_sunos = UFS_MOUNT_UFSTYPE_SUNOS,
  321. Opt_type_44bsd = UFS_MOUNT_UFSTYPE_44BSD,
  322. Opt_type_ufs2 = UFS_MOUNT_UFSTYPE_UFS2,
  323. Opt_type_hp = UFS_MOUNT_UFSTYPE_HP,
  324. Opt_type_nextstepcd = UFS_MOUNT_UFSTYPE_NEXTSTEP_CD,
  325. Opt_type_nextstep = UFS_MOUNT_UFSTYPE_NEXTSTEP,
  326. Opt_type_openstep = UFS_MOUNT_UFSTYPE_OPENSTEP,
  327. Opt_onerror_panic = UFS_MOUNT_ONERROR_PANIC,
  328. Opt_onerror_lock = UFS_MOUNT_ONERROR_LOCK,
  329. Opt_onerror_umount = UFS_MOUNT_ONERROR_UMOUNT,
  330. Opt_onerror_repair = UFS_MOUNT_ONERROR_REPAIR,
  331. Opt_err
  332. };
  333. static const match_table_t tokens = {
  334. {Opt_type_old, "ufstype=old"},
  335. {Opt_type_sunx86, "ufstype=sunx86"},
  336. {Opt_type_sun, "ufstype=sun"},
  337. {Opt_type_sunos, "ufstype=sunos"},
  338. {Opt_type_44bsd, "ufstype=44bsd"},
  339. {Opt_type_ufs2, "ufstype=ufs2"},
  340. {Opt_type_ufs2, "ufstype=5xbsd"},
  341. {Opt_type_hp, "ufstype=hp"},
  342. {Opt_type_nextstepcd, "ufstype=nextstep-cd"},
  343. {Opt_type_nextstep, "ufstype=nextstep"},
  344. {Opt_type_openstep, "ufstype=openstep"},
  345. /*end of possible ufs types */
  346. {Opt_onerror_panic, "onerror=panic"},
  347. {Opt_onerror_lock, "onerror=lock"},
  348. {Opt_onerror_umount, "onerror=umount"},
  349. {Opt_onerror_repair, "onerror=repair"},
  350. {Opt_err, NULL}
  351. };
  352. static int ufs_parse_options (char * options, unsigned * mount_options)
  353. {
  354. char * p;
  355. UFSD("ENTER\n");
  356. if (!options)
  357. return 1;
  358. while ((p = strsep(&options, ",")) != NULL) {
  359. substring_t args[MAX_OPT_ARGS];
  360. int token;
  361. if (!*p)
  362. continue;
  363. token = match_token(p, tokens, args);
  364. switch (token) {
  365. case Opt_type_old:
  366. ufs_clear_opt (*mount_options, UFSTYPE);
  367. ufs_set_opt (*mount_options, UFSTYPE_OLD);
  368. break;
  369. case Opt_type_sunx86:
  370. ufs_clear_opt (*mount_options, UFSTYPE);
  371. ufs_set_opt (*mount_options, UFSTYPE_SUNx86);
  372. break;
  373. case Opt_type_sun:
  374. ufs_clear_opt (*mount_options, UFSTYPE);
  375. ufs_set_opt (*mount_options, UFSTYPE_SUN);
  376. break;
  377. case Opt_type_sunos:
  378. ufs_clear_opt(*mount_options, UFSTYPE);
  379. ufs_set_opt(*mount_options, UFSTYPE_SUNOS);
  380. break;
  381. case Opt_type_44bsd:
  382. ufs_clear_opt (*mount_options, UFSTYPE);
  383. ufs_set_opt (*mount_options, UFSTYPE_44BSD);
  384. break;
  385. case Opt_type_ufs2:
  386. ufs_clear_opt(*mount_options, UFSTYPE);
  387. ufs_set_opt(*mount_options, UFSTYPE_UFS2);
  388. break;
  389. case Opt_type_hp:
  390. ufs_clear_opt (*mount_options, UFSTYPE);
  391. ufs_set_opt (*mount_options, UFSTYPE_HP);
  392. break;
  393. case Opt_type_nextstepcd:
  394. ufs_clear_opt (*mount_options, UFSTYPE);
  395. ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP_CD);
  396. break;
  397. case Opt_type_nextstep:
  398. ufs_clear_opt (*mount_options, UFSTYPE);
  399. ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP);
  400. break;
  401. case Opt_type_openstep:
  402. ufs_clear_opt (*mount_options, UFSTYPE);
  403. ufs_set_opt (*mount_options, UFSTYPE_OPENSTEP);
  404. break;
  405. case Opt_onerror_panic:
  406. ufs_clear_opt (*mount_options, ONERROR);
  407. ufs_set_opt (*mount_options, ONERROR_PANIC);
  408. break;
  409. case Opt_onerror_lock:
  410. ufs_clear_opt (*mount_options, ONERROR);
  411. ufs_set_opt (*mount_options, ONERROR_LOCK);
  412. break;
  413. case Opt_onerror_umount:
  414. ufs_clear_opt (*mount_options, ONERROR);
  415. ufs_set_opt (*mount_options, ONERROR_UMOUNT);
  416. break;
  417. case Opt_onerror_repair:
  418. pr_err("Unable to do repair on error, will lock lock instead\n");
  419. ufs_clear_opt (*mount_options, ONERROR);
  420. ufs_set_opt (*mount_options, ONERROR_REPAIR);
  421. break;
  422. default:
  423. pr_err("Invalid option: \"%s\" or missing value\n", p);
  424. return 0;
  425. }
  426. }
  427. return 1;
  428. }
  429. /*
  430. * Different types of UFS hold fs_cstotal in different
  431. * places, and use different data structure for it.
  432. * To make things simpler we just copy fs_cstotal to ufs_sb_private_info
  433. */
  434. static void ufs_setup_cstotal(struct super_block *sb)
  435. {
  436. struct ufs_sb_info *sbi = UFS_SB(sb);
  437. struct ufs_sb_private_info *uspi = sbi->s_uspi;
  438. struct ufs_super_block_first *usb1;
  439. struct ufs_super_block_second *usb2;
  440. struct ufs_super_block_third *usb3;
  441. unsigned mtype = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE;
  442. UFSD("ENTER, mtype=%u\n", mtype);
  443. usb1 = ubh_get_usb_first(uspi);
  444. usb2 = ubh_get_usb_second(uspi);
  445. usb3 = ubh_get_usb_third(uspi);
  446. if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&
  447. (usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) ||
  448. mtype == UFS_MOUNT_UFSTYPE_UFS2) {
  449. /*we have statistic in different place, then usual*/
  450. uspi->cs_total.cs_ndir = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir);
  451. uspi->cs_total.cs_nbfree = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_nbfree);
  452. uspi->cs_total.cs_nifree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nifree);
  453. uspi->cs_total.cs_nffree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nffree);
  454. } else {
  455. uspi->cs_total.cs_ndir = fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir);
  456. uspi->cs_total.cs_nbfree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree);
  457. uspi->cs_total.cs_nifree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree);
  458. uspi->cs_total.cs_nffree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree);
  459. }
  460. UFSD("EXIT\n");
  461. }
  462. /*
  463. * Read on-disk structures associated with cylinder groups
  464. */
  465. static int ufs_read_cylinder_structures(struct super_block *sb)
  466. {
  467. struct ufs_sb_info *sbi = UFS_SB(sb);
  468. struct ufs_sb_private_info *uspi = sbi->s_uspi;
  469. struct ufs_buffer_head * ubh;
  470. unsigned char * base, * space;
  471. unsigned size, blks, i;
  472. UFSD("ENTER\n");
  473. /*
  474. * Read cs structures from (usually) first data block
  475. * on the device.
  476. */
  477. size = uspi->s_cssize;
  478. blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
  479. base = space = kmalloc(size, GFP_NOFS);
  480. if (!base)
  481. goto failed;
  482. sbi->s_csp = (struct ufs_csum *)space;
  483. for (i = 0; i < blks; i += uspi->s_fpb) {
  484. size = uspi->s_bsize;
  485. if (i + uspi->s_fpb > blks)
  486. size = (blks - i) * uspi->s_fsize;
  487. ubh = ubh_bread(sb, uspi->s_csaddr + i, size);
  488. if (!ubh)
  489. goto failed;
  490. ubh_ubhcpymem (space, ubh, size);
  491. space += size;
  492. ubh_brelse (ubh);
  493. ubh = NULL;
  494. }
  495. /*
  496. * Read cylinder group (we read only first fragment from block
  497. * at this time) and prepare internal data structures for cg caching.
  498. */
  499. sbi->s_ucg = kmalloc_array(uspi->s_ncg, sizeof(struct buffer_head *),
  500. GFP_NOFS);
  501. if (!sbi->s_ucg)
  502. goto failed;
  503. for (i = 0; i < uspi->s_ncg; i++)
  504. sbi->s_ucg[i] = NULL;
  505. for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
  506. sbi->s_ucpi[i] = NULL;
  507. sbi->s_cgno[i] = UFS_CGNO_EMPTY;
  508. }
  509. for (i = 0; i < uspi->s_ncg; i++) {
  510. UFSD("read cg %u\n", i);
  511. if (!(sbi->s_ucg[i] = sb_bread(sb, ufs_cgcmin(i))))
  512. goto failed;
  513. if (!ufs_cg_chkmagic (sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data))
  514. goto failed;
  515. ufs_print_cylinder_stuff(sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data);
  516. }
  517. for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
  518. if (!(sbi->s_ucpi[i] = kmalloc (sizeof(struct ufs_cg_private_info), GFP_NOFS)))
  519. goto failed;
  520. sbi->s_cgno[i] = UFS_CGNO_EMPTY;
  521. }
  522. sbi->s_cg_loaded = 0;
  523. UFSD("EXIT\n");
  524. return 1;
  525. failed:
  526. kfree (base);
  527. if (sbi->s_ucg) {
  528. for (i = 0; i < uspi->s_ncg; i++)
  529. if (sbi->s_ucg[i])
  530. brelse (sbi->s_ucg[i]);
  531. kfree (sbi->s_ucg);
  532. for (i = 0; i < UFS_MAX_GROUP_LOADED; i++)
  533. kfree (sbi->s_ucpi[i]);
  534. }
  535. UFSD("EXIT (FAILED)\n");
  536. return 0;
  537. }
  538. /*
  539. * Sync our internal copy of fs_cstotal with disk
  540. */
  541. static void ufs_put_cstotal(struct super_block *sb)
  542. {
  543. unsigned mtype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE;
  544. struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
  545. struct ufs_super_block_first *usb1;
  546. struct ufs_super_block_second *usb2;
  547. struct ufs_super_block_third *usb3;
  548. UFSD("ENTER\n");
  549. usb1 = ubh_get_usb_first(uspi);
  550. usb2 = ubh_get_usb_second(uspi);
  551. usb3 = ubh_get_usb_third(uspi);
  552. if (mtype == UFS_MOUNT_UFSTYPE_UFS2) {
  553. /*we have statistic in different place, then usual*/
  554. usb2->fs_un.fs_u2.cs_ndir =
  555. cpu_to_fs64(sb, uspi->cs_total.cs_ndir);
  556. usb2->fs_un.fs_u2.cs_nbfree =
  557. cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);
  558. usb3->fs_un1.fs_u2.cs_nifree =
  559. cpu_to_fs64(sb, uspi->cs_total.cs_nifree);
  560. usb3->fs_un1.fs_u2.cs_nffree =
  561. cpu_to_fs64(sb, uspi->cs_total.cs_nffree);
  562. goto out;
  563. }
  564. if (mtype == UFS_MOUNT_UFSTYPE_44BSD &&
  565. (usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) {
  566. /* store stats in both old and new places */
  567. usb2->fs_un.fs_u2.cs_ndir =
  568. cpu_to_fs64(sb, uspi->cs_total.cs_ndir);
  569. usb2->fs_un.fs_u2.cs_nbfree =
  570. cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);
  571. usb3->fs_un1.fs_u2.cs_nifree =
  572. cpu_to_fs64(sb, uspi->cs_total.cs_nifree);
  573. usb3->fs_un1.fs_u2.cs_nffree =
  574. cpu_to_fs64(sb, uspi->cs_total.cs_nffree);
  575. }
  576. usb1->fs_cstotal.cs_ndir = cpu_to_fs32(sb, uspi->cs_total.cs_ndir);
  577. usb1->fs_cstotal.cs_nbfree = cpu_to_fs32(sb, uspi->cs_total.cs_nbfree);
  578. usb1->fs_cstotal.cs_nifree = cpu_to_fs32(sb, uspi->cs_total.cs_nifree);
  579. usb1->fs_cstotal.cs_nffree = cpu_to_fs32(sb, uspi->cs_total.cs_nffree);
  580. out:
  581. ubh_mark_buffer_dirty(USPI_UBH(uspi));
  582. ufs_print_super_stuff(sb, usb1, usb2, usb3);
  583. UFSD("EXIT\n");
  584. }
  585. /**
  586. * ufs_put_super_internal() - put on-disk intrenal structures
  587. * @sb: pointer to super_block structure
  588. * Put on-disk structures associated with cylinder groups
  589. * and write them back to disk, also update cs_total on disk
  590. */
  591. static void ufs_put_super_internal(struct super_block *sb)
  592. {
  593. struct ufs_sb_info *sbi = UFS_SB(sb);
  594. struct ufs_sb_private_info *uspi = sbi->s_uspi;
  595. struct ufs_buffer_head * ubh;
  596. unsigned char * base, * space;
  597. unsigned blks, size, i;
  598. UFSD("ENTER\n");
  599. ufs_put_cstotal(sb);
  600. size = uspi->s_cssize;
  601. blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
  602. base = space = (char*) sbi->s_csp;
  603. for (i = 0; i < blks; i += uspi->s_fpb) {
  604. size = uspi->s_bsize;
  605. if (i + uspi->s_fpb > blks)
  606. size = (blks - i) * uspi->s_fsize;
  607. ubh = ubh_bread(sb, uspi->s_csaddr + i, size);
  608. ubh_memcpyubh (ubh, space, size);
  609. space += size;
  610. ubh_mark_buffer_uptodate (ubh, 1);
  611. ubh_mark_buffer_dirty (ubh);
  612. ubh_brelse (ubh);
  613. }
  614. for (i = 0; i < sbi->s_cg_loaded; i++) {
  615. ufs_put_cylinder (sb, i);
  616. kfree (sbi->s_ucpi[i]);
  617. }
  618. for (; i < UFS_MAX_GROUP_LOADED; i++)
  619. kfree (sbi->s_ucpi[i]);
  620. for (i = 0; i < uspi->s_ncg; i++)
  621. brelse (sbi->s_ucg[i]);
  622. kfree (sbi->s_ucg);
  623. kfree (base);
  624. UFSD("EXIT\n");
  625. }
  626. static int ufs_sync_fs(struct super_block *sb, int wait)
  627. {
  628. struct ufs_sb_private_info * uspi;
  629. struct ufs_super_block_first * usb1;
  630. struct ufs_super_block_third * usb3;
  631. unsigned flags;
  632. mutex_lock(&UFS_SB(sb)->s_lock);
  633. UFSD("ENTER\n");
  634. flags = UFS_SB(sb)->s_flags;
  635. uspi = UFS_SB(sb)->s_uspi;
  636. usb1 = ubh_get_usb_first(uspi);
  637. usb3 = ubh_get_usb_third(uspi);
  638. usb1->fs_time = ufs_get_seconds(sb);
  639. if ((flags & UFS_ST_MASK) == UFS_ST_SUN ||
  640. (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
  641. (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
  642. ufs_set_fs_state(sb, usb1, usb3,
  643. UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
  644. ufs_put_cstotal(sb);
  645. UFSD("EXIT\n");
  646. mutex_unlock(&UFS_SB(sb)->s_lock);
  647. return 0;
  648. }
  649. static void delayed_sync_fs(struct work_struct *work)
  650. {
  651. struct ufs_sb_info *sbi;
  652. sbi = container_of(work, struct ufs_sb_info, sync_work.work);
  653. spin_lock(&sbi->work_lock);
  654. sbi->work_queued = 0;
  655. spin_unlock(&sbi->work_lock);
  656. ufs_sync_fs(sbi->sb, 1);
  657. }
  658. void ufs_mark_sb_dirty(struct super_block *sb)
  659. {
  660. struct ufs_sb_info *sbi = UFS_SB(sb);
  661. unsigned long delay;
  662. spin_lock(&sbi->work_lock);
  663. if (!sbi->work_queued) {
  664. delay = msecs_to_jiffies(dirty_writeback_interval * 10);
  665. queue_delayed_work(system_long_wq, &sbi->sync_work, delay);
  666. sbi->work_queued = 1;
  667. }
  668. spin_unlock(&sbi->work_lock);
  669. }
  670. static void ufs_put_super(struct super_block *sb)
  671. {
  672. struct ufs_sb_info * sbi = UFS_SB(sb);
  673. UFSD("ENTER\n");
  674. if (!sb_rdonly(sb))
  675. ufs_put_super_internal(sb);
  676. cancel_delayed_work_sync(&sbi->sync_work);
  677. ubh_brelse_uspi (sbi->s_uspi);
  678. kfree (sbi->s_uspi);
  679. kfree (sbi);
  680. sb->s_fs_info = NULL;
  681. UFSD("EXIT\n");
  682. return;
  683. }
  684. static u64 ufs_max_bytes(struct super_block *sb)
  685. {
  686. struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
  687. int bits = uspi->s_apbshift;
  688. u64 res;
  689. if (bits > 21)
  690. res = ~0ULL;
  691. else
  692. res = UFS_NDADDR + (1LL << bits) + (1LL << (2*bits)) +
  693. (1LL << (3*bits));
  694. if (res >= (MAX_LFS_FILESIZE >> uspi->s_bshift))
  695. return MAX_LFS_FILESIZE;
  696. return res << uspi->s_bshift;
  697. }
  698. static int ufs_fill_super(struct super_block *sb, void *data, int silent)
  699. {
  700. struct ufs_sb_info * sbi;
  701. struct ufs_sb_private_info * uspi;
  702. struct ufs_super_block_first * usb1;
  703. struct ufs_super_block_second * usb2;
  704. struct ufs_super_block_third * usb3;
  705. struct ufs_buffer_head * ubh;
  706. struct inode *inode;
  707. unsigned block_size, super_block_size;
  708. unsigned flags;
  709. unsigned super_block_offset;
  710. unsigned maxsymlen;
  711. int ret = -EINVAL;
  712. uspi = NULL;
  713. ubh = NULL;
  714. flags = 0;
  715. UFSD("ENTER\n");
  716. #ifndef CONFIG_UFS_FS_WRITE
  717. if (!sb_rdonly(sb)) {
  718. pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
  719. return -EROFS;
  720. }
  721. #endif
  722. sbi = kzalloc(sizeof(struct ufs_sb_info), GFP_KERNEL);
  723. if (!sbi)
  724. goto failed_nomem;
  725. sb->s_fs_info = sbi;
  726. sbi->sb = sb;
  727. UFSD("flag %u\n", (int)(sb_rdonly(sb)));
  728. mutex_init(&sbi->s_lock);
  729. spin_lock_init(&sbi->work_lock);
  730. INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs);
  731. /*
  732. * Set default mount options
  733. * Parse mount options
  734. */
  735. sbi->s_mount_opt = 0;
  736. ufs_set_opt (sbi->s_mount_opt, ONERROR_LOCK);
  737. if (!ufs_parse_options ((char *) data, &sbi->s_mount_opt)) {
  738. pr_err("wrong mount options\n");
  739. goto failed;
  740. }
  741. if (!(sbi->s_mount_opt & UFS_MOUNT_UFSTYPE)) {
  742. if (!silent)
  743. pr_err("You didn't specify the type of your ufs filesystem\n\n"
  744. "mount -t ufs -o ufstype="
  745. "sun|sunx86|44bsd|ufs2|5xbsd|old|hp|nextstep|nextstep-cd|openstep ...\n\n"
  746. ">>>WARNING<<< Wrong ufstype may corrupt your filesystem, "
  747. "default is ufstype=old\n");
  748. ufs_set_opt (sbi->s_mount_opt, UFSTYPE_OLD);
  749. }
  750. uspi = kzalloc(sizeof(struct ufs_sb_private_info), GFP_KERNEL);
  751. sbi->s_uspi = uspi;
  752. if (!uspi)
  753. goto failed;
  754. uspi->s_dirblksize = UFS_SECTOR_SIZE;
  755. super_block_offset=UFS_SBLOCK;
  756. sb->s_maxbytes = MAX_LFS_FILESIZE;
  757. sb->s_time_gran = NSEC_PER_SEC;
  758. sb->s_time_min = S32_MIN;
  759. sb->s_time_max = S32_MAX;
  760. switch (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) {
  761. case UFS_MOUNT_UFSTYPE_44BSD:
  762. UFSD("ufstype=44bsd\n");
  763. uspi->s_fsize = block_size = 512;
  764. uspi->s_fmask = ~(512 - 1);
  765. uspi->s_fshift = 9;
  766. uspi->s_sbsize = super_block_size = 1536;
  767. uspi->s_sbbase = 0;
  768. flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
  769. break;
  770. case UFS_MOUNT_UFSTYPE_UFS2:
  771. UFSD("ufstype=ufs2\n");
  772. super_block_offset=SBLOCK_UFS2;
  773. uspi->s_fsize = block_size = 512;
  774. uspi->s_fmask = ~(512 - 1);
  775. uspi->s_fshift = 9;
  776. uspi->s_sbsize = super_block_size = 1536;
  777. uspi->s_sbbase = 0;
  778. sb->s_time_gran = 1;
  779. sb->s_time_min = S64_MIN;
  780. sb->s_time_max = S64_MAX;
  781. flags |= UFS_TYPE_UFS2 | UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
  782. break;
  783. case UFS_MOUNT_UFSTYPE_SUN:
  784. UFSD("ufstype=sun\n");
  785. uspi->s_fsize = block_size = 1024;
  786. uspi->s_fmask = ~(1024 - 1);
  787. uspi->s_fshift = 10;
  788. uspi->s_sbsize = super_block_size = 2048;
  789. uspi->s_sbbase = 0;
  790. uspi->s_maxsymlinklen = 0; /* Not supported on disk */
  791. flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUN | UFS_CG_SUN;
  792. break;
  793. case UFS_MOUNT_UFSTYPE_SUNOS:
  794. UFSD("ufstype=sunos\n");
  795. uspi->s_fsize = block_size = 1024;
  796. uspi->s_fmask = ~(1024 - 1);
  797. uspi->s_fshift = 10;
  798. uspi->s_sbsize = 2048;
  799. super_block_size = 2048;
  800. uspi->s_sbbase = 0;
  801. uspi->s_maxsymlinklen = 0; /* Not supported on disk */
  802. flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_SUNOS | UFS_CG_SUN;
  803. break;
  804. case UFS_MOUNT_UFSTYPE_SUNx86:
  805. UFSD("ufstype=sunx86\n");
  806. uspi->s_fsize = block_size = 1024;
  807. uspi->s_fmask = ~(1024 - 1);
  808. uspi->s_fshift = 10;
  809. uspi->s_sbsize = super_block_size = 2048;
  810. uspi->s_sbbase = 0;
  811. uspi->s_maxsymlinklen = 0; /* Not supported on disk */
  812. flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUNx86 | UFS_CG_SUN;
  813. break;
  814. case UFS_MOUNT_UFSTYPE_OLD:
  815. UFSD("ufstype=old\n");
  816. uspi->s_fsize = block_size = 1024;
  817. uspi->s_fmask = ~(1024 - 1);
  818. uspi->s_fshift = 10;
  819. uspi->s_sbsize = super_block_size = 2048;
  820. uspi->s_sbbase = 0;
  821. flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
  822. if (!sb_rdonly(sb)) {
  823. if (!silent)
  824. pr_info("ufstype=old is supported read-only\n");
  825. sb->s_flags |= SB_RDONLY;
  826. }
  827. break;
  828. case UFS_MOUNT_UFSTYPE_NEXTSTEP:
  829. UFSD("ufstype=nextstep\n");
  830. uspi->s_fsize = block_size = 1024;
  831. uspi->s_fmask = ~(1024 - 1);
  832. uspi->s_fshift = 10;
  833. uspi->s_sbsize = super_block_size = 2048;
  834. uspi->s_sbbase = 0;
  835. uspi->s_dirblksize = 1024;
  836. flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
  837. if (!sb_rdonly(sb)) {
  838. if (!silent)
  839. pr_info("ufstype=nextstep is supported read-only\n");
  840. sb->s_flags |= SB_RDONLY;
  841. }
  842. break;
  843. case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD:
  844. UFSD("ufstype=nextstep-cd\n");
  845. uspi->s_fsize = block_size = 2048;
  846. uspi->s_fmask = ~(2048 - 1);
  847. uspi->s_fshift = 11;
  848. uspi->s_sbsize = super_block_size = 2048;
  849. uspi->s_sbbase = 0;
  850. uspi->s_dirblksize = 1024;
  851. flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
  852. if (!sb_rdonly(sb)) {
  853. if (!silent)
  854. pr_info("ufstype=nextstep-cd is supported read-only\n");
  855. sb->s_flags |= SB_RDONLY;
  856. }
  857. break;
  858. case UFS_MOUNT_UFSTYPE_OPENSTEP:
  859. UFSD("ufstype=openstep\n");
  860. uspi->s_fsize = block_size = 1024;
  861. uspi->s_fmask = ~(1024 - 1);
  862. uspi->s_fshift = 10;
  863. uspi->s_sbsize = super_block_size = 2048;
  864. uspi->s_sbbase = 0;
  865. uspi->s_dirblksize = 1024;
  866. flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
  867. if (!sb_rdonly(sb)) {
  868. if (!silent)
  869. pr_info("ufstype=openstep is supported read-only\n");
  870. sb->s_flags |= SB_RDONLY;
  871. }
  872. break;
  873. case UFS_MOUNT_UFSTYPE_HP:
  874. UFSD("ufstype=hp\n");
  875. uspi->s_fsize = block_size = 1024;
  876. uspi->s_fmask = ~(1024 - 1);
  877. uspi->s_fshift = 10;
  878. uspi->s_sbsize = super_block_size = 2048;
  879. uspi->s_sbbase = 0;
  880. flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
  881. if (!sb_rdonly(sb)) {
  882. if (!silent)
  883. pr_info("ufstype=hp is supported read-only\n");
  884. sb->s_flags |= SB_RDONLY;
  885. }
  886. break;
  887. default:
  888. if (!silent)
  889. pr_err("unknown ufstype\n");
  890. goto failed;
  891. }
  892. again:
  893. if (!sb_set_blocksize(sb, block_size)) {
  894. pr_err("failed to set blocksize\n");
  895. goto failed;
  896. }
  897. /*
  898. * read ufs super block from device
  899. */
  900. ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size);
  901. if (!ubh)
  902. goto failed;
  903. usb1 = ubh_get_usb_first(uspi);
  904. usb2 = ubh_get_usb_second(uspi);
  905. usb3 = ubh_get_usb_third(uspi);
  906. /* Sort out mod used on SunOS 4.1.3 for fs_state */
  907. uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);
  908. if (((flags & UFS_ST_MASK) == UFS_ST_SUNOS) &&
  909. (uspi->s_postblformat != UFS_42POSTBLFMT)) {
  910. flags &= ~UFS_ST_MASK;
  911. flags |= UFS_ST_SUN;
  912. }
  913. if ((flags & UFS_ST_MASK) == UFS_ST_44BSD &&
  914. uspi->s_postblformat == UFS_42POSTBLFMT) {
  915. if (!silent)
  916. pr_err("this is not a 44bsd filesystem");
  917. goto failed;
  918. }
  919. /*
  920. * Check ufs magic number
  921. */
  922. sbi->s_bytesex = BYTESEX_LE;
  923. switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
  924. case UFS_MAGIC:
  925. case UFS_MAGIC_BW:
  926. case UFS2_MAGIC:
  927. case UFS_MAGIC_LFN:
  928. case UFS_MAGIC_FEA:
  929. case UFS_MAGIC_4GB:
  930. goto magic_found;
  931. }
  932. sbi->s_bytesex = BYTESEX_BE;
  933. switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
  934. case UFS_MAGIC:
  935. case UFS_MAGIC_BW:
  936. case UFS2_MAGIC:
  937. case UFS_MAGIC_LFN:
  938. case UFS_MAGIC_FEA:
  939. case UFS_MAGIC_4GB:
  940. goto magic_found;
  941. }
  942. if ((((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP)
  943. || ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD)
  944. || ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_OPENSTEP))
  945. && uspi->s_sbbase < 256) {
  946. ubh_brelse_uspi(uspi);
  947. ubh = NULL;
  948. uspi->s_sbbase += 8;
  949. goto again;
  950. }
  951. if (!silent)
  952. pr_err("%s(): bad magic number\n", __func__);
  953. goto failed;
  954. magic_found:
  955. /*
  956. * Check block and fragment sizes
  957. */
  958. uspi->s_bsize = fs32_to_cpu(sb, usb1->fs_bsize);
  959. uspi->s_fsize = fs32_to_cpu(sb, usb1->fs_fsize);
  960. uspi->s_sbsize = fs32_to_cpu(sb, usb1->fs_sbsize);
  961. uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
  962. uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
  963. if (!is_power_of_2(uspi->s_fsize)) {
  964. pr_err("%s(): fragment size %u is not a power of 2\n",
  965. __func__, uspi->s_fsize);
  966. goto failed;
  967. }
  968. if (uspi->s_fsize < 512) {
  969. pr_err("%s(): fragment size %u is too small\n",
  970. __func__, uspi->s_fsize);
  971. goto failed;
  972. }
  973. if (uspi->s_fsize > 4096) {
  974. pr_err("%s(): fragment size %u is too large\n",
  975. __func__, uspi->s_fsize);
  976. goto failed;
  977. }
  978. if (!is_power_of_2(uspi->s_bsize)) {
  979. pr_err("%s(): block size %u is not a power of 2\n",
  980. __func__, uspi->s_bsize);
  981. goto failed;
  982. }
  983. if (uspi->s_bsize < 4096) {
  984. pr_err("%s(): block size %u is too small\n",
  985. __func__, uspi->s_bsize);
  986. goto failed;
  987. }
  988. if (uspi->s_bsize / uspi->s_fsize > 8) {
  989. pr_err("%s(): too many fragments per block (%u)\n",
  990. __func__, uspi->s_bsize / uspi->s_fsize);
  991. goto failed;
  992. }
  993. if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) {
  994. ubh_brelse_uspi(uspi);
  995. ubh = NULL;
  996. block_size = uspi->s_fsize;
  997. super_block_size = uspi->s_sbsize;
  998. UFSD("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size);
  999. goto again;
  1000. }
  1001. sbi->s_flags = flags;/*after that line some functions use s_flags*/
  1002. ufs_print_super_stuff(sb, usb1, usb2, usb3);
  1003. /*
  1004. * Check, if file system was correctly unmounted.
  1005. * If not, make it read only.
  1006. */
  1007. if (((flags & UFS_ST_MASK) == UFS_ST_44BSD) ||
  1008. ((flags & UFS_ST_MASK) == UFS_ST_OLD) ||
  1009. (((flags & UFS_ST_MASK) == UFS_ST_SUN ||
  1010. (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
  1011. (flags & UFS_ST_MASK) == UFS_ST_SUNx86) &&
  1012. (ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time))))) {
  1013. switch(usb1->fs_clean) {
  1014. case UFS_FSCLEAN:
  1015. UFSD("fs is clean\n");
  1016. break;
  1017. case UFS_FSSTABLE:
  1018. UFSD("fs is stable\n");
  1019. break;
  1020. case UFS_FSLOG:
  1021. UFSD("fs is logging fs\n");
  1022. break;
  1023. case UFS_FSOSF1:
  1024. UFSD("fs is DEC OSF/1\n");
  1025. break;
  1026. case UFS_FSACTIVE:
  1027. pr_err("%s(): fs is active\n", __func__);
  1028. sb->s_flags |= SB_RDONLY;
  1029. break;
  1030. case UFS_FSBAD:
  1031. pr_err("%s(): fs is bad\n", __func__);
  1032. sb->s_flags |= SB_RDONLY;
  1033. break;
  1034. default:
  1035. pr_err("%s(): can't grok fs_clean 0x%x\n",
  1036. __func__, usb1->fs_clean);
  1037. sb->s_flags |= SB_RDONLY;
  1038. break;
  1039. }
  1040. } else {
  1041. pr_err("%s(): fs needs fsck\n", __func__);
  1042. sb->s_flags |= SB_RDONLY;
  1043. }
  1044. /*
  1045. * Read ufs_super_block into internal data structures
  1046. */
  1047. sb->s_op = &ufs_super_ops;
  1048. sb->s_export_op = &ufs_export_ops;
  1049. sb->s_magic = fs32_to_cpu(sb, usb3->fs_magic);
  1050. uspi->s_sblkno = fs32_to_cpu(sb, usb1->fs_sblkno);
  1051. uspi->s_cblkno = fs32_to_cpu(sb, usb1->fs_cblkno);
  1052. uspi->s_iblkno = fs32_to_cpu(sb, usb1->fs_iblkno);
  1053. uspi->s_dblkno = fs32_to_cpu(sb, usb1->fs_dblkno);
  1054. uspi->s_cgoffset = fs32_to_cpu(sb, usb1->fs_cgoffset);
  1055. uspi->s_cgmask = fs32_to_cpu(sb, usb1->fs_cgmask);
  1056. if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
  1057. uspi->s_size = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size);
  1058. uspi->s_dsize = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);
  1059. } else {
  1060. uspi->s_size = fs32_to_cpu(sb, usb1->fs_size);
  1061. uspi->s_dsize = fs32_to_cpu(sb, usb1->fs_dsize);
  1062. }
  1063. uspi->s_ncg = fs32_to_cpu(sb, usb1->fs_ncg);
  1064. /* s_bsize already set */
  1065. /* s_fsize already set */
  1066. uspi->s_fpb = fs32_to_cpu(sb, usb1->fs_frag);
  1067. uspi->s_minfree = fs32_to_cpu(sb, usb1->fs_minfree);
  1068. uspi->s_bmask = fs32_to_cpu(sb, usb1->fs_bmask);
  1069. uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
  1070. uspi->s_bshift = fs32_to_cpu(sb, usb1->fs_bshift);
  1071. uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
  1072. UFSD("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi->s_bshift,
  1073. uspi->s_fshift);
  1074. uspi->s_fpbshift = fs32_to_cpu(sb, usb1->fs_fragshift);
  1075. uspi->s_fsbtodb = fs32_to_cpu(sb, usb1->fs_fsbtodb);
  1076. /* s_sbsize already set */
  1077. uspi->s_csmask = fs32_to_cpu(sb, usb1->fs_csmask);
  1078. uspi->s_csshift = fs32_to_cpu(sb, usb1->fs_csshift);
  1079. uspi->s_nindir = fs32_to_cpu(sb, usb1->fs_nindir);
  1080. uspi->s_inopb = fs32_to_cpu(sb, usb1->fs_inopb);
  1081. uspi->s_nspf = fs32_to_cpu(sb, usb1->fs_nspf);
  1082. uspi->s_npsect = ufs_get_fs_npsect(sb, usb1, usb3);
  1083. uspi->s_interleave = fs32_to_cpu(sb, usb1->fs_interleave);
  1084. uspi->s_trackskew = fs32_to_cpu(sb, usb1->fs_trackskew);
  1085. if (uspi->fs_magic == UFS2_MAGIC)
  1086. uspi->s_csaddr = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_csaddr);
  1087. else
  1088. uspi->s_csaddr = fs32_to_cpu(sb, usb1->fs_csaddr);
  1089. uspi->s_cssize = fs32_to_cpu(sb, usb1->fs_cssize);
  1090. uspi->s_cgsize = fs32_to_cpu(sb, usb1->fs_cgsize);
  1091. uspi->s_ntrak = fs32_to_cpu(sb, usb1->fs_ntrak);
  1092. uspi->s_nsect = fs32_to_cpu(sb, usb1->fs_nsect);
  1093. uspi->s_spc = fs32_to_cpu(sb, usb1->fs_spc);
  1094. uspi->s_ipg = fs32_to_cpu(sb, usb1->fs_ipg);
  1095. uspi->s_fpg = fs32_to_cpu(sb, usb1->fs_fpg);
  1096. uspi->s_cpc = fs32_to_cpu(sb, usb2->fs_un.fs_u1.fs_cpc);
  1097. uspi->s_contigsumsize = fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_contigsumsize);
  1098. uspi->s_qbmask = ufs_get_fs_qbmask(sb, usb3);
  1099. uspi->s_qfmask = ufs_get_fs_qfmask(sb, usb3);
  1100. uspi->s_nrpos = fs32_to_cpu(sb, usb3->fs_nrpos);
  1101. uspi->s_postbloff = fs32_to_cpu(sb, usb3->fs_postbloff);
  1102. uspi->s_rotbloff = fs32_to_cpu(sb, usb3->fs_rotbloff);
  1103. uspi->s_root_blocks = mul_u64_u32_div(uspi->s_dsize,
  1104. uspi->s_minfree, 100);
  1105. if (uspi->s_minfree <= 5) {
  1106. uspi->s_time_to_space = ~0ULL;
  1107. uspi->s_space_to_time = 0;
  1108. usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTSPACE);
  1109. } else {
  1110. uspi->s_time_to_space = (uspi->s_root_blocks / 2) + 1;
  1111. uspi->s_space_to_time = mul_u64_u32_div(uspi->s_dsize,
  1112. uspi->s_minfree - 2, 100) - 1;
  1113. }
  1114. /*
  1115. * Compute another frequently used values
  1116. */
  1117. uspi->s_fpbmask = uspi->s_fpb - 1;
  1118. if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
  1119. uspi->s_apbshift = uspi->s_bshift - 3;
  1120. else
  1121. uspi->s_apbshift = uspi->s_bshift - 2;
  1122. uspi->s_2apbshift = uspi->s_apbshift * 2;
  1123. uspi->s_3apbshift = uspi->s_apbshift * 3;
  1124. uspi->s_apb = 1 << uspi->s_apbshift;
  1125. uspi->s_2apb = 1 << uspi->s_2apbshift;
  1126. uspi->s_3apb = 1 << uspi->s_3apbshift;
  1127. uspi->s_apbmask = uspi->s_apb - 1;
  1128. uspi->s_nspfshift = uspi->s_fshift - UFS_SECTOR_BITS;
  1129. uspi->s_nspb = uspi->s_nspf << uspi->s_fpbshift;
  1130. uspi->s_inopf = uspi->s_inopb >> uspi->s_fpbshift;
  1131. uspi->s_bpf = uspi->s_fsize << 3;
  1132. uspi->s_bpfshift = uspi->s_fshift + 3;
  1133. uspi->s_bpfmask = uspi->s_bpf - 1;
  1134. if ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_44BSD ||
  1135. (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_UFS2)
  1136. uspi->s_maxsymlinklen =
  1137. fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen);
  1138. if (uspi->fs_magic == UFS2_MAGIC)
  1139. maxsymlen = 2 * 4 * (UFS_NDADDR + UFS_NINDIR);
  1140. else
  1141. maxsymlen = 4 * (UFS_NDADDR + UFS_NINDIR);
  1142. if (uspi->s_maxsymlinklen > maxsymlen) {
  1143. ufs_warning(sb, __func__, "ufs_read_super: excessive maximum "
  1144. "fast symlink size (%u)\n", uspi->s_maxsymlinklen);
  1145. uspi->s_maxsymlinklen = maxsymlen;
  1146. }
  1147. sb->s_maxbytes = ufs_max_bytes(sb);
  1148. sb->s_max_links = UFS_LINK_MAX;
  1149. inode = ufs_iget(sb, UFS_ROOTINO);
  1150. if (IS_ERR(inode)) {
  1151. ret = PTR_ERR(inode);
  1152. goto failed;
  1153. }
  1154. sb->s_root = d_make_root(inode);
  1155. if (!sb->s_root) {
  1156. ret = -ENOMEM;
  1157. goto failed;
  1158. }
  1159. ufs_setup_cstotal(sb);
  1160. /*
  1161. * Read cylinder group structures
  1162. */
  1163. if (!sb_rdonly(sb))
  1164. if (!ufs_read_cylinder_structures(sb))
  1165. goto failed;
  1166. UFSD("EXIT\n");
  1167. return 0;
  1168. failed:
  1169. if (ubh)
  1170. ubh_brelse_uspi (uspi);
  1171. kfree (uspi);
  1172. kfree(sbi);
  1173. sb->s_fs_info = NULL;
  1174. UFSD("EXIT (FAILED)\n");
  1175. return ret;
  1176. failed_nomem:
  1177. UFSD("EXIT (NOMEM)\n");
  1178. return -ENOMEM;
  1179. }
  1180. static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
  1181. {
  1182. struct ufs_sb_private_info * uspi;
  1183. struct ufs_super_block_first * usb1;
  1184. struct ufs_super_block_third * usb3;
  1185. unsigned new_mount_opt, ufstype;
  1186. unsigned flags;
  1187. sync_filesystem(sb);
  1188. mutex_lock(&UFS_SB(sb)->s_lock);
  1189. uspi = UFS_SB(sb)->s_uspi;
  1190. flags = UFS_SB(sb)->s_flags;
  1191. usb1 = ubh_get_usb_first(uspi);
  1192. usb3 = ubh_get_usb_third(uspi);
  1193. /*
  1194. * Allow the "check" option to be passed as a remount option.
  1195. * It is not possible to change ufstype option during remount
  1196. */
  1197. ufstype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE;
  1198. new_mount_opt = 0;
  1199. ufs_set_opt (new_mount_opt, ONERROR_LOCK);
  1200. if (!ufs_parse_options (data, &new_mount_opt)) {
  1201. mutex_unlock(&UFS_SB(sb)->s_lock);
  1202. return -EINVAL;
  1203. }
  1204. if (!(new_mount_opt & UFS_MOUNT_UFSTYPE)) {
  1205. new_mount_opt |= ufstype;
  1206. } else if ((new_mount_opt & UFS_MOUNT_UFSTYPE) != ufstype) {
  1207. pr_err("ufstype can't be changed during remount\n");
  1208. mutex_unlock(&UFS_SB(sb)->s_lock);
  1209. return -EINVAL;
  1210. }
  1211. if ((bool)(*mount_flags & SB_RDONLY) == sb_rdonly(sb)) {
  1212. UFS_SB(sb)->s_mount_opt = new_mount_opt;
  1213. mutex_unlock(&UFS_SB(sb)->s_lock);
  1214. return 0;
  1215. }
  1216. /*
  1217. * fs was mouted as rw, remounting ro
  1218. */
  1219. if (*mount_flags & SB_RDONLY) {
  1220. ufs_put_super_internal(sb);
  1221. usb1->fs_time = ufs_get_seconds(sb);
  1222. if ((flags & UFS_ST_MASK) == UFS_ST_SUN
  1223. || (flags & UFS_ST_MASK) == UFS_ST_SUNOS
  1224. || (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
  1225. ufs_set_fs_state(sb, usb1, usb3,
  1226. UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
  1227. ubh_mark_buffer_dirty (USPI_UBH(uspi));
  1228. sb->s_flags |= SB_RDONLY;
  1229. } else {
  1230. /*
  1231. * fs was mounted as ro, remounting rw
  1232. */
  1233. #ifndef CONFIG_UFS_FS_WRITE
  1234. pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
  1235. mutex_unlock(&UFS_SB(sb)->s_lock);
  1236. return -EINVAL;
  1237. #else
  1238. if (ufstype != UFS_MOUNT_UFSTYPE_SUN &&
  1239. ufstype != UFS_MOUNT_UFSTYPE_SUNOS &&
  1240. ufstype != UFS_MOUNT_UFSTYPE_44BSD &&
  1241. ufstype != UFS_MOUNT_UFSTYPE_SUNx86 &&
  1242. ufstype != UFS_MOUNT_UFSTYPE_UFS2) {
  1243. pr_err("this ufstype is read-only supported\n");
  1244. mutex_unlock(&UFS_SB(sb)->s_lock);
  1245. return -EINVAL;
  1246. }
  1247. if (!ufs_read_cylinder_structures(sb)) {
  1248. pr_err("failed during remounting\n");
  1249. mutex_unlock(&UFS_SB(sb)->s_lock);
  1250. return -EPERM;
  1251. }
  1252. sb->s_flags &= ~SB_RDONLY;
  1253. #endif
  1254. }
  1255. UFS_SB(sb)->s_mount_opt = new_mount_opt;
  1256. mutex_unlock(&UFS_SB(sb)->s_lock);
  1257. return 0;
  1258. }
  1259. static int ufs_show_options(struct seq_file *seq, struct dentry *root)
  1260. {
  1261. struct ufs_sb_info *sbi = UFS_SB(root->d_sb);
  1262. unsigned mval = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE;
  1263. const struct match_token *tp = tokens;
  1264. while (tp->token != Opt_onerror_panic && tp->token != mval)
  1265. ++tp;
  1266. BUG_ON(tp->token == Opt_onerror_panic);
  1267. seq_printf(seq, ",%s", tp->pattern);
  1268. mval = sbi->s_mount_opt & UFS_MOUNT_ONERROR;
  1269. while (tp->token != Opt_err && tp->token != mval)
  1270. ++tp;
  1271. BUG_ON(tp->token == Opt_err);
  1272. seq_printf(seq, ",%s", tp->pattern);
  1273. return 0;
  1274. }
  1275. static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf)
  1276. {
  1277. struct super_block *sb = dentry->d_sb;
  1278. struct ufs_sb_private_info *uspi= UFS_SB(sb)->s_uspi;
  1279. unsigned flags = UFS_SB(sb)->s_flags;
  1280. u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
  1281. mutex_lock(&UFS_SB(sb)->s_lock);
  1282. if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
  1283. buf->f_type = UFS2_MAGIC;
  1284. else
  1285. buf->f_type = UFS_MAGIC;
  1286. buf->f_blocks = uspi->s_dsize;
  1287. buf->f_bfree = ufs_freefrags(uspi);
  1288. buf->f_ffree = uspi->cs_total.cs_nifree;
  1289. buf->f_bsize = sb->s_blocksize;
  1290. buf->f_bavail = (buf->f_bfree > uspi->s_root_blocks)
  1291. ? (buf->f_bfree - uspi->s_root_blocks) : 0;
  1292. buf->f_files = uspi->s_ncg * uspi->s_ipg;
  1293. buf->f_namelen = UFS_MAXNAMLEN;
  1294. buf->f_fsid = u64_to_fsid(id);
  1295. mutex_unlock(&UFS_SB(sb)->s_lock);
  1296. return 0;
  1297. }
  1298. static struct kmem_cache * ufs_inode_cachep;
  1299. static struct inode *ufs_alloc_inode(struct super_block *sb)
  1300. {
  1301. struct ufs_inode_info *ei;
  1302. ei = kmem_cache_alloc(ufs_inode_cachep, GFP_NOFS);
  1303. if (!ei)
  1304. return NULL;
  1305. inode_set_iversion(&ei->vfs_inode, 1);
  1306. seqlock_init(&ei->meta_lock);
  1307. mutex_init(&ei->truncate_mutex);
  1308. return &ei->vfs_inode;
  1309. }
  1310. static void ufs_free_in_core_inode(struct inode *inode)
  1311. {
  1312. kmem_cache_free(ufs_inode_cachep, UFS_I(inode));
  1313. }
  1314. static void init_once(void *foo)
  1315. {
  1316. struct ufs_inode_info *ei = (struct ufs_inode_info *) foo;
  1317. inode_init_once(&ei->vfs_inode);
  1318. }
  1319. static int __init init_inodecache(void)
  1320. {
  1321. ufs_inode_cachep = kmem_cache_create_usercopy("ufs_inode_cache",
  1322. sizeof(struct ufs_inode_info), 0,
  1323. (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
  1324. SLAB_ACCOUNT),
  1325. offsetof(struct ufs_inode_info, i_u1.i_symlink),
  1326. sizeof_field(struct ufs_inode_info,
  1327. i_u1.i_symlink),
  1328. init_once);
  1329. if (ufs_inode_cachep == NULL)
  1330. return -ENOMEM;
  1331. return 0;
  1332. }
  1333. static void destroy_inodecache(void)
  1334. {
  1335. /*
  1336. * Make sure all delayed rcu free inodes are flushed before we
  1337. * destroy cache.
  1338. */
  1339. rcu_barrier();
  1340. kmem_cache_destroy(ufs_inode_cachep);
  1341. }
  1342. static const struct super_operations ufs_super_ops = {
  1343. .alloc_inode = ufs_alloc_inode,
  1344. .free_inode = ufs_free_in_core_inode,
  1345. .write_inode = ufs_write_inode,
  1346. .evict_inode = ufs_evict_inode,
  1347. .put_super = ufs_put_super,
  1348. .sync_fs = ufs_sync_fs,
  1349. .statfs = ufs_statfs,
  1350. .remount_fs = ufs_remount,
  1351. .show_options = ufs_show_options,
  1352. };
  1353. static struct dentry *ufs_mount(struct file_system_type *fs_type,
  1354. int flags, const char *dev_name, void *data)
  1355. {
  1356. return mount_bdev(fs_type, flags, dev_name, data, ufs_fill_super);
  1357. }
  1358. static struct file_system_type ufs_fs_type = {
  1359. .owner = THIS_MODULE,
  1360. .name = "ufs",
  1361. .mount = ufs_mount,
  1362. .kill_sb = kill_block_super,
  1363. .fs_flags = FS_REQUIRES_DEV,
  1364. };
  1365. MODULE_ALIAS_FS("ufs");
  1366. static int __init init_ufs_fs(void)
  1367. {
  1368. int err = init_inodecache();
  1369. if (err)
  1370. goto out1;
  1371. err = register_filesystem(&ufs_fs_type);
  1372. if (err)
  1373. goto out;
  1374. return 0;
  1375. out:
  1376. destroy_inodecache();
  1377. out1:
  1378. return err;
  1379. }
  1380. static void __exit exit_ufs_fs(void)
  1381. {
  1382. unregister_filesystem(&ufs_fs_type);
  1383. destroy_inodecache();
  1384. }
  1385. module_init(init_ufs_fs)
  1386. module_exit(exit_ufs_fs)
  1387. MODULE_LICENSE("GPL");
  1388. MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);