开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
super.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：30k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

super.c：源码内容
  1. /*
  2.  *  linux/fs/ufs/super.c
  3.  *
  4.  * Copyright (C) 1998
  5.  * Daniel Pirkl <daniel.pirkl@email.cz>
  6.  * Charles University, Faculty of Mathematics and Physics
  7.  */
  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. /*
  29.  * Inspired by
  30.  *
  31.  *  linux/fs/ufs/super.c
  32.  *
  33.  * Copyright (C) 1996
  34.  * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
  35.  * Laboratory for Computer Science Research Computing Facility
  36.  * Rutgers, The State University of New Jersey
  37.  *
  38.  * Copyright (C) 1996  Eddie C. Dost  (ecd@skynet.be)
  39.  *
  40.  * Kernel module support added on 96/04/26 by
  41.  * Stefan Reinauer <stepan@home.culture.mipt.ru>
  42.  *
  43.  * Module usage counts added on 96/04/29 by
  44.  * Gertjan van Wingerde <gertjan@cs.vu.nl>
  45.  *
  46.  * Clean swab support on 19970406 by
  47.  * Francois-Rene Rideau <fare@tunes.org>
  48.  *
  49.  * 4.4BSD (FreeBSD) support added on February 1st 1998 by
  50.  * Niels Kristian Bech Jensen <nkbj@image.dk> partially based
  51.  * on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>.
  52.  *
  53.  * NeXTstep support added on February 5th 1998 by
  54.  * Niels Kristian Bech Jensen <nkbj@image.dk>.
  55.  *
  56.  * write support Daniel Pirkl <daniel.pirkl@email.cz> 1998
  57.  * 
  58.  * HP/UX hfs filesystem support added by
  59.  * Martin K. Petersen <mkp@mkp.net>, August 1999
  60.  *
  61.  */
  64. #include <linux/config.h>
  65. #include <linux/module.h>
  67. #include <stdarg.h>
  69. #include <asm/bitops.h>
  70. #include <asm/uaccess.h>
  71. #include <asm/system.h>
  73. #include <linux/errno.h>
  74. #include <linux/fs.h>
  75. #include <linux/ufs_fs.h>
  76. #include <linux/slab.h>
  77. #include <linux/sched.h>
  78. #include <linux/stat.h>
  79. #include <linux/string.h>
  80. #include <linux/locks.h>
  81. #include <linux/blkdev.h>
  82. #include <linux/init.h>
  84. #include "swab.h"
  85. #include "util.h"
  87. #undef UFS_SUPER_DEBUG
  88. #undef UFS_SUPER_DEBUG_MORE
  90. #ifdef UFS_SUPER_DEBUG
  91. #define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
  92. #else
  93. #define UFSD(x)
  94. #endif
  96. #ifdef UFS_SUPER_DEBUG_MORE
  97. /*
  98.  * Print contents of ufs_super_block, useful for debugging
  99.  */
  100. void ufs_print_super_stuff(struct super_block *sb,
  101. struct ufs_super_block_first * usb1,
  102. struct ufs_super_block_second * usb2, 
  103. struct ufs_super_block_third * usb3)
  104. {
  105. printk("ufs_print_super_stuffn");
  106. printk("size of usb:     %un", sizeof(struct ufs_super_block));
  107. printk("  magic:         0x%xn", fs32_to_cpu(sb, usb3->fs_magic));
  108. printk("  sblkno:        %un", fs32_to_cpu(sb, usb1->fs_sblkno));
  109. printk("  cblkno:        %un", fs32_to_cpu(sb, usb1->fs_cblkno));
  110. printk("  iblkno:        %un", fs32_to_cpu(sb, usb1->fs_iblkno));
  111. printk("  dblkno:        %un", fs32_to_cpu(sb, usb1->fs_dblkno));
  112. printk("  cgoffset:      %un", fs32_to_cpu(sb, usb1->fs_cgoffset));
  113. printk("  ~cgmask:       0x%xn", ~fs32_to_cpu(sb, usb1->fs_cgmask));
  114. printk("  size:          %un", fs32_to_cpu(sb, usb1->fs_size));
  115. printk("  dsize:         %un", fs32_to_cpu(sb, usb1->fs_dsize));
  116. printk("  ncg:           %un", fs32_to_cpu(sb, usb1->fs_ncg));
  117. printk("  bsize:         %un", fs32_to_cpu(sb, usb1->fs_bsize));
  118. printk("  fsize:         %un", fs32_to_cpu(sb, usb1->fs_fsize));
  119. printk("  frag:          %un", fs32_to_cpu(sb, usb1->fs_frag));
  120. printk("  fragshift:     %un", fs32_to_cpu(sb, usb1->fs_fragshift));
  121. printk("  ~fmask:        %un", ~fs32_to_cpu(sb, usb1->fs_fmask));
  122. printk("  fshift:        %un", fs32_to_cpu(sb, usb1->fs_fshift));
  123. printk("  sbsize:        %un", fs32_to_cpu(sb, usb1->fs_sbsize));
  124. printk("  spc:           %un", fs32_to_cpu(sb, usb1->fs_spc));
  125. printk("  cpg:           %un", fs32_to_cpu(sb, usb1->fs_cpg));
  126. printk("  ipg:           %un", fs32_to_cpu(sb, usb1->fs_ipg));
  127. printk("  fpg:           %un", fs32_to_cpu(sb, usb1->fs_fpg));
  128. printk("  csaddr:        %un", fs32_to_cpu(sb, usb1->fs_csaddr));
  129. printk("  cssize:        %un", fs32_to_cpu(sb, usb1->fs_cssize));
  130. printk("  cgsize:        %un", fs32_to_cpu(sb, usb1->fs_cgsize));
  131. printk("  fstodb:        %un", fs32_to_cpu(sb, usb1->fs_fsbtodb));
  132. printk("  contigsumsize: %dn", fs32_to_cpu(sb, usb3->fs_u2.fs_44.fs_contigsumsize));
  133. printk("  postblformat:  %un", fs32_to_cpu(sb, usb3->fs_postblformat));
  134. printk("  nrpos:         %un", fs32_to_cpu(sb, usb3->fs_nrpos));
  135. printk("  ndir           %un", fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir));
  136. printk("  nifree         %un", fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree));
  137. printk("  nbfree         %un", fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree));
  138. printk("  nffree         %un", fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree));
  139. printk("n");
  140. }
  143. /*
  144.  * Print contents of ufs_cylinder_group, useful for debugging
  145.  */
  146. void ufs_print_cylinder_stuff(struct super_block *sb, struct ufs_cylinder_group *cg)
  147. {
  148. printk("nufs_print_cylinder_stuffn");
  149. printk("size of ucg: %un", sizeof(struct ufs_cylinder_group));
  150. printk("  magic:        %xn", fs32_to_cpu(sb, cg->cg_magic));
  151. printk("  time:         %un", fs32_to_cpu(sb, cg->cg_time));
  152. printk("  cgx:          %un", fs32_to_cpu(sb, cg->cg_cgx));
  153. printk("  ncyl:         %un", fs16_to_cpu(sb, cg->cg_ncyl));
  154. printk("  niblk:        %un", fs16_to_cpu(sb, cg->cg_niblk));
  155. printk("  ndblk:        %un", fs32_to_cpu(sb, cg->cg_ndblk));
  156. printk("  cs_ndir:      %un", fs32_to_cpu(sb, cg->cg_cs.cs_ndir));
  157. printk("  cs_nbfree:    %un", fs32_to_cpu(sb, cg->cg_cs.cs_nbfree));
  158. printk("  cs_nifree:    %un", fs32_to_cpu(sb, cg->cg_cs.cs_nifree));
  159. printk("  cs_nffree:    %un", fs32_to_cpu(sb, cg->cg_cs.cs_nffree));
  160. printk("  rotor:        %un", fs32_to_cpu(sb, cg->cg_rotor));
  161. printk("  frotor:       %un", fs32_to_cpu(sb, cg->cg_frotor));
  162. printk("  irotor:       %un", fs32_to_cpu(sb, cg->cg_irotor));
  163. printk("  frsum:        %u, %u, %u, %u, %u, %u, %u, %un",
  164.     fs32_to_cpu(sb, cg->cg_frsum[0]), fs32_to_cpu(sb, cg->cg_frsum[1]),
  165.     fs32_to_cpu(sb, cg->cg_frsum[2]), fs32_to_cpu(sb, cg->cg_frsum[3]),
  166.     fs32_to_cpu(sb, cg->cg_frsum[4]), fs32_to_cpu(sb, cg->cg_frsum[5]),
  167.     fs32_to_cpu(sb, cg->cg_frsum[6]), fs32_to_cpu(sb, cg->cg_frsum[7]));
  168. printk("  btotoff:      %un", fs32_to_cpu(sb, cg->cg_btotoff));
  169. printk("  boff:         %un", fs32_to_cpu(sb, cg->cg_boff));
  170. printk("  iuseoff:      %un", fs32_to_cpu(sb, cg->cg_iusedoff));
  171. printk("  freeoff:      %un", fs32_to_cpu(sb, cg->cg_freeoff));
  172. printk("  nextfreeoff:  %un", fs32_to_cpu(sb, cg->cg_nextfreeoff));
  173. printk("  clustersumoff %un", fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clustersumoff));
  174. printk("  clusteroff    %un", fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clusteroff));
  175. printk("  nclusterblks  %un", fs32_to_cpu(sb, cg->cg_u.cg_44.cg_nclusterblks));
  176. printk("n");
  177. }
  178. #endif /* UFS_SUPER_DEBUG_MORE */
  180. static struct super_operations ufs_super_ops;
  182. static char error_buf[1024];
  184. void ufs_error (struct super_block * sb, const char * function,
  185. const char * fmt, ...)
  186. {
  187. struct ufs_sb_private_info * uspi;
  188. struct ufs_super_block_first * usb1;
  189. va_list args;
  191. uspi = sb->u.ufs_sb.s_uspi;
  192. usb1 = ubh_get_usb_first(USPI_UBH);
  194. if (!(sb->s_flags & MS_RDONLY)) {
  195. usb1->fs_clean = UFS_FSBAD;
  196. ubh_mark_buffer_dirty(USPI_UBH);
  197. sb->s_dirt = 1;
  198. sb->s_flags |= MS_RDONLY;
  199. }
  200. va_start (args, fmt);
  201. vsprintf (error_buf, fmt, args);
  202. va_end (args);
  203. switch (sb->u.ufs_sb.s_mount_opt & UFS_MOUNT_ONERROR) {
  204. case UFS_MOUNT_ONERROR_PANIC:
  205. panic ("UFS-fs panic (device %s): %s: %sn", 
  206. kdevname(sb->s_dev), function, error_buf);
  208. case UFS_MOUNT_ONERROR_LOCK:
  209. case UFS_MOUNT_ONERROR_UMOUNT:
  210. case UFS_MOUNT_ONERROR_REPAIR:
  211. printk (KERN_CRIT "UFS-fs error (device %s): %s: %sn",
  212. kdevname(sb->s_dev), function, error_buf);
  213. }
  214. }
  216. void ufs_panic (struct super_block * sb, const char * function,
  217. const char * fmt, ...)
  218. {
  219. struct ufs_sb_private_info * uspi;
  220. struct ufs_super_block_first * usb1;
  221. va_list args;
  223. uspi = sb->u.ufs_sb.s_uspi;
  224. usb1 = ubh_get_usb_first(USPI_UBH);
  226. if (!(sb->s_flags & MS_RDONLY)) {
  227. usb1->fs_clean = UFS_FSBAD;
  228. ubh_mark_buffer_dirty(USPI_UBH);
  229. sb->s_dirt = 1;
  230. }
  231. va_start (args, fmt);
  232. vsprintf (error_buf, fmt, args);
  233. va_end (args);
  234. sb->s_flags |= MS_RDONLY;
  235. printk (KERN_CRIT "UFS-fs panic (device %s): %s: %sn",
  236. kdevname(sb->s_dev), function, error_buf);
  237. }
  239. void ufs_warning (struct super_block * sb, const char * function,
  240. const char * fmt, ...)
  241. {
  242. va_list args;
  244. va_start (args, fmt);
  245. vsprintf (error_buf, fmt, args);
  246. va_end (args);
  247. printk (KERN_WARNING "UFS-fs warning (device %s): %s: %sn",
  248. kdevname(sb->s_dev), function, error_buf);
  249. }
  251. static int ufs_parse_options (char * options, unsigned * mount_options)
  252. {
  253. char * this_char;
  254. char * value;
  256. UFSD(("ENTERn"))
  258. if (!options)
  259. return 1;
  261. for (this_char = strtok (options, ",");
  262.      this_char != NULL;
  263.      this_char = strtok (NULL, ",")) {
  264.      
  265. if ((value = strchr (this_char, '=')) != NULL)
  266. *value++ = 0;
  267. if (!strcmp (this_char, "ufstype")) {
  268. ufs_clear_opt (*mount_options, UFSTYPE);
  269. if (!strcmp (value, "old"))
  270. ufs_set_opt (*mount_options, UFSTYPE_OLD);
  271. else if (!strcmp (value, "sun"))
  272. ufs_set_opt (*mount_options, UFSTYPE_SUN);
  273. else if (!strcmp (value, "44bsd"))
  274. ufs_set_opt (*mount_options, UFSTYPE_44BSD);
  275. else if (!strcmp (value, "nextstep"))
  276. ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP);
  277. else if (!strcmp (value, "nextstep-cd"))
  278. ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP_CD);
  279. else if (!strcmp (value, "openstep"))
  280. ufs_set_opt (*mount_options, UFSTYPE_OPENSTEP);
  281. else if (!strcmp (value, "sunx86"))
  282. ufs_set_opt (*mount_options, UFSTYPE_SUNx86);
  283. else if (!strcmp (value, "hp"))
  284. ufs_set_opt (*mount_options, UFSTYPE_HP);
  285. else {
  286. printk ("UFS-fs: Invalid type option: %sn", value);
  287. return 0;
  288. }
  289. }
  290. else if (!strcmp (this_char, "onerror")) {
  291. ufs_clear_opt (*mount_options, ONERROR);
  292. if (!strcmp (value, "panic"))
  293. ufs_set_opt (*mount_options, ONERROR_PANIC);
  294. else if (!strcmp (value, "lock"))
  295. ufs_set_opt (*mount_options, ONERROR_LOCK);
  296. else if (!strcmp (value, "umount"))
  297. ufs_set_opt (*mount_options, ONERROR_UMOUNT);
  298. else if (!strcmp (value, "repair")) {
  299. printk("UFS-fs: Unable to do repair on error, "
  300. "will lock lock instead n");
  301. ufs_set_opt (*mount_options, ONERROR_REPAIR);
  302. }
  303. else {
  304. printk ("UFS-fs: Invalid action onerror: %sn", value);
  305. return 0;
  306. }
  307. }
  308. else {
  309. printk("UFS-fs: Invalid option: %sn", this_char);
  310. return 0;
  311. }
  312. }
  313. return 1;
  314. }
  316. /*
  317.  * Read on-disk structures associated with cylinder groups
  318.  */
  319. int ufs_read_cylinder_structures (struct super_block * sb) {
  320. struct ufs_sb_private_info * uspi;
  321. struct ufs_buffer_head * ubh;
  322. unsigned char * base, * space;
  323. unsigned size, blks, i;
  325. UFSD(("ENTERn"))
  327. uspi = sb->u.ufs_sb.s_uspi;
  329. /*
  330.  * Read cs structures from (usually) first data block
  331.  * on the device. 
  332.  */
  333. size = uspi->s_cssize;
  334. blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
  335. base = space = kmalloc(size, GFP_KERNEL);
  336. if (!base)
  337. goto failed; 
  338. for (i = 0; i < blks; i += uspi->s_fpb) {
  339. size = uspi->s_bsize;
  340. if (i + uspi->s_fpb > blks)
  341. size = (blks - i) * uspi->s_fsize;
  342. ubh = ubh_bread(sb, uspi->s_csaddr + i, size);
  343. if (!ubh)
  344. goto failed;
  345. ubh_ubhcpymem (space, ubh, size);
  346. sb->u.ufs_sb.s_csp[ufs_fragstoblks(i)] = (struct ufs_csum *)space;
  347. space += size;
  348. ubh_brelse (ubh);
  349. ubh = NULL;
  350. }
  352. /*
  353.  * Read cylinder group (we read only first fragment from block
  354.  * at this time) and prepare internal data structures for cg caching.
  355.  */
  356. if (!(sb->u.ufs_sb.s_ucg = kmalloc (sizeof(struct buffer_head *) * uspi->s_ncg, GFP_KERNEL)))
  357. goto failed;
  358. for (i = 0; i < uspi->s_ncg; i++) 
  359. sb->u.ufs_sb.s_ucg[i] = NULL;
  360. for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
  361. sb->u.ufs_sb.s_ucpi[i] = NULL;
  362. sb->u.ufs_sb.s_cgno[i] = UFS_CGNO_EMPTY;
  363. }
  364. for (i = 0; i < uspi->s_ncg; i++) {
  365. UFSD(("read cg %un", i))
  366. if (!(sb->u.ufs_sb.s_ucg[i] = sb_bread(sb, ufs_cgcmin(i))))
  367. goto failed;
  368. if (!ufs_cg_chkmagic (sb, (struct ufs_cylinder_group *) sb->u.ufs_sb.s_ucg[i]->b_data))
  369. goto failed;
  370. #ifdef UFS_SUPER_DEBUG_MORE
  371. ufs_print_cylinder_stuff(sb, (struct ufs_cylinder_group *) sb->u.ufs_sb.s_ucg[i]->b_data);
  372. #endif
  373. }
  374. for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
  375. if (!(sb->u.ufs_sb.s_ucpi[i] = kmalloc (sizeof(struct ufs_cg_private_info), GFP_KERNEL)))
  376. goto failed;
  377. sb->u.ufs_sb.s_cgno[i] = UFS_CGNO_EMPTY;
  378. }
  379. sb->u.ufs_sb.s_cg_loaded = 0;
  380. UFSD(("EXITn"))
  381. return 1;
  383. failed:
  384. if (base) kfree (base);
  385. if (sb->u.ufs_sb.s_ucg) {
  386. for (i = 0; i < uspi->s_ncg; i++)
  387. if (sb->u.ufs_sb.s_ucg[i]) brelse (sb->u.ufs_sb.s_ucg[i]);
  388. kfree (sb->u.ufs_sb.s_ucg);
  389. for (i = 0; i < UFS_MAX_GROUP_LOADED; i++)
  390. if (sb->u.ufs_sb.s_ucpi[i]) kfree (sb->u.ufs_sb.s_ucpi[i]);
  391. }
  392. UFSD(("EXIT (FAILED)n"))
  393. return 0;
  394. }
  396. /*
  397.  * Put on-disk structures associated with cylinder groups and 
  398.  * write them back to disk
  399.  */
  400. void ufs_put_cylinder_structures (struct super_block * sb) {
  401. struct ufs_sb_private_info * uspi;
  402. struct ufs_buffer_head * ubh;
  403. unsigned char * base, * space;
  404. unsigned blks, size, i;
  406. UFSD(("ENTERn"))
  408. uspi = sb->u.ufs_sb.s_uspi;
  410. size = uspi->s_cssize;
  411. blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
  412. base = space = (char*) sb->u.ufs_sb.s_csp[0];
  413. for (i = 0; i < blks; i += uspi->s_fpb) {
  414. size = uspi->s_bsize;
  415. if (i + uspi->s_fpb > blks)
  416. size = (blks - i) * uspi->s_fsize;
  417. ubh = ubh_bread(sb, uspi->s_csaddr + i, size);
  418. ubh_memcpyubh (ubh, space, size);
  419. space += size;
  420. ubh_mark_buffer_uptodate (ubh, 1);
  421. ubh_mark_buffer_dirty (ubh);
  422. ubh_brelse (ubh);
  423. }
  424. for (i = 0; i < sb->u.ufs_sb.s_cg_loaded; i++) {
  425. ufs_put_cylinder (sb, i);
  426. kfree (sb->u.ufs_sb.s_ucpi[i]);
  427. }
  428. for (; i < UFS_MAX_GROUP_LOADED; i++) 
  429. kfree (sb->u.ufs_sb.s_ucpi[i]);
  430. for (i = 0; i < uspi->s_ncg; i++) 
  431. brelse (sb->u.ufs_sb.s_ucg[i]);
  432. kfree (sb->u.ufs_sb.s_ucg);
  433. kfree (base);
  434. UFSD(("EXITn"))
  435. }
  437. struct super_block * ufs_read_super (struct super_block * sb, void * data,
  438. int silent)
  439. {
  440. struct ufs_sb_private_info * uspi;
  441. struct ufs_super_block_first * usb1;
  442. struct ufs_super_block_second * usb2;
  443. struct ufs_super_block_third * usb3;
  444. struct ufs_buffer_head * ubh;
  445. struct inode *inode;
  446. unsigned block_size, super_block_size;
  447. unsigned flags;
  449. uspi = NULL;
  450. ubh = NULL;
  451. flags = 0;
  453. UFSD(("ENTERn"))
  455. UFSD(("flag %un", (int)(sb->s_flags & MS_RDONLY)))
  457. #ifndef CONFIG_UFS_FS_WRITE
  458. if (!(sb->s_flags & MS_RDONLY)) {
  459. printk("ufs was compiled with read-only support, "
  460. "can't be mounted as read-writen");
  461. goto failed;
  462. }
  463. #endif
  464. /*
  465.  * Set default mount options
  466.  * Parse mount options
  467.  */
  468. sb->u.ufs_sb.s_mount_opt = 0;
  469. ufs_set_opt (sb->u.ufs_sb.s_mount_opt, ONERROR_LOCK);
  470. if (!ufs_parse_options ((char *) data, &sb->u.ufs_sb.s_mount_opt)) {
  471. printk("wrong mount optionsn");
  472. goto failed;
  473. }
  474. if (!(sb->u.ufs_sb.s_mount_opt & UFS_MOUNT_UFSTYPE)) {
  475. printk("You didn't specify the type of your ufs filesystemnn"
  476. "mount -t ufs -o ufstype="
  477. "sun|sunx86|44bsd|old|hp|nextstep|netxstep-cd|openstep ...nn"
  478. ">>>WARNING<<< Wrong ufstype may corrupt your filesystem, "
  479. "default is ufstype=oldn");
  480. ufs_set_opt (sb->u.ufs_sb.s_mount_opt, UFSTYPE_OLD);
  481. }
  483. sb->u.ufs_sb.s_uspi = uspi =
  484. kmalloc (sizeof(struct ufs_sb_private_info), GFP_KERNEL);
  485. if (!uspi)
  486. goto failed;
  488. /* Keep 2Gig file limit. Some UFS variants need to override 
  489.    this but as I don't know which I'll let those in the know loosen
  490.    the rules */
  491.    
  492. switch (sb->u.ufs_sb.s_mount_opt & UFS_MOUNT_UFSTYPE) {
  493. case UFS_MOUNT_UFSTYPE_44BSD:
  494. UFSD(("ufstype=44bsdn"))
  495. uspi->s_fsize = block_size = 512;
  496. uspi->s_fmask = ~(512 - 1);
  497. uspi->s_fshift = 9;
  498. uspi->s_sbsize = super_block_size = 1536;
  499. uspi->s_sbbase = 0;
  500. flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
  501. break;
  503. case UFS_MOUNT_UFSTYPE_SUN:
  504. UFSD(("ufstype=sunn"))
  505. uspi->s_fsize = block_size = 1024;
  506. uspi->s_fmask = ~(1024 - 1);
  507. uspi->s_fshift = 10;
  508. uspi->s_sbsize = super_block_size = 2048;
  509. uspi->s_sbbase = 0;
  510. uspi->s_maxsymlinklen = 56;
  511. flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUN | UFS_CG_SUN;
  512. break;
  514. case UFS_MOUNT_UFSTYPE_SUNx86:
  515. UFSD(("ufstype=sunx86n"))
  516. uspi->s_fsize = block_size = 1024;
  517. uspi->s_fmask = ~(1024 - 1);
  518. uspi->s_fshift = 10;
  519. uspi->s_sbsize = super_block_size = 2048;
  520. uspi->s_sbbase = 0;
  521. uspi->s_maxsymlinklen = 56;
  522. flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUNx86 | UFS_CG_SUN;
  523. break;
  525. case UFS_MOUNT_UFSTYPE_OLD:
  526. UFSD(("ufstype=oldn"))
  527. uspi->s_fsize = block_size = 1024;
  528. uspi->s_fmask = ~(1024 - 1);
  529. uspi->s_fshift = 10;
  530. uspi->s_sbsize = super_block_size = 2048;
  531. uspi->s_sbbase = 0;
  532. flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
  533. if (!(sb->s_flags & MS_RDONLY)) {
  534. printk(KERN_INFO "ufstype=old is supported read-onlyn"); 
  535. sb->s_flags |= MS_RDONLY;
  536. }
  537. break;
  539. case UFS_MOUNT_UFSTYPE_NEXTSTEP:
  540. UFSD(("ufstype=nextstepn"))
  541. uspi->s_fsize = block_size = 1024;
  542. uspi->s_fmask = ~(1024 - 1);
  543. uspi->s_fshift = 10;
  544. uspi->s_sbsize = super_block_size = 2048;
  545. uspi->s_sbbase = 0;
  546. flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
  547. if (!(sb->s_flags & MS_RDONLY)) {
  548. printk(KERN_INFO "ufstype=nextstep is supported read-onlyn");
  549. sb->s_flags |= MS_RDONLY;
  550. }
  551. break;
  553. case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD:
  554. UFSD(("ufstype=nextstep-cdn"))
  555. uspi->s_fsize = block_size = 2048;
  556. uspi->s_fmask = ~(2048 - 1);
  557. uspi->s_fshift = 11;
  558. uspi->s_sbsize = super_block_size = 2048;
  559. uspi->s_sbbase = 0;
  560. flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
  561. if (!(sb->s_flags & MS_RDONLY)) {
  562. printk(KERN_INFO "ufstype=nextstep-cd is supported read-onlyn");
  563. sb->s_flags |= MS_RDONLY;
  564. }
  565. break;
  567. case UFS_MOUNT_UFSTYPE_OPENSTEP:
  568. UFSD(("ufstype=openstepn"))
  569. uspi->s_fsize = block_size = 1024;
  570. uspi->s_fmask = ~(1024 - 1);
  571. uspi->s_fshift = 10;
  572. uspi->s_sbsize = super_block_size = 2048;
  573. uspi->s_sbbase = 0;
  574. flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
  575. if (!(sb->s_flags & MS_RDONLY)) {
  576. printk(KERN_INFO "ufstype=openstep is supported read-onlyn");
  577. sb->s_flags |= MS_RDONLY;
  578. }
  579. break;
  581. case UFS_MOUNT_UFSTYPE_HP:
  582. UFSD(("ufstype=hpn"))
  583. uspi->s_fsize = block_size = 1024;
  584. uspi->s_fmask = ~(1024 - 1);
  585. uspi->s_fshift = 10;
  586. uspi->s_sbsize = super_block_size = 2048;
  587. uspi->s_sbbase = 0;
  588. flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
  589. if (!(sb->s_flags & MS_RDONLY)) {
  590. printk(KERN_INFO "ufstype=hp is supported read-onlyn");
  591. sb->s_flags |= MS_RDONLY;
  592.   }
  593.   break;
  594. default:
  595. printk("unknown ufstypen");
  596. goto failed;
  597. }
  599. again:
  600. set_blocksize (sb->s_dev, block_size);
  601. sb->s_blocksize = block_size;
  603. /*
  604.  * read ufs super block from device
  605.  */
  606. ubh = ubh_bread_uspi (uspi, sb, uspi->s_sbbase + UFS_SBLOCK/block_size, super_block_size);
  607. if (!ubh) 
  608. goto failed;
  610. usb1 = ubh_get_usb_first(USPI_UBH);
  611. usb2 = ubh_get_usb_second(USPI_UBH);
  612. usb3 = ubh_get_usb_third(USPI_UBH);
  614. /*
  615.  * Check ufs magic number
  616.  */
  617. switch (__constant_le32_to_cpu(usb3->fs_magic)) {
  618. case UFS_MAGIC:
  619. case UFS_MAGIC_LFN:
  620.         case UFS_MAGIC_FEA:
  621.         case UFS_MAGIC_4GB:
  622. sb->u.ufs_sb.s_bytesex = BYTESEX_LE;
  623. goto magic_found;
  624. }
  625. switch (__constant_be32_to_cpu(usb3->fs_magic)) {
  626. case UFS_MAGIC:
  627. case UFS_MAGIC_LFN:
  628.         case UFS_MAGIC_FEA:
  629.         case UFS_MAGIC_4GB:
  630. sb->u.ufs_sb.s_bytesex = BYTESEX_BE;
  631. goto magic_found;
  632. }
  634. if ((((sb->u.ufs_sb.s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP) 
  635.   || ((sb->u.ufs_sb.s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD) 
  636.   || ((sb->u.ufs_sb.s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_OPENSTEP)) 
  637.   && uspi->s_sbbase < 256) {
  638. ubh_brelse_uspi(uspi);
  639. ubh = NULL;
  640. uspi->s_sbbase += 8;
  641. goto again;
  642. }
  643. printk("ufs_read_super: bad magic numbern");
  644. goto failed;
  646. magic_found:
  647. /*
  648.  * Check block and fragment sizes
  649.  */
  650. uspi->s_bsize = fs32_to_cpu(sb, usb1->fs_bsize);
  651. uspi->s_fsize = fs32_to_cpu(sb, usb1->fs_fsize);
  652. uspi->s_sbsize = fs32_to_cpu(sb, usb1->fs_sbsize);
  653. uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
  654. uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
  656. if (uspi->s_bsize != 4096 && uspi->s_bsize != 8192 
  657.   && uspi->s_bsize != 32768) {
  658. printk("ufs_read_super: fs_bsize %u != {4096, 8192, 32768}n", uspi->s_bsize);
  659. goto failed;
  660. }
  661. if (uspi->s_fsize != 512 && uspi->s_fsize != 1024 
  662.   && uspi->s_fsize != 2048 && uspi->s_fsize != 4096) {
  663. printk("ufs_read_super: fs_fsize %u != {512, 1024, 2048. 4096}n", uspi->s_fsize);
  664. goto failed;
  665. }
  666. if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) {
  667. ubh_brelse_uspi(uspi);
  668. ubh = NULL;
  669. block_size = uspi->s_fsize;
  670. super_block_size = uspi->s_sbsize;
  671. UFSD(("another value of block_size or super_block_size %u, %un", block_size, super_block_size))
  672. goto again;
  673. }
  675. #ifdef UFS_SUPER_DEBUG_MORE
  676. ufs_print_super_stuff(sb, usb1, usb2, usb3);
  677. #endif
  679. /*
  680.  * Check, if file system was correctly unmounted.
  681.  * If not, make it read only.
  682.  */
  683. if (((flags & UFS_ST_MASK) == UFS_ST_44BSD) ||
  684.   ((flags & UFS_ST_MASK) == UFS_ST_OLD) ||
  685.   (((flags & UFS_ST_MASK) == UFS_ST_SUN || 
  686.   (flags & UFS_ST_MASK) == UFS_ST_SUNx86) && 
  687.   (ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time))))) {
  688. switch(usb1->fs_clean) {
  689. case UFS_FSCLEAN:
  690. UFSD(("fs is cleann"))
  691. break;
  692. case UFS_FSSTABLE:
  693. UFSD(("fs is stablen"))
  694. break;
  695. case UFS_FSOSF1:
  696. UFSD(("fs is DEC OSF/1n"))
  697. break;
  698. case UFS_FSACTIVE:
  699. printk("ufs_read_super: fs is activen");
  700. sb->s_flags |= MS_RDONLY;
  701. break;
  702. case UFS_FSBAD:
  703. printk("ufs_read_super: fs is badn");
  704. sb->s_flags |= MS_RDONLY;
  705. break;
  706. default:
  707. printk("ufs_read_super: can't grok fs_clean 0x%xn", usb1->fs_clean);
  708. sb->s_flags |= MS_RDONLY;
  709. break;
  710. }
  711. }
  712. else {
  713. printk("ufs_read_super: fs needs fsckn");
  714. sb->s_flags |= MS_RDONLY;
  715. }
  717. /*
  718.  * Read ufs_super_block into internal data structures
  719.  */
  720. sb->s_blocksize = fs32_to_cpu(sb, usb1->fs_fsize);
  721. sb->s_blocksize_bits = fs32_to_cpu(sb, usb1->fs_fshift);
  722. sb->s_op = &ufs_super_ops;
  723. sb->dq_op = NULL; /***/
  724. sb->s_magic = fs32_to_cpu(sb, usb3->fs_magic);
  726. uspi->s_sblkno = fs32_to_cpu(sb, usb1->fs_sblkno);
  727. uspi->s_cblkno = fs32_to_cpu(sb, usb1->fs_cblkno);
  728. uspi->s_iblkno = fs32_to_cpu(sb, usb1->fs_iblkno);
  729. uspi->s_dblkno = fs32_to_cpu(sb, usb1->fs_dblkno);
  730. uspi->s_cgoffset = fs32_to_cpu(sb, usb1->fs_cgoffset);
  731. uspi->s_cgmask = fs32_to_cpu(sb, usb1->fs_cgmask);
  732. uspi->s_size = fs32_to_cpu(sb, usb1->fs_size);
  733. uspi->s_dsize = fs32_to_cpu(sb, usb1->fs_dsize);
  734. uspi->s_ncg = fs32_to_cpu(sb, usb1->fs_ncg);
  735. /* s_bsize already set */
  736. /* s_fsize already set */
  737. uspi->s_fpb = fs32_to_cpu(sb, usb1->fs_frag);
  738. uspi->s_minfree = fs32_to_cpu(sb, usb1->fs_minfree);
  739. uspi->s_bmask = fs32_to_cpu(sb, usb1->fs_bmask);
  740. uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
  741. uspi->s_bshift = fs32_to_cpu(sb, usb1->fs_bshift);
  742. uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
  743. uspi->s_fpbshift = fs32_to_cpu(sb, usb1->fs_fragshift);
  744. uspi->s_fsbtodb = fs32_to_cpu(sb, usb1->fs_fsbtodb);
  745. /* s_sbsize already set */
  746. uspi->s_csmask = fs32_to_cpu(sb, usb1->fs_csmask);
  747. uspi->s_csshift = fs32_to_cpu(sb, usb1->fs_csshift);
  748. uspi->s_nindir = fs32_to_cpu(sb, usb1->fs_nindir);
  749. uspi->s_inopb = fs32_to_cpu(sb, usb1->fs_inopb);
  750. uspi->s_nspf = fs32_to_cpu(sb, usb1->fs_nspf);
  751. uspi->s_npsect = ufs_get_fs_npsect(sb, usb1, usb3);
  752. uspi->s_interleave = fs32_to_cpu(sb, usb1->fs_interleave);
  753. uspi->s_trackskew = fs32_to_cpu(sb, usb1->fs_trackskew);
  754. uspi->s_csaddr = fs32_to_cpu(sb, usb1->fs_csaddr);
  755. uspi->s_cssize = fs32_to_cpu(sb, usb1->fs_cssize);
  756. uspi->s_cgsize = fs32_to_cpu(sb, usb1->fs_cgsize);
  757. uspi->s_ntrak = fs32_to_cpu(sb, usb1->fs_ntrak);
  758. uspi->s_nsect = fs32_to_cpu(sb, usb1->fs_nsect);
  759. uspi->s_spc = fs32_to_cpu(sb, usb1->fs_spc);
  760. uspi->s_ipg = fs32_to_cpu(sb, usb1->fs_ipg);
  761. uspi->s_fpg = fs32_to_cpu(sb, usb1->fs_fpg);
  762. uspi->s_cpc = fs32_to_cpu(sb, usb2->fs_cpc);
  763. uspi->s_contigsumsize = fs32_to_cpu(sb, usb3->fs_u2.fs_44.fs_contigsumsize);
  764. uspi->s_qbmask = ufs_get_fs_qbmask(sb, usb3);
  765. uspi->s_qfmask = ufs_get_fs_qfmask(sb, usb3);
  766. uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);
  767. uspi->s_nrpos = fs32_to_cpu(sb, usb3->fs_nrpos);
  768. uspi->s_postbloff = fs32_to_cpu(sb, usb3->fs_postbloff);
  769. uspi->s_rotbloff = fs32_to_cpu(sb, usb3->fs_rotbloff);
  771. /*
  772.  * Compute another frequently used values
  773.  */
  774. uspi->s_fpbmask = uspi->s_fpb - 1;
  775. uspi->s_apbshift = uspi->s_bshift - 2;
  776. uspi->s_2apbshift = uspi->s_apbshift * 2;
  777. uspi->s_3apbshift = uspi->s_apbshift * 3;
  778. uspi->s_apb = 1 << uspi->s_apbshift;
  779. uspi->s_2apb = 1 << uspi->s_2apbshift;
  780. uspi->s_3apb = 1 << uspi->s_3apbshift;
  781. uspi->s_apbmask = uspi->s_apb - 1;
  782. uspi->s_nspfshift = uspi->s_fshift - UFS_SECTOR_BITS;
  783. uspi->s_nspb = uspi->s_nspf << uspi->s_fpbshift;
  784. uspi->s_inopf = uspi->s_inopb >> uspi->s_fpbshift;
  785. uspi->s_bpf = uspi->s_fsize << 3;
  786. uspi->s_bpfshift = uspi->s_fshift + 3;
  787. uspi->s_bpfmask = uspi->s_bpf - 1;
  788. if ((sb->u.ufs_sb.s_mount_opt & UFS_MOUNT_UFSTYPE) ==
  789.     UFS_MOUNT_UFSTYPE_44BSD)
  790. uspi->s_maxsymlinklen =
  791.     fs32_to_cpu(sb, usb3->fs_u2.fs_44.fs_maxsymlinklen);
  793. sb->u.ufs_sb.s_flags = flags;
  795. inode = iget(sb, UFS_ROOTINO);
  796. if (!inode || is_bad_inode(inode))
  797. goto failed;
  798. sb->s_root = d_alloc_root(inode);
  799. if (!sb->s_root)
  800. goto dalloc_failed;
  803. /*
  804.  * Read cylinder group structures
  805.  */
  806. if (!(sb->s_flags & MS_RDONLY))
  807. if (!ufs_read_cylinder_structures(sb))
  808. goto failed;
  810. UFSD(("EXITn"))
  811. return(sb);
  813. dalloc_failed:
  814. iput(inode);
  815. failed:
  816. if (ubh) ubh_brelse_uspi (uspi);
  817. if (uspi) kfree (uspi);
  818. UFSD(("EXIT (FAILED)n"))
  819. return(NULL);
  820. }
  822. void ufs_write_super (struct super_block * sb) {
  823. struct ufs_sb_private_info * uspi;
  824. struct ufs_super_block_first * usb1;
  825. struct ufs_super_block_third * usb3;
  826. unsigned flags;
  828. UFSD(("ENTERn"))
  829. flags = sb->u.ufs_sb.s_flags;
  830. uspi = sb->u.ufs_sb.s_uspi;
  831. usb1 = ubh_get_usb_first(USPI_UBH);
  832. usb3 = ubh_get_usb_third(USPI_UBH);
  834. if (!(sb->s_flags & MS_RDONLY)) {
  835. usb1->fs_time = cpu_to_fs32(sb, CURRENT_TIME);
  836. if ((flags & UFS_ST_MASK) == UFS_ST_SUN 
  837.   || (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
  838. ufs_set_fs_state(sb, usb1, usb3,
  839. UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
  840. ubh_mark_buffer_dirty (USPI_UBH);
  841. }
  842. sb->s_dirt = 0;
  843. UFSD(("EXITn"))
  844. }
  846. void ufs_put_super (struct super_block * sb)
  847. {
  848. struct ufs_sb_private_info * uspi;
  850. UFSD(("ENTERn"))
  852. uspi = sb->u.ufs_sb.s_uspi;
  854. if (!(sb->s_flags & MS_RDONLY))
  855. ufs_put_cylinder_structures (sb);
  857. ubh_brelse_uspi (uspi);
  858. kfree (sb->u.ufs_sb.s_uspi);
  859. return;
  860. }
  863. int ufs_remount (struct super_block * sb, int * mount_flags, char * data)
  864. {
  865. struct ufs_sb_private_info * uspi;
  866. struct ufs_super_block_first * usb1;
  867. struct ufs_super_block_third * usb3;
  868. unsigned new_mount_opt, ufstype;
  869. unsigned flags;
  871. uspi = sb->u.ufs_sb.s_uspi;
  872. flags = sb->u.ufs_sb.s_flags;
  873. usb1 = ubh_get_usb_first(USPI_UBH);
  874. usb3 = ubh_get_usb_third(USPI_UBH);
  876. /*
  877.  * Allow the "check" option to be passed as a remount option.
  878.  * It is not possible to change ufstype option during remount
  879.  */
  880. ufstype = sb->u.ufs_sb.s_mount_opt & UFS_MOUNT_UFSTYPE;
  881. new_mount_opt = 0;
  882. ufs_set_opt (new_mount_opt, ONERROR_LOCK);
  883. if (!ufs_parse_options (data, &new_mount_opt))
  884. return -EINVAL;
  885. if (!(new_mount_opt & UFS_MOUNT_UFSTYPE)) {
  886. new_mount_opt |= ufstype;
  887. }
  888. else if ((new_mount_opt & UFS_MOUNT_UFSTYPE) != ufstype) {
  889. printk("ufstype can't be changed during remountn");
  890. return -EINVAL;
  891. }
  893. if ((*mount_flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) {
  894. sb->u.ufs_sb.s_mount_opt = new_mount_opt;
  895. return 0;
  896. }
  898. /*
  899.  * fs was mouted as rw, remounting ro
  900.  */
  901. if (*mount_flags & MS_RDONLY) {
  902. ufs_put_cylinder_structures(sb);
  903. usb1->fs_time = cpu_to_fs32(sb, CURRENT_TIME);
  904. if ((flags & UFS_ST_MASK) == UFS_ST_SUN
  905.   || (flags & UFS_ST_MASK) == UFS_ST_SUNx86) 
  906. ufs_set_fs_state(sb, usb1, usb3,
  907. UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
  908. ubh_mark_buffer_dirty (USPI_UBH);
  909. sb->s_dirt = 0;
  910. sb->s_flags |= MS_RDONLY;
  911. }
  912. /*
  913.  * fs was mounted as ro, remounting rw
  914.  */
  915. else {
  916. #ifndef CONFIG_UFS_FS_WRITE
  917. printk("ufs was compiled with read-only support, "
  918. "can't be mounted as read-writen");
  919. return -EINVAL;
  920. #else
  921. if (ufstype != UFS_MOUNT_UFSTYPE_SUN && 
  922.     ufstype != UFS_MOUNT_UFSTYPE_44BSD &&
  923.     ufstype != UFS_MOUNT_UFSTYPE_SUNx86) {
  924. printk("this ufstype is read-only supportedn");
  925. return -EINVAL;
  926. }
  927. if (!ufs_read_cylinder_structures (sb)) {
  928. printk("failed during remountingn");
  929. return -EPERM;
  930. }
  931. sb->s_flags &= ~MS_RDONLY;
  932. #endif
  933. }
  934. sb->u.ufs_sb.s_mount_opt = new_mount_opt;
  935. return 0;
  936. }
  938. int ufs_statfs (struct super_block * sb, struct statfs * buf)
  939. {
  940. struct ufs_sb_private_info * uspi;
  941. struct ufs_super_block_first * usb1;
  943. uspi = sb->u.ufs_sb.s_uspi;
  944. usb1 = ubh_get_usb_first (USPI_UBH);
  946. buf->f_type = UFS_MAGIC;
  947. buf->f_bsize = sb->s_blocksize;
  948. buf->f_blocks = uspi->s_dsize;
  949. buf->f_bfree = ufs_blkstofrags(fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree)) +
  950. fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree);
  951. buf->f_bavail = (buf->f_bfree > ((buf->f_blocks / 100) * uspi->s_minfree))
  952. ? (buf->f_bfree - ((buf->f_blocks / 100) * uspi->s_minfree)) : 0;
  953. buf->f_files = uspi->s_ncg * uspi->s_ipg;
  954. buf->f_ffree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree);
  955. buf->f_namelen = UFS_MAXNAMLEN;
  956. return 0;
  957. }
  959. static struct super_operations ufs_super_ops = {
  960. read_inode: ufs_read_inode,
  961. write_inode: ufs_write_inode,
  962. delete_inode: ufs_delete_inode,
  963. put_super: ufs_put_super,
  964. write_super: ufs_write_super,
  965. statfs: ufs_statfs,
  966. remount_fs: ufs_remount,
  967. };
  969. static DECLARE_FSTYPE_DEV(ufs_fs_type, "ufs", ufs_read_super);
  971. static int __init init_ufs_fs(void)
  972. {
  973. return register_filesystem(&ufs_fs_type);
  974. }
  976. static void __exit exit_ufs_fs(void)
  977. {
  978. unregister_filesystem(&ufs_fs_type);
  979. }
  981. EXPORT_NO_SYMBOLS;
  983. module_init(init_ufs_fs)
  984. module_exit(exit_ufs_fs)
  985. MODULE_LICENSE("GPL");