109c434b8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * linux/fs/ufs/super.c
41da177e4SLinus Torvalds *
51da177e4SLinus Torvalds * Copyright (C) 1998
61da177e4SLinus Torvalds * Daniel Pirkl <daniel.pirkl@email.cz>
71da177e4SLinus Torvalds * Charles University, Faculty of Mathematics and Physics
81da177e4SLinus Torvalds */
91da177e4SLinus Torvalds
101da177e4SLinus Torvalds /* Derived from
111da177e4SLinus Torvalds *
121da177e4SLinus Torvalds * linux/fs/ext2/super.c
131da177e4SLinus Torvalds *
141da177e4SLinus Torvalds * Copyright (C) 1992, 1993, 1994, 1995
151da177e4SLinus Torvalds * Remy Card (card@masi.ibp.fr)
161da177e4SLinus Torvalds * Laboratoire MASI - Institut Blaise Pascal
171da177e4SLinus Torvalds * Universite Pierre et Marie Curie (Paris VI)
181da177e4SLinus Torvalds *
191da177e4SLinus Torvalds * from
201da177e4SLinus Torvalds *
211da177e4SLinus Torvalds * linux/fs/minix/inode.c
221da177e4SLinus Torvalds *
231da177e4SLinus Torvalds * Copyright (C) 1991, 1992 Linus Torvalds
241da177e4SLinus Torvalds *
251da177e4SLinus Torvalds * Big-endian to little-endian byte-swapping/bitmaps by
261da177e4SLinus Torvalds * David S. Miller (davem@caip.rutgers.edu), 1995
271da177e4SLinus Torvalds */
281da177e4SLinus Torvalds
291da177e4SLinus Torvalds /*
301da177e4SLinus Torvalds * Inspired by
311da177e4SLinus Torvalds *
321da177e4SLinus Torvalds * linux/fs/ufs/super.c
331da177e4SLinus Torvalds *
341da177e4SLinus Torvalds * Copyright (C) 1996
351da177e4SLinus Torvalds * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
361da177e4SLinus Torvalds * Laboratory for Computer Science Research Computing Facility
371da177e4SLinus Torvalds * Rutgers, The State University of New Jersey
381da177e4SLinus Torvalds *
391da177e4SLinus Torvalds * Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
401da177e4SLinus Torvalds *
411da177e4SLinus Torvalds * Kernel module support added on 96/04/26 by
421da177e4SLinus Torvalds * Stefan Reinauer <stepan@home.culture.mipt.ru>
431da177e4SLinus Torvalds *
441da177e4SLinus Torvalds * Module usage counts added on 96/04/29 by
45f762dd68SGertjan van Wingerde * Gertjan van Wingerde <gwingerde@gmail.com>
461da177e4SLinus Torvalds *
471da177e4SLinus Torvalds * Clean swab support on 19970406 by
481da177e4SLinus Torvalds * Francois-Rene Rideau <fare@tunes.org>
491da177e4SLinus Torvalds *
501da177e4SLinus Torvalds * 4.4BSD (FreeBSD) support added on February 1st 1998 by
511da177e4SLinus Torvalds * Niels Kristian Bech Jensen <nkbj@image.dk> partially based
521da177e4SLinus Torvalds * on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>.
531da177e4SLinus Torvalds *
541da177e4SLinus Torvalds * NeXTstep support added on February 5th 1998 by
551da177e4SLinus Torvalds * Niels Kristian Bech Jensen <nkbj@image.dk>.
561da177e4SLinus Torvalds *
571da177e4SLinus Torvalds * write support Daniel Pirkl <daniel.pirkl@email.cz> 1998
581da177e4SLinus Torvalds *
591da177e4SLinus Torvalds * HP/UX hfs filesystem support added by
601da177e4SLinus Torvalds * Martin K. Petersen <mkp@mkp.net>, August 1999
611da177e4SLinus Torvalds *
621da177e4SLinus Torvalds * UFS2 (of FreeBSD 5.x) support added by
631da177e4SLinus Torvalds * Niraj Kumar <niraj17@iitbombay.org>, Jan 2004
641da177e4SLinus Torvalds *
65cbcae39fSEvgeniy Dushistov * UFS2 write support added by
66cbcae39fSEvgeniy Dushistov * Evgeniy Dushistov <dushistov@mail.ru>, 2007
671da177e4SLinus Torvalds */
681da177e4SLinus Torvalds
69f3e2a520SAlexey Dobriyan #include <linux/exportfs.h>
701da177e4SLinus Torvalds #include <linux/module.h>
711da177e4SLinus Torvalds #include <linux/bitops.h>
721da177e4SLinus Torvalds
73c0891ac1SAlexey Dobriyan #include <linux/stdarg.h>
741da177e4SLinus Torvalds
757c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
761da177e4SLinus Torvalds
771da177e4SLinus Torvalds #include <linux/errno.h>
781da177e4SLinus Torvalds #include <linux/fs.h>
791da177e4SLinus Torvalds #include <linux/slab.h>
801da177e4SLinus Torvalds #include <linux/time.h>
811da177e4SLinus Torvalds #include <linux/stat.h>
821da177e4SLinus Torvalds #include <linux/string.h>
831da177e4SLinus Torvalds #include <linux/blkdev.h>
8466114cadSTejun Heo #include <linux/backing-dev.h>
851da177e4SLinus Torvalds #include <linux/init.h>
861da177e4SLinus Torvalds #include <linux/parser.h>
871da177e4SLinus Torvalds #include <linux/buffer_head.h>
881da177e4SLinus Torvalds #include <linux/vfs.h>
899e8c4273Svignesh babu #include <linux/log2.h>
902a9807c0SEvgeniy Dushistov #include <linux/mount.h>
912a9807c0SEvgeniy Dushistov #include <linux/seq_file.h>
92bb8c2d66SJeff Layton #include <linux/iversion.h>
931da177e4SLinus Torvalds
94e5420598SMike Frysinger #include "ufs_fs.h"
95bcd6d4ecSChristoph Hellwig #include "ufs.h"
961da177e4SLinus Torvalds #include "swab.h"
971da177e4SLinus Torvalds #include "util.h"
981da177e4SLinus Torvalds
ufs_nfs_get_inode(struct super_block * sb,u64 ino,u32 generation)99f3e2a520SAlexey Dobriyan static struct inode *ufs_nfs_get_inode(struct super_block *sb, u64 ino, u32 generation)
100f3e2a520SAlexey Dobriyan {
101f3e2a520SAlexey Dobriyan struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
102f3e2a520SAlexey Dobriyan struct inode *inode;
103f3e2a520SAlexey Dobriyan
10488b2e9b0SColin Ian King if (ino < UFS_ROOTINO || ino > (u64)uspi->s_ncg * uspi->s_ipg)
105f3e2a520SAlexey Dobriyan return ERR_PTR(-ESTALE);
106f3e2a520SAlexey Dobriyan
107f3e2a520SAlexey Dobriyan inode = ufs_iget(sb, ino);
108f3e2a520SAlexey Dobriyan if (IS_ERR(inode))
109f3e2a520SAlexey Dobriyan return ERR_CAST(inode);
110f3e2a520SAlexey Dobriyan if (generation && inode->i_generation != generation) {
111f3e2a520SAlexey Dobriyan iput(inode);
112f3e2a520SAlexey Dobriyan return ERR_PTR(-ESTALE);
113f3e2a520SAlexey Dobriyan }
114f3e2a520SAlexey Dobriyan return inode;
115f3e2a520SAlexey Dobriyan }
116f3e2a520SAlexey Dobriyan
ufs_fh_to_dentry(struct super_block * sb,struct fid * fid,int fh_len,int fh_type)117f3e2a520SAlexey Dobriyan static struct dentry *ufs_fh_to_dentry(struct super_block *sb, struct fid *fid,
118f3e2a520SAlexey Dobriyan int fh_len, int fh_type)
119f3e2a520SAlexey Dobriyan {
120f3e2a520SAlexey Dobriyan return generic_fh_to_dentry(sb, fid, fh_len, fh_type, ufs_nfs_get_inode);
121f3e2a520SAlexey Dobriyan }
122f3e2a520SAlexey Dobriyan
ufs_fh_to_parent(struct super_block * sb,struct fid * fid,int fh_len,int fh_type)123f3e2a520SAlexey Dobriyan static struct dentry *ufs_fh_to_parent(struct super_block *sb, struct fid *fid,
124f3e2a520SAlexey Dobriyan int fh_len, int fh_type)
125f3e2a520SAlexey Dobriyan {
126f3e2a520SAlexey Dobriyan return generic_fh_to_parent(sb, fid, fh_len, fh_type, ufs_nfs_get_inode);
127f3e2a520SAlexey Dobriyan }
128f3e2a520SAlexey Dobriyan
ufs_get_parent(struct dentry * child)129f3e2a520SAlexey Dobriyan static struct dentry *ufs_get_parent(struct dentry *child)
130f3e2a520SAlexey Dobriyan {
131f3e2a520SAlexey Dobriyan ino_t ino;
132f3e2a520SAlexey Dobriyan
13380e5d1ffSAl Viro ino = ufs_inode_by_name(d_inode(child), &dotdot_name);
134f3e2a520SAlexey Dobriyan if (!ino)
135f3e2a520SAlexey Dobriyan return ERR_PTR(-ENOENT);
136fc64005cSAl Viro return d_obtain_alias(ufs_iget(child->d_sb, ino));
137f3e2a520SAlexey Dobriyan }
138f3e2a520SAlexey Dobriyan
139f3e2a520SAlexey Dobriyan static const struct export_operations ufs_export_ops = {
140f3e2a520SAlexey Dobriyan .fh_to_dentry = ufs_fh_to_dentry,
141f3e2a520SAlexey Dobriyan .fh_to_parent = ufs_fh_to_parent,
142f3e2a520SAlexey Dobriyan .get_parent = ufs_get_parent,
143f3e2a520SAlexey Dobriyan };
144f3e2a520SAlexey Dobriyan
145abf5d15fSEvgeniy Dushistov #ifdef CONFIG_UFS_DEBUG
1461da177e4SLinus Torvalds /*
1471da177e4SLinus Torvalds * Print contents of ufs_super_block, useful for debugging
1481da177e4SLinus Torvalds */
ufs_print_super_stuff(struct super_block * sb,struct ufs_super_block_first * usb1,struct ufs_super_block_second * usb2,struct ufs_super_block_third * usb3)1493313e292SEvgeniy Dushistov static void ufs_print_super_stuff(struct super_block *sb,
1501da177e4SLinus Torvalds struct ufs_super_block_first *usb1,
1511da177e4SLinus Torvalds struct ufs_super_block_second *usb2,
1521da177e4SLinus Torvalds struct ufs_super_block_third *usb3)
1531da177e4SLinus Torvalds {
1543313e292SEvgeniy Dushistov u32 magic = fs32_to_cpu(sb, usb3->fs_magic);
1553313e292SEvgeniy Dushistov
156a9814c5dSFabian Frederick pr_debug("ufs_print_super_stuff\n");
157a9814c5dSFabian Frederick pr_debug(" magic: 0x%x\n", magic);
1583313e292SEvgeniy Dushistov if (fs32_to_cpu(sb, usb3->fs_magic) == UFS2_MAGIC) {
159a9814c5dSFabian Frederick pr_debug(" fs_size: %llu\n", (unsigned long long)
160647b7e87SEvgeniy Dushistov fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size));
161a9814c5dSFabian Frederick pr_debug(" fs_dsize: %llu\n", (unsigned long long)
162647b7e87SEvgeniy Dushistov fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize));
163a9814c5dSFabian Frederick pr_debug(" bsize: %u\n",
164647b7e87SEvgeniy Dushistov fs32_to_cpu(sb, usb1->fs_bsize));
165a9814c5dSFabian Frederick pr_debug(" fsize: %u\n",
166647b7e87SEvgeniy Dushistov fs32_to_cpu(sb, usb1->fs_fsize));
167a9814c5dSFabian Frederick pr_debug(" fs_volname: %s\n", usb2->fs_un.fs_u2.fs_volname);
168a9814c5dSFabian Frederick pr_debug(" fs_sblockloc: %llu\n", (unsigned long long)
169647b7e87SEvgeniy Dushistov fs64_to_cpu(sb, usb2->fs_un.fs_u2.fs_sblockloc));
170a9814c5dSFabian Frederick pr_debug(" cs_ndir(No of dirs): %llu\n", (unsigned long long)
171647b7e87SEvgeniy Dushistov fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir));
172a9814c5dSFabian Frederick pr_debug(" cs_nbfree(No of free blocks): %llu\n",
173647b7e87SEvgeniy Dushistov (unsigned long long)
174647b7e87SEvgeniy Dushistov fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_nbfree));
175a9814c5dSFabian Frederick pr_info(" cs_nifree(Num of free inodes): %llu\n",
1763313e292SEvgeniy Dushistov (unsigned long long)
1773313e292SEvgeniy Dushistov fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nifree));
178a9814c5dSFabian Frederick pr_info(" cs_nffree(Num of free frags): %llu\n",
1793313e292SEvgeniy Dushistov (unsigned long long)
1803313e292SEvgeniy Dushistov fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nffree));
181a9814c5dSFabian Frederick pr_info(" fs_maxsymlinklen: %u\n",
18290b315afSEvgeniy Dushistov fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen));
183647b7e87SEvgeniy Dushistov } else {
184a9814c5dSFabian Frederick pr_debug(" sblkno: %u\n", fs32_to_cpu(sb, usb1->fs_sblkno));
185a9814c5dSFabian Frederick pr_debug(" cblkno: %u\n", fs32_to_cpu(sb, usb1->fs_cblkno));
186a9814c5dSFabian Frederick pr_debug(" iblkno: %u\n", fs32_to_cpu(sb, usb1->fs_iblkno));
187a9814c5dSFabian Frederick pr_debug(" dblkno: %u\n", fs32_to_cpu(sb, usb1->fs_dblkno));
188a9814c5dSFabian Frederick pr_debug(" cgoffset: %u\n",
189647b7e87SEvgeniy Dushistov fs32_to_cpu(sb, usb1->fs_cgoffset));
190a9814c5dSFabian Frederick pr_debug(" ~cgmask: 0x%x\n",
191647b7e87SEvgeniy Dushistov ~fs32_to_cpu(sb, usb1->fs_cgmask));
192a9814c5dSFabian Frederick pr_debug(" size: %u\n", fs32_to_cpu(sb, usb1->fs_size));
193a9814c5dSFabian Frederick pr_debug(" dsize: %u\n", fs32_to_cpu(sb, usb1->fs_dsize));
194a9814c5dSFabian Frederick pr_debug(" ncg: %u\n", fs32_to_cpu(sb, usb1->fs_ncg));
195a9814c5dSFabian Frederick pr_debug(" bsize: %u\n", fs32_to_cpu(sb, usb1->fs_bsize));
196a9814c5dSFabian Frederick pr_debug(" fsize: %u\n", fs32_to_cpu(sb, usb1->fs_fsize));
197a9814c5dSFabian Frederick pr_debug(" frag: %u\n", fs32_to_cpu(sb, usb1->fs_frag));
198a9814c5dSFabian Frederick pr_debug(" fragshift: %u\n",
199647b7e87SEvgeniy Dushistov fs32_to_cpu(sb, usb1->fs_fragshift));
200a9814c5dSFabian Frederick pr_debug(" ~fmask: %u\n", ~fs32_to_cpu(sb, usb1->fs_fmask));
201a9814c5dSFabian Frederick pr_debug(" fshift: %u\n", fs32_to_cpu(sb, usb1->fs_fshift));
202a9814c5dSFabian Frederick pr_debug(" sbsize: %u\n", fs32_to_cpu(sb, usb1->fs_sbsize));
203a9814c5dSFabian Frederick pr_debug(" spc: %u\n", fs32_to_cpu(sb, usb1->fs_spc));
204a9814c5dSFabian Frederick pr_debug(" cpg: %u\n", fs32_to_cpu(sb, usb1->fs_cpg));
205a9814c5dSFabian Frederick pr_debug(" ipg: %u\n", fs32_to_cpu(sb, usb1->fs_ipg));
206a9814c5dSFabian Frederick pr_debug(" fpg: %u\n", fs32_to_cpu(sb, usb1->fs_fpg));
207a9814c5dSFabian Frederick pr_debug(" csaddr: %u\n", fs32_to_cpu(sb, usb1->fs_csaddr));
208a9814c5dSFabian Frederick pr_debug(" cssize: %u\n", fs32_to_cpu(sb, usb1->fs_cssize));
209a9814c5dSFabian Frederick pr_debug(" cgsize: %u\n", fs32_to_cpu(sb, usb1->fs_cgsize));
210a9814c5dSFabian Frederick pr_debug(" fstodb: %u\n",
211647b7e87SEvgeniy Dushistov fs32_to_cpu(sb, usb1->fs_fsbtodb));
212a9814c5dSFabian Frederick pr_debug(" nrpos: %u\n", fs32_to_cpu(sb, usb3->fs_nrpos));
213a9814c5dSFabian Frederick pr_debug(" ndir %u\n",
214647b7e87SEvgeniy Dushistov fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir));
215a9814c5dSFabian Frederick pr_debug(" nifree %u\n",
216647b7e87SEvgeniy Dushistov fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree));
217a9814c5dSFabian Frederick pr_debug(" nbfree %u\n",
218647b7e87SEvgeniy Dushistov fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree));
219a9814c5dSFabian Frederick pr_debug(" nffree %u\n",
220647b7e87SEvgeniy Dushistov fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree));
2211da177e4SLinus Torvalds }
222a9814c5dSFabian Frederick pr_debug("\n");
2231da177e4SLinus Torvalds }
2241da177e4SLinus Torvalds
2251da177e4SLinus Torvalds /*
2261da177e4SLinus Torvalds * Print contents of ufs_cylinder_group, useful for debugging
2271da177e4SLinus Torvalds */
ufs_print_cylinder_stuff(struct super_block * sb,struct ufs_cylinder_group * cg)228647b7e87SEvgeniy Dushistov static void ufs_print_cylinder_stuff(struct super_block *sb,
229647b7e87SEvgeniy Dushistov struct ufs_cylinder_group *cg)
2301da177e4SLinus Torvalds {
231a9814c5dSFabian Frederick pr_debug("\nufs_print_cylinder_stuff\n");
232a9814c5dSFabian Frederick pr_debug("size of ucg: %zu\n", sizeof(struct ufs_cylinder_group));
233a9814c5dSFabian Frederick pr_debug(" magic: %x\n", fs32_to_cpu(sb, cg->cg_magic));
234a9814c5dSFabian Frederick pr_debug(" time: %u\n", fs32_to_cpu(sb, cg->cg_time));
235a9814c5dSFabian Frederick pr_debug(" cgx: %u\n", fs32_to_cpu(sb, cg->cg_cgx));
236a9814c5dSFabian Frederick pr_debug(" ncyl: %u\n", fs16_to_cpu(sb, cg->cg_ncyl));
237a9814c5dSFabian Frederick pr_debug(" niblk: %u\n", fs16_to_cpu(sb, cg->cg_niblk));
238a9814c5dSFabian Frederick pr_debug(" ndblk: %u\n", fs32_to_cpu(sb, cg->cg_ndblk));
239a9814c5dSFabian Frederick pr_debug(" cs_ndir: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_ndir));
240a9814c5dSFabian Frederick pr_debug(" cs_nbfree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nbfree));
241a9814c5dSFabian Frederick pr_debug(" cs_nifree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nifree));
242a9814c5dSFabian Frederick pr_debug(" cs_nffree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nffree));
243a9814c5dSFabian Frederick pr_debug(" rotor: %u\n", fs32_to_cpu(sb, cg->cg_rotor));
244a9814c5dSFabian Frederick pr_debug(" frotor: %u\n", fs32_to_cpu(sb, cg->cg_frotor));
245a9814c5dSFabian Frederick pr_debug(" irotor: %u\n", fs32_to_cpu(sb, cg->cg_irotor));
246a9814c5dSFabian Frederick pr_debug(" frsum: %u, %u, %u, %u, %u, %u, %u, %u\n",
2471da177e4SLinus Torvalds fs32_to_cpu(sb, cg->cg_frsum[0]), fs32_to_cpu(sb, cg->cg_frsum[1]),
2481da177e4SLinus Torvalds fs32_to_cpu(sb, cg->cg_frsum[2]), fs32_to_cpu(sb, cg->cg_frsum[3]),
2491da177e4SLinus Torvalds fs32_to_cpu(sb, cg->cg_frsum[4]), fs32_to_cpu(sb, cg->cg_frsum[5]),
2501da177e4SLinus Torvalds fs32_to_cpu(sb, cg->cg_frsum[6]), fs32_to_cpu(sb, cg->cg_frsum[7]));
251a9814c5dSFabian Frederick pr_debug(" btotoff: %u\n", fs32_to_cpu(sb, cg->cg_btotoff));
252a9814c5dSFabian Frederick pr_debug(" boff: %u\n", fs32_to_cpu(sb, cg->cg_boff));
253a9814c5dSFabian Frederick pr_debug(" iuseoff: %u\n", fs32_to_cpu(sb, cg->cg_iusedoff));
254a9814c5dSFabian Frederick pr_debug(" freeoff: %u\n", fs32_to_cpu(sb, cg->cg_freeoff));
255a9814c5dSFabian Frederick pr_debug(" nextfreeoff: %u\n", fs32_to_cpu(sb, cg->cg_nextfreeoff));
256a9814c5dSFabian Frederick pr_debug(" clustersumoff %u\n",
257647b7e87SEvgeniy Dushistov fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clustersumoff));
258a9814c5dSFabian Frederick pr_debug(" clusteroff %u\n",
259647b7e87SEvgeniy Dushistov fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clusteroff));
260a9814c5dSFabian Frederick pr_debug(" nclusterblks %u\n",
261647b7e87SEvgeniy Dushistov fs32_to_cpu(sb, cg->cg_u.cg_44.cg_nclusterblks));
262a9814c5dSFabian Frederick pr_debug("\n");
2631da177e4SLinus Torvalds }
264647b7e87SEvgeniy Dushistov #else
2653313e292SEvgeniy Dushistov # define ufs_print_super_stuff(sb, usb1, usb2, usb3) /**/
266647b7e87SEvgeniy Dushistov # define ufs_print_cylinder_stuff(sb, cg) /**/
267abf5d15fSEvgeniy Dushistov #endif /* CONFIG_UFS_DEBUG */
2681da177e4SLinus Torvalds
269ee9b6d61SJosef 'Jeff' Sipek static const struct super_operations ufs_super_ops;
2701da177e4SLinus Torvalds
ufs_error(struct super_block * sb,const char * function,const char * fmt,...)2711da177e4SLinus Torvalds void ufs_error (struct super_block * sb, const char * function,
2721da177e4SLinus Torvalds const char * fmt, ...)
2731da177e4SLinus Torvalds {
2741da177e4SLinus Torvalds struct ufs_sb_private_info * uspi;
2751da177e4SLinus Torvalds struct ufs_super_block_first * usb1;
2767e1e4167SFabian Frederick struct va_format vaf;
2771da177e4SLinus Torvalds va_list args;
2781da177e4SLinus Torvalds
2791da177e4SLinus Torvalds uspi = UFS_SB(sb)->s_uspi;
2807b4ee73eSEvgeniy usb1 = ubh_get_usb_first(uspi);
2811da177e4SLinus Torvalds
282bc98a42cSDavid Howells if (!sb_rdonly(sb)) {
2831da177e4SLinus Torvalds usb1->fs_clean = UFS_FSBAD;
2849695ef16SEvgeniy Dushistov ubh_mark_buffer_dirty(USPI_UBH(uspi));
2859e9ad5f4SArtem Bityutskiy ufs_mark_sb_dirty(sb);
2861751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY;
2871da177e4SLinus Torvalds }
2881da177e4SLinus Torvalds va_start(args, fmt);
2897e1e4167SFabian Frederick vaf.fmt = fmt;
2907e1e4167SFabian Frederick vaf.va = &args;
2911da177e4SLinus Torvalds switch (UFS_SB(sb)->s_mount_opt & UFS_MOUNT_ONERROR) {
2921da177e4SLinus Torvalds case UFS_MOUNT_ONERROR_PANIC:
2937e1e4167SFabian Frederick panic("panic (device %s): %s: %pV\n",
2947e1e4167SFabian Frederick sb->s_id, function, &vaf);
2951da177e4SLinus Torvalds
2961da177e4SLinus Torvalds case UFS_MOUNT_ONERROR_LOCK:
2971da177e4SLinus Torvalds case UFS_MOUNT_ONERROR_UMOUNT:
2981da177e4SLinus Torvalds case UFS_MOUNT_ONERROR_REPAIR:
2997e1e4167SFabian Frederick pr_crit("error (device %s): %s: %pV\n",
3007e1e4167SFabian Frederick sb->s_id, function, &vaf);
3011da177e4SLinus Torvalds }
3027e1e4167SFabian Frederick va_end(args);
3031da177e4SLinus Torvalds }
3041da177e4SLinus Torvalds
ufs_panic(struct super_block * sb,const char * function,const char * fmt,...)3051da177e4SLinus Torvalds void ufs_panic (struct super_block * sb, const char * function,
3061da177e4SLinus Torvalds const char * fmt, ...)
3071da177e4SLinus Torvalds {
3081da177e4SLinus Torvalds struct ufs_sb_private_info * uspi;
3091da177e4SLinus Torvalds struct ufs_super_block_first * usb1;
3107e1e4167SFabian Frederick struct va_format vaf;
3111da177e4SLinus Torvalds va_list args;
3121da177e4SLinus Torvalds
3131da177e4SLinus Torvalds uspi = UFS_SB(sb)->s_uspi;
3147b4ee73eSEvgeniy usb1 = ubh_get_usb_first(uspi);
3151da177e4SLinus Torvalds
316bc98a42cSDavid Howells if (!sb_rdonly(sb)) {
3171da177e4SLinus Torvalds usb1->fs_clean = UFS_FSBAD;
3189695ef16SEvgeniy Dushistov ubh_mark_buffer_dirty(USPI_UBH(uspi));
3199e9ad5f4SArtem Bityutskiy ufs_mark_sb_dirty(sb);
3201da177e4SLinus Torvalds }
3211da177e4SLinus Torvalds va_start(args, fmt);
3227e1e4167SFabian Frederick vaf.fmt = fmt;
3237e1e4167SFabian Frederick vaf.va = &args;
3241751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY;
3257e1e4167SFabian Frederick pr_crit("panic (device %s): %s: %pV\n",
3267e1e4167SFabian Frederick sb->s_id, function, &vaf);
3277e1e4167SFabian Frederick va_end(args);
3281da177e4SLinus Torvalds }
3291da177e4SLinus Torvalds
ufs_warning(struct super_block * sb,const char * function,const char * fmt,...)3301da177e4SLinus Torvalds void ufs_warning (struct super_block * sb, const char * function,
3311da177e4SLinus Torvalds const char * fmt, ...)
3321da177e4SLinus Torvalds {
3337e1e4167SFabian Frederick struct va_format vaf;
3341da177e4SLinus Torvalds va_list args;
3351da177e4SLinus Torvalds
3361da177e4SLinus Torvalds va_start(args, fmt);
3377e1e4167SFabian Frederick vaf.fmt = fmt;
3387e1e4167SFabian Frederick vaf.va = &args;
3397e1e4167SFabian Frederick pr_warn("(device %s): %s: %pV\n",
3407e1e4167SFabian Frederick sb->s_id, function, &vaf);
3411da177e4SLinus Torvalds va_end(args);
3421da177e4SLinus Torvalds }
3431da177e4SLinus Torvalds
3441da177e4SLinus Torvalds enum {
3452a9807c0SEvgeniy Dushistov Opt_type_old = UFS_MOUNT_UFSTYPE_OLD,
3462a9807c0SEvgeniy Dushistov Opt_type_sunx86 = UFS_MOUNT_UFSTYPE_SUNx86,
3472a9807c0SEvgeniy Dushistov Opt_type_sun = UFS_MOUNT_UFSTYPE_SUN,
3482a9807c0SEvgeniy Dushistov Opt_type_sunos = UFS_MOUNT_UFSTYPE_SUNOS,
3492a9807c0SEvgeniy Dushistov Opt_type_44bsd = UFS_MOUNT_UFSTYPE_44BSD,
3502a9807c0SEvgeniy Dushistov Opt_type_ufs2 = UFS_MOUNT_UFSTYPE_UFS2,
3512a9807c0SEvgeniy Dushistov Opt_type_hp = UFS_MOUNT_UFSTYPE_HP,
3522a9807c0SEvgeniy Dushistov Opt_type_nextstepcd = UFS_MOUNT_UFSTYPE_NEXTSTEP_CD,
3532a9807c0SEvgeniy Dushistov Opt_type_nextstep = UFS_MOUNT_UFSTYPE_NEXTSTEP,
3542a9807c0SEvgeniy Dushistov Opt_type_openstep = UFS_MOUNT_UFSTYPE_OPENSTEP,
3552a9807c0SEvgeniy Dushistov Opt_onerror_panic = UFS_MOUNT_ONERROR_PANIC,
3562a9807c0SEvgeniy Dushistov Opt_onerror_lock = UFS_MOUNT_ONERROR_LOCK,
3572a9807c0SEvgeniy Dushistov Opt_onerror_umount = UFS_MOUNT_ONERROR_UMOUNT,
3582a9807c0SEvgeniy Dushistov Opt_onerror_repair = UFS_MOUNT_ONERROR_REPAIR,
3592a9807c0SEvgeniy Dushistov Opt_err
3601da177e4SLinus Torvalds };
3611da177e4SLinus Torvalds
362a447c093SSteven Whitehouse static const match_table_t tokens = {
3631da177e4SLinus Torvalds {Opt_type_old, "ufstype=old"},
3641da177e4SLinus Torvalds {Opt_type_sunx86, "ufstype=sunx86"},
3651da177e4SLinus Torvalds {Opt_type_sun, "ufstype=sun"},
366252e211eSMark Fortescue {Opt_type_sunos, "ufstype=sunos"},
3671da177e4SLinus Torvalds {Opt_type_44bsd, "ufstype=44bsd"},
3681da177e4SLinus Torvalds {Opt_type_ufs2, "ufstype=ufs2"},
3691da177e4SLinus Torvalds {Opt_type_ufs2, "ufstype=5xbsd"},
3701da177e4SLinus Torvalds {Opt_type_hp, "ufstype=hp"},
3711da177e4SLinus Torvalds {Opt_type_nextstepcd, "ufstype=nextstep-cd"},
3721da177e4SLinus Torvalds {Opt_type_nextstep, "ufstype=nextstep"},
3731da177e4SLinus Torvalds {Opt_type_openstep, "ufstype=openstep"},
3742a9807c0SEvgeniy Dushistov /*end of possible ufs types */
3751da177e4SLinus Torvalds {Opt_onerror_panic, "onerror=panic"},
3761da177e4SLinus Torvalds {Opt_onerror_lock, "onerror=lock"},
3771da177e4SLinus Torvalds {Opt_onerror_umount, "onerror=umount"},
3781da177e4SLinus Torvalds {Opt_onerror_repair, "onerror=repair"},
3791da177e4SLinus Torvalds {Opt_err, NULL}
3801da177e4SLinus Torvalds };
3811da177e4SLinus Torvalds
ufs_parse_options(char * options,unsigned * mount_options)3821da177e4SLinus Torvalds static int ufs_parse_options (char * options, unsigned * mount_options)
3831da177e4SLinus Torvalds {
3841da177e4SLinus Torvalds char * p;
3851da177e4SLinus Torvalds
386abf5d15fSEvgeniy Dushistov UFSD("ENTER\n");
3871da177e4SLinus Torvalds
3881da177e4SLinus Torvalds if (!options)
3891da177e4SLinus Torvalds return 1;
3901da177e4SLinus Torvalds
3911da177e4SLinus Torvalds while ((p = strsep(&options, ",")) != NULL) {
3921da177e4SLinus Torvalds substring_t args[MAX_OPT_ARGS];
3931da177e4SLinus Torvalds int token;
3941da177e4SLinus Torvalds if (!*p)
3951da177e4SLinus Torvalds continue;
3961da177e4SLinus Torvalds
3971da177e4SLinus Torvalds token = match_token(p, tokens, args);
3981da177e4SLinus Torvalds switch (token) {
3991da177e4SLinus Torvalds case Opt_type_old:
4001da177e4SLinus Torvalds ufs_clear_opt (*mount_options, UFSTYPE);
4011da177e4SLinus Torvalds ufs_set_opt (*mount_options, UFSTYPE_OLD);
4021da177e4SLinus Torvalds break;
4031da177e4SLinus Torvalds case Opt_type_sunx86:
4041da177e4SLinus Torvalds ufs_clear_opt (*mount_options, UFSTYPE);
4051da177e4SLinus Torvalds ufs_set_opt (*mount_options, UFSTYPE_SUNx86);
4061da177e4SLinus Torvalds break;
4071da177e4SLinus Torvalds case Opt_type_sun:
4081da177e4SLinus Torvalds ufs_clear_opt (*mount_options, UFSTYPE);
4091da177e4SLinus Torvalds ufs_set_opt (*mount_options, UFSTYPE_SUN);
4101da177e4SLinus Torvalds break;
411252e211eSMark Fortescue case Opt_type_sunos:
412252e211eSMark Fortescue ufs_clear_opt(*mount_options, UFSTYPE);
413252e211eSMark Fortescue ufs_set_opt(*mount_options, UFSTYPE_SUNOS);
414252e211eSMark Fortescue break;
4151da177e4SLinus Torvalds case Opt_type_44bsd:
4161da177e4SLinus Torvalds ufs_clear_opt (*mount_options, UFSTYPE);
4171da177e4SLinus Torvalds ufs_set_opt (*mount_options, UFSTYPE_44BSD);
4181da177e4SLinus Torvalds break;
4191da177e4SLinus Torvalds case Opt_type_ufs2:
4201da177e4SLinus Torvalds ufs_clear_opt(*mount_options, UFSTYPE);
4211da177e4SLinus Torvalds ufs_set_opt(*mount_options, UFSTYPE_UFS2);
4221da177e4SLinus Torvalds break;
4231da177e4SLinus Torvalds case Opt_type_hp:
4241da177e4SLinus Torvalds ufs_clear_opt (*mount_options, UFSTYPE);
4251da177e4SLinus Torvalds ufs_set_opt (*mount_options, UFSTYPE_HP);
4261da177e4SLinus Torvalds break;
4271da177e4SLinus Torvalds case Opt_type_nextstepcd:
4281da177e4SLinus Torvalds ufs_clear_opt (*mount_options, UFSTYPE);
4291da177e4SLinus Torvalds ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP_CD);
4301da177e4SLinus Torvalds break;
4311da177e4SLinus Torvalds case Opt_type_nextstep:
4321da177e4SLinus Torvalds ufs_clear_opt (*mount_options, UFSTYPE);
4331da177e4SLinus Torvalds ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP);
4341da177e4SLinus Torvalds break;
4351da177e4SLinus Torvalds case Opt_type_openstep:
4361da177e4SLinus Torvalds ufs_clear_opt (*mount_options, UFSTYPE);
4371da177e4SLinus Torvalds ufs_set_opt (*mount_options, UFSTYPE_OPENSTEP);
4381da177e4SLinus Torvalds break;
4391da177e4SLinus Torvalds case Opt_onerror_panic:
4401da177e4SLinus Torvalds ufs_clear_opt (*mount_options, ONERROR);
4411da177e4SLinus Torvalds ufs_set_opt (*mount_options, ONERROR_PANIC);
4421da177e4SLinus Torvalds break;
4431da177e4SLinus Torvalds case Opt_onerror_lock:
4441da177e4SLinus Torvalds ufs_clear_opt (*mount_options, ONERROR);
4451da177e4SLinus Torvalds ufs_set_opt (*mount_options, ONERROR_LOCK);
4461da177e4SLinus Torvalds break;
4471da177e4SLinus Torvalds case Opt_onerror_umount:
4481da177e4SLinus Torvalds ufs_clear_opt (*mount_options, ONERROR);
4491da177e4SLinus Torvalds ufs_set_opt (*mount_options, ONERROR_UMOUNT);
4501da177e4SLinus Torvalds break;
4511da177e4SLinus Torvalds case Opt_onerror_repair:
452de771bdaSFabian Frederick pr_err("Unable to do repair on error, will lock lock instead\n");
4531da177e4SLinus Torvalds ufs_clear_opt (*mount_options, ONERROR);
4541da177e4SLinus Torvalds ufs_set_opt (*mount_options, ONERROR_REPAIR);
4551da177e4SLinus Torvalds break;
4561da177e4SLinus Torvalds default:
457de771bdaSFabian Frederick pr_err("Invalid option: \"%s\" or missing value\n", p);
4581da177e4SLinus Torvalds return 0;
4591da177e4SLinus Torvalds }
4601da177e4SLinus Torvalds }
4611da177e4SLinus Torvalds return 1;
4621da177e4SLinus Torvalds }
4631da177e4SLinus Torvalds
4641da177e4SLinus Torvalds /*
46525985edcSLucas De Marchi * Different types of UFS hold fs_cstotal in different
46625985edcSLucas De Marchi * places, and use different data structure for it.
46725985edcSLucas De Marchi * To make things simpler we just copy fs_cstotal to ufs_sb_private_info
468ee3ffd6cSEvgeniy Dushistov */
ufs_setup_cstotal(struct super_block * sb)469ee3ffd6cSEvgeniy Dushistov static void ufs_setup_cstotal(struct super_block *sb)
470ee3ffd6cSEvgeniy Dushistov {
471ee3ffd6cSEvgeniy Dushistov struct ufs_sb_info *sbi = UFS_SB(sb);
472ee3ffd6cSEvgeniy Dushistov struct ufs_sb_private_info *uspi = sbi->s_uspi;
473ee3ffd6cSEvgeniy Dushistov struct ufs_super_block_first *usb1;
474ee3ffd6cSEvgeniy Dushistov struct ufs_super_block_second *usb2;
475ee3ffd6cSEvgeniy Dushistov struct ufs_super_block_third *usb3;
476ee3ffd6cSEvgeniy Dushistov unsigned mtype = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE;
477ee3ffd6cSEvgeniy Dushistov
478ee3ffd6cSEvgeniy Dushistov UFSD("ENTER, mtype=%u\n", mtype);
479ee3ffd6cSEvgeniy Dushistov usb1 = ubh_get_usb_first(uspi);
480ee3ffd6cSEvgeniy Dushistov usb2 = ubh_get_usb_second(uspi);
481ee3ffd6cSEvgeniy Dushistov usb3 = ubh_get_usb_third(uspi);
482ee3ffd6cSEvgeniy Dushistov
483ee3ffd6cSEvgeniy Dushistov if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&
48496ecff14SAl Viro (usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) ||
485ee3ffd6cSEvgeniy Dushistov mtype == UFS_MOUNT_UFSTYPE_UFS2) {
486ee3ffd6cSEvgeniy Dushistov /*we have statistic in different place, then usual*/
487ee3ffd6cSEvgeniy Dushistov uspi->cs_total.cs_ndir = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir);
488ee3ffd6cSEvgeniy Dushistov uspi->cs_total.cs_nbfree = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_nbfree);
489ee3ffd6cSEvgeniy Dushistov uspi->cs_total.cs_nifree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nifree);
490ee3ffd6cSEvgeniy Dushistov uspi->cs_total.cs_nffree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nffree);
491ee3ffd6cSEvgeniy Dushistov } else {
492ee3ffd6cSEvgeniy Dushistov uspi->cs_total.cs_ndir = fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir);
493ee3ffd6cSEvgeniy Dushistov uspi->cs_total.cs_nbfree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree);
494ee3ffd6cSEvgeniy Dushistov uspi->cs_total.cs_nifree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree);
495ee3ffd6cSEvgeniy Dushistov uspi->cs_total.cs_nffree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree);
496ee3ffd6cSEvgeniy Dushistov }
497ee3ffd6cSEvgeniy Dushistov UFSD("EXIT\n");
498ee3ffd6cSEvgeniy Dushistov }
499ee3ffd6cSEvgeniy Dushistov
500ee3ffd6cSEvgeniy Dushistov /*
5011da177e4SLinus Torvalds * Read on-disk structures associated with cylinder groups
5021da177e4SLinus Torvalds */
ufs_read_cylinder_structures(struct super_block * sb)503e295cfcbSEvgeniy Dushistov static int ufs_read_cylinder_structures(struct super_block *sb)
504e295cfcbSEvgeniy Dushistov {
5051da177e4SLinus Torvalds struct ufs_sb_info *sbi = UFS_SB(sb);
506647b7e87SEvgeniy Dushistov struct ufs_sb_private_info *uspi = sbi->s_uspi;
5071da177e4SLinus Torvalds struct ufs_buffer_head * ubh;
5081da177e4SLinus Torvalds unsigned char * base, * space;
5091da177e4SLinus Torvalds unsigned size, blks, i;
5101da177e4SLinus Torvalds
511abf5d15fSEvgeniy Dushistov UFSD("ENTER\n");
5121da177e4SLinus Torvalds
5131da177e4SLinus Torvalds /*
5141da177e4SLinus Torvalds * Read cs structures from (usually) first data block
5151da177e4SLinus Torvalds * on the device.
5161da177e4SLinus Torvalds */
5171da177e4SLinus Torvalds size = uspi->s_cssize;
5181da177e4SLinus Torvalds blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
519788257d6SArnd Bergmann base = space = kmalloc(size, GFP_NOFS);
5201da177e4SLinus Torvalds if (!base)
5211da177e4SLinus Torvalds goto failed;
522e295cfcbSEvgeniy Dushistov sbi->s_csp = (struct ufs_csum *)space;
5231da177e4SLinus Torvalds for (i = 0; i < blks; i += uspi->s_fpb) {
5241da177e4SLinus Torvalds size = uspi->s_bsize;
5251da177e4SLinus Torvalds if (i + uspi->s_fpb > blks)
5261da177e4SLinus Torvalds size = (blks - i) * uspi->s_fsize;
5271da177e4SLinus Torvalds
5281da177e4SLinus Torvalds ubh = ubh_bread(sb, uspi->s_csaddr + i, size);
5297b4ee73eSEvgeniy
5301da177e4SLinus Torvalds if (!ubh)
5311da177e4SLinus Torvalds goto failed;
5327b4ee73eSEvgeniy
5331da177e4SLinus Torvalds ubh_ubhcpymem (space, ubh, size);
5347b4ee73eSEvgeniy
5351da177e4SLinus Torvalds space += size;
5361da177e4SLinus Torvalds ubh_brelse (ubh);
5371da177e4SLinus Torvalds ubh = NULL;
5381da177e4SLinus Torvalds }
5391da177e4SLinus Torvalds
5401da177e4SLinus Torvalds /*
5411da177e4SLinus Torvalds * Read cylinder group (we read only first fragment from block
5421da177e4SLinus Torvalds * at this time) and prepare internal data structures for cg caching.
5431da177e4SLinus Torvalds */
5446da2ec56SKees Cook sbi->s_ucg = kmalloc_array(uspi->s_ncg, sizeof(struct buffer_head *),
5456da2ec56SKees Cook GFP_NOFS);
5466da2ec56SKees Cook if (!sbi->s_ucg)
5471da177e4SLinus Torvalds goto failed;
5481da177e4SLinus Torvalds for (i = 0; i < uspi->s_ncg; i++)
5491da177e4SLinus Torvalds sbi->s_ucg[i] = NULL;
5501da177e4SLinus Torvalds for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
5511da177e4SLinus Torvalds sbi->s_ucpi[i] = NULL;
5521da177e4SLinus Torvalds sbi->s_cgno[i] = UFS_CGNO_EMPTY;
5531da177e4SLinus Torvalds }
5541da177e4SLinus Torvalds for (i = 0; i < uspi->s_ncg; i++) {
555abf5d15fSEvgeniy Dushistov UFSD("read cg %u\n", i);
5561da177e4SLinus Torvalds if (!(sbi->s_ucg[i] = sb_bread(sb, ufs_cgcmin(i))))
5571da177e4SLinus Torvalds goto failed;
5581da177e4SLinus Torvalds if (!ufs_cg_chkmagic (sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data))
5591da177e4SLinus Torvalds goto failed;
560647b7e87SEvgeniy Dushistov
5611da177e4SLinus Torvalds ufs_print_cylinder_stuff(sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data);
5621da177e4SLinus Torvalds }
5631da177e4SLinus Torvalds for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
564788257d6SArnd Bergmann if (!(sbi->s_ucpi[i] = kmalloc (sizeof(struct ufs_cg_private_info), GFP_NOFS)))
5651da177e4SLinus Torvalds goto failed;
5661da177e4SLinus Torvalds sbi->s_cgno[i] = UFS_CGNO_EMPTY;
5671da177e4SLinus Torvalds }
5681da177e4SLinus Torvalds sbi->s_cg_loaded = 0;
569abf5d15fSEvgeniy Dushistov UFSD("EXIT\n");
5701da177e4SLinus Torvalds return 1;
5711da177e4SLinus Torvalds
5721da177e4SLinus Torvalds failed:
573f99d49adSJesper Juhl kfree (base);
5741da177e4SLinus Torvalds if (sbi->s_ucg) {
5751da177e4SLinus Torvalds for (i = 0; i < uspi->s_ncg; i++)
576f99d49adSJesper Juhl if (sbi->s_ucg[i])
577f99d49adSJesper Juhl brelse (sbi->s_ucg[i]);
5781da177e4SLinus Torvalds kfree (sbi->s_ucg);
5791da177e4SLinus Torvalds for (i = 0; i < UFS_MAX_GROUP_LOADED; i++)
580f99d49adSJesper Juhl kfree (sbi->s_ucpi[i]);
5811da177e4SLinus Torvalds }
582abf5d15fSEvgeniy Dushistov UFSD("EXIT (FAILED)\n");
5831da177e4SLinus Torvalds return 0;
5841da177e4SLinus Torvalds }
5851da177e4SLinus Torvalds
5861da177e4SLinus Torvalds /*
587ee3ffd6cSEvgeniy Dushistov * Sync our internal copy of fs_cstotal with disk
5881da177e4SLinus Torvalds */
ufs_put_cstotal(struct super_block * sb)589ee3ffd6cSEvgeniy Dushistov static void ufs_put_cstotal(struct super_block *sb)
590ee3ffd6cSEvgeniy Dushistov {
591ee3ffd6cSEvgeniy Dushistov unsigned mtype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE;
592ee3ffd6cSEvgeniy Dushistov struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
593ee3ffd6cSEvgeniy Dushistov struct ufs_super_block_first *usb1;
594ee3ffd6cSEvgeniy Dushistov struct ufs_super_block_second *usb2;
595ee3ffd6cSEvgeniy Dushistov struct ufs_super_block_third *usb3;
596ee3ffd6cSEvgeniy Dushistov
597ee3ffd6cSEvgeniy Dushistov UFSD("ENTER\n");
598ee3ffd6cSEvgeniy Dushistov usb1 = ubh_get_usb_first(uspi);
599ee3ffd6cSEvgeniy Dushistov usb2 = ubh_get_usb_second(uspi);
600ee3ffd6cSEvgeniy Dushistov usb3 = ubh_get_usb_third(uspi);
601ee3ffd6cSEvgeniy Dushistov
60296ecff14SAl Viro if (mtype == UFS_MOUNT_UFSTYPE_UFS2) {
603ee3ffd6cSEvgeniy Dushistov /*we have statistic in different place, then usual*/
604ee3ffd6cSEvgeniy Dushistov usb2->fs_un.fs_u2.cs_ndir =
605ee3ffd6cSEvgeniy Dushistov cpu_to_fs64(sb, uspi->cs_total.cs_ndir);
606ee3ffd6cSEvgeniy Dushistov usb2->fs_un.fs_u2.cs_nbfree =
607ee3ffd6cSEvgeniy Dushistov cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);
608ee3ffd6cSEvgeniy Dushistov usb3->fs_un1.fs_u2.cs_nifree =
609ee3ffd6cSEvgeniy Dushistov cpu_to_fs64(sb, uspi->cs_total.cs_nifree);
610ee3ffd6cSEvgeniy Dushistov usb3->fs_un1.fs_u2.cs_nffree =
611ee3ffd6cSEvgeniy Dushistov cpu_to_fs64(sb, uspi->cs_total.cs_nffree);
61296ecff14SAl Viro goto out;
613ee3ffd6cSEvgeniy Dushistov }
61496ecff14SAl Viro
61596ecff14SAl Viro if (mtype == UFS_MOUNT_UFSTYPE_44BSD &&
61696ecff14SAl Viro (usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) {
61796ecff14SAl Viro /* store stats in both old and new places */
61896ecff14SAl Viro usb2->fs_un.fs_u2.cs_ndir =
61996ecff14SAl Viro cpu_to_fs64(sb, uspi->cs_total.cs_ndir);
62096ecff14SAl Viro usb2->fs_un.fs_u2.cs_nbfree =
62196ecff14SAl Viro cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);
62296ecff14SAl Viro usb3->fs_un1.fs_u2.cs_nifree =
62396ecff14SAl Viro cpu_to_fs64(sb, uspi->cs_total.cs_nifree);
62496ecff14SAl Viro usb3->fs_un1.fs_u2.cs_nffree =
62596ecff14SAl Viro cpu_to_fs64(sb, uspi->cs_total.cs_nffree);
62696ecff14SAl Viro }
62796ecff14SAl Viro usb1->fs_cstotal.cs_ndir = cpu_to_fs32(sb, uspi->cs_total.cs_ndir);
62896ecff14SAl Viro usb1->fs_cstotal.cs_nbfree = cpu_to_fs32(sb, uspi->cs_total.cs_nbfree);
62996ecff14SAl Viro usb1->fs_cstotal.cs_nifree = cpu_to_fs32(sb, uspi->cs_total.cs_nifree);
63096ecff14SAl Viro usb1->fs_cstotal.cs_nffree = cpu_to_fs32(sb, uspi->cs_total.cs_nffree);
63196ecff14SAl Viro out:
632ee3ffd6cSEvgeniy Dushistov ubh_mark_buffer_dirty(USPI_UBH(uspi));
6333313e292SEvgeniy Dushistov ufs_print_super_stuff(sb, usb1, usb2, usb3);
634ee3ffd6cSEvgeniy Dushistov UFSD("EXIT\n");
635ee3ffd6cSEvgeniy Dushistov }
636ee3ffd6cSEvgeniy Dushistov
637ee3ffd6cSEvgeniy Dushistov /**
638ee3ffd6cSEvgeniy Dushistov * ufs_put_super_internal() - put on-disk intrenal structures
639ee3ffd6cSEvgeniy Dushistov * @sb: pointer to super_block structure
640ee3ffd6cSEvgeniy Dushistov * Put on-disk structures associated with cylinder groups
641ee3ffd6cSEvgeniy Dushistov * and write them back to disk, also update cs_total on disk
642ee3ffd6cSEvgeniy Dushistov */
ufs_put_super_internal(struct super_block * sb)643ee3ffd6cSEvgeniy Dushistov static void ufs_put_super_internal(struct super_block *sb)
644e295cfcbSEvgeniy Dushistov {
6451da177e4SLinus Torvalds struct ufs_sb_info *sbi = UFS_SB(sb);
646ee3ffd6cSEvgeniy Dushistov struct ufs_sb_private_info *uspi = sbi->s_uspi;
6471da177e4SLinus Torvalds struct ufs_buffer_head * ubh;
6481da177e4SLinus Torvalds unsigned char * base, * space;
6491da177e4SLinus Torvalds unsigned blks, size, i;
6501da177e4SLinus Torvalds
651ee3ffd6cSEvgeniy Dushistov
652abf5d15fSEvgeniy Dushistov UFSD("ENTER\n");
6536cfd0148SChristoph Hellwig
654ee3ffd6cSEvgeniy Dushistov ufs_put_cstotal(sb);
6551da177e4SLinus Torvalds size = uspi->s_cssize;
6561da177e4SLinus Torvalds blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
657e295cfcbSEvgeniy Dushistov base = space = (char*) sbi->s_csp;
6581da177e4SLinus Torvalds for (i = 0; i < blks; i += uspi->s_fpb) {
6591da177e4SLinus Torvalds size = uspi->s_bsize;
6601da177e4SLinus Torvalds if (i + uspi->s_fpb > blks)
6611da177e4SLinus Torvalds size = (blks - i) * uspi->s_fsize;
6623313e292SEvgeniy Dushistov
6631da177e4SLinus Torvalds ubh = ubh_bread(sb, uspi->s_csaddr + i, size);
6643313e292SEvgeniy Dushistov
6651da177e4SLinus Torvalds ubh_memcpyubh (ubh, space, size);
6661da177e4SLinus Torvalds space += size;
6671da177e4SLinus Torvalds ubh_mark_buffer_uptodate (ubh, 1);
6681da177e4SLinus Torvalds ubh_mark_buffer_dirty (ubh);
6691da177e4SLinus Torvalds ubh_brelse (ubh);
6701da177e4SLinus Torvalds }
6711da177e4SLinus Torvalds for (i = 0; i < sbi->s_cg_loaded; i++) {
6721da177e4SLinus Torvalds ufs_put_cylinder (sb, i);
6731da177e4SLinus Torvalds kfree (sbi->s_ucpi[i]);
6741da177e4SLinus Torvalds }
6751da177e4SLinus Torvalds for (; i < UFS_MAX_GROUP_LOADED; i++)
6761da177e4SLinus Torvalds kfree (sbi->s_ucpi[i]);
6771da177e4SLinus Torvalds for (i = 0; i < uspi->s_ncg; i++)
6781da177e4SLinus Torvalds brelse (sbi->s_ucg[i]);
6791da177e4SLinus Torvalds kfree (sbi->s_ucg);
6801da177e4SLinus Torvalds kfree (base);
6816cfd0148SChristoph Hellwig
682abf5d15fSEvgeniy Dushistov UFSD("EXIT\n");
6831da177e4SLinus Torvalds }
6841da177e4SLinus Torvalds
ufs_sync_fs(struct super_block * sb,int wait)6857bd54ef7SArtem Bityutskiy static int ufs_sync_fs(struct super_block *sb, int wait)
6867bd54ef7SArtem Bityutskiy {
6877bd54ef7SArtem Bityutskiy struct ufs_sb_private_info * uspi;
6887bd54ef7SArtem Bityutskiy struct ufs_super_block_first * usb1;
6897bd54ef7SArtem Bityutskiy struct ufs_super_block_third * usb3;
6907bd54ef7SArtem Bityutskiy unsigned flags;
6917bd54ef7SArtem Bityutskiy
692cdd9eefdSFabian Frederick mutex_lock(&UFS_SB(sb)->s_lock);
6937bd54ef7SArtem Bityutskiy
6947bd54ef7SArtem Bityutskiy UFSD("ENTER\n");
6957bd54ef7SArtem Bityutskiy
6967bd54ef7SArtem Bityutskiy flags = UFS_SB(sb)->s_flags;
6977bd54ef7SArtem Bityutskiy uspi = UFS_SB(sb)->s_uspi;
6987bd54ef7SArtem Bityutskiy usb1 = ubh_get_usb_first(uspi);
6997bd54ef7SArtem Bityutskiy usb3 = ubh_get_usb_third(uspi);
7007bd54ef7SArtem Bityutskiy
701a3fda0ffSArnd Bergmann usb1->fs_time = ufs_get_seconds(sb);
7027bd54ef7SArtem Bityutskiy if ((flags & UFS_ST_MASK) == UFS_ST_SUN ||
7037bd54ef7SArtem Bityutskiy (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
7047bd54ef7SArtem Bityutskiy (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
7057bd54ef7SArtem Bityutskiy ufs_set_fs_state(sb, usb1, usb3,
7067bd54ef7SArtem Bityutskiy UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
7077bd54ef7SArtem Bityutskiy ufs_put_cstotal(sb);
7087bd54ef7SArtem Bityutskiy
7097bd54ef7SArtem Bityutskiy UFSD("EXIT\n");
710cdd9eefdSFabian Frederick mutex_unlock(&UFS_SB(sb)->s_lock);
7117bd54ef7SArtem Bityutskiy
7127bd54ef7SArtem Bityutskiy return 0;
7137bd54ef7SArtem Bityutskiy }
7147bd54ef7SArtem Bityutskiy
delayed_sync_fs(struct work_struct * work)7159e9ad5f4SArtem Bityutskiy static void delayed_sync_fs(struct work_struct *work)
7167bd54ef7SArtem Bityutskiy {
7179e9ad5f4SArtem Bityutskiy struct ufs_sb_info *sbi;
7189e9ad5f4SArtem Bityutskiy
7199e9ad5f4SArtem Bityutskiy sbi = container_of(work, struct ufs_sb_info, sync_work.work);
7209e9ad5f4SArtem Bityutskiy
7219e9ad5f4SArtem Bityutskiy spin_lock(&sbi->work_lock);
7229e9ad5f4SArtem Bityutskiy sbi->work_queued = 0;
7239e9ad5f4SArtem Bityutskiy spin_unlock(&sbi->work_lock);
7249e9ad5f4SArtem Bityutskiy
7259e9ad5f4SArtem Bityutskiy ufs_sync_fs(sbi->sb, 1);
7269e9ad5f4SArtem Bityutskiy }
7279e9ad5f4SArtem Bityutskiy
ufs_mark_sb_dirty(struct super_block * sb)7289e9ad5f4SArtem Bityutskiy void ufs_mark_sb_dirty(struct super_block *sb)
7299e9ad5f4SArtem Bityutskiy {
7309e9ad5f4SArtem Bityutskiy struct ufs_sb_info *sbi = UFS_SB(sb);
7319e9ad5f4SArtem Bityutskiy unsigned long delay;
7329e9ad5f4SArtem Bityutskiy
7339e9ad5f4SArtem Bityutskiy spin_lock(&sbi->work_lock);
7349e9ad5f4SArtem Bityutskiy if (!sbi->work_queued) {
7359e9ad5f4SArtem Bityutskiy delay = msecs_to_jiffies(dirty_writeback_interval * 10);
7369e9ad5f4SArtem Bityutskiy queue_delayed_work(system_long_wq, &sbi->sync_work, delay);
7379e9ad5f4SArtem Bityutskiy sbi->work_queued = 1;
7389e9ad5f4SArtem Bityutskiy }
7399e9ad5f4SArtem Bityutskiy spin_unlock(&sbi->work_lock);
7407bd54ef7SArtem Bityutskiy }
7417bd54ef7SArtem Bityutskiy
ufs_put_super(struct super_block * sb)7427bd54ef7SArtem Bityutskiy static void ufs_put_super(struct super_block *sb)
7437bd54ef7SArtem Bityutskiy {
7447bd54ef7SArtem Bityutskiy struct ufs_sb_info * sbi = UFS_SB(sb);
7457bd54ef7SArtem Bityutskiy
7467bd54ef7SArtem Bityutskiy UFSD("ENTER\n");
7477bd54ef7SArtem Bityutskiy
748bc98a42cSDavid Howells if (!sb_rdonly(sb))
7497bd54ef7SArtem Bityutskiy ufs_put_super_internal(sb);
7509e9ad5f4SArtem Bityutskiy cancel_delayed_work_sync(&sbi->sync_work);
7517bd54ef7SArtem Bityutskiy
7527bd54ef7SArtem Bityutskiy ubh_brelse_uspi (sbi->s_uspi);
7537bd54ef7SArtem Bityutskiy kfree (sbi->s_uspi);
7547bd54ef7SArtem Bityutskiy kfree (sbi);
7557bd54ef7SArtem Bityutskiy sb->s_fs_info = NULL;
7567bd54ef7SArtem Bityutskiy UFSD("EXIT\n");
7577bd54ef7SArtem Bityutskiy return;
7587bd54ef7SArtem Bityutskiy }
7597bd54ef7SArtem Bityutskiy
ufs_max_bytes(struct super_block * sb)7606b0d144fSAl Viro static u64 ufs_max_bytes(struct super_block *sb)
7616b0d144fSAl Viro {
7626b0d144fSAl Viro struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
7636b0d144fSAl Viro int bits = uspi->s_apbshift;
7646b0d144fSAl Viro u64 res;
7656b0d144fSAl Viro
7666b0d144fSAl Viro if (bits > 21)
7676b0d144fSAl Viro res = ~0ULL;
7686b0d144fSAl Viro else
7696b0d144fSAl Viro res = UFS_NDADDR + (1LL << bits) + (1LL << (2*bits)) +
7706b0d144fSAl Viro (1LL << (3*bits));
7716b0d144fSAl Viro
7726b0d144fSAl Viro if (res >= (MAX_LFS_FILESIZE >> uspi->s_bshift))
7736b0d144fSAl Viro return MAX_LFS_FILESIZE;
7746b0d144fSAl Viro return res << uspi->s_bshift;
7756b0d144fSAl Viro }
7766b0d144fSAl Viro
ufs_fill_super(struct super_block * sb,void * data,int silent)7771da177e4SLinus Torvalds static int ufs_fill_super(struct super_block *sb, void *data, int silent)
7781da177e4SLinus Torvalds {
7791da177e4SLinus Torvalds struct ufs_sb_info * sbi;
7801da177e4SLinus Torvalds struct ufs_sb_private_info * uspi;
7811da177e4SLinus Torvalds struct ufs_super_block_first * usb1;
7821da177e4SLinus Torvalds struct ufs_super_block_second * usb2;
7831da177e4SLinus Torvalds struct ufs_super_block_third * usb3;
7841da177e4SLinus Torvalds struct ufs_buffer_head * ubh;
7851da177e4SLinus Torvalds struct inode *inode;
7861da177e4SLinus Torvalds unsigned block_size, super_block_size;
7871da177e4SLinus Torvalds unsigned flags;
7887b4ee73eSEvgeniy unsigned super_block_offset;
7899e6766ccSDuane Griffin unsigned maxsymlen;
790b55c460dSDavid Howells int ret = -EINVAL;
7911da177e4SLinus Torvalds
7921da177e4SLinus Torvalds uspi = NULL;
7931da177e4SLinus Torvalds ubh = NULL;
7941da177e4SLinus Torvalds flags = 0;
7951da177e4SLinus Torvalds
796abf5d15fSEvgeniy Dushistov UFSD("ENTER\n");
7971da177e4SLinus Torvalds
7980244756eSFabian Frederick #ifndef CONFIG_UFS_FS_WRITE
799bc98a42cSDavid Howells if (!sb_rdonly(sb)) {
800a9814c5dSFabian Frederick pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
8010244756eSFabian Frederick return -EROFS;
8020244756eSFabian Frederick }
8030244756eSFabian Frederick #endif
8040244756eSFabian Frederick
805f8314dc6SPanagiotis Issaris sbi = kzalloc(sizeof(struct ufs_sb_info), GFP_KERNEL);
8061da177e4SLinus Torvalds if (!sbi)
8071da177e4SLinus Torvalds goto failed_nomem;
8081da177e4SLinus Torvalds sb->s_fs_info = sbi;
8099e9ad5f4SArtem Bityutskiy sbi->sb = sb;
8101da177e4SLinus Torvalds
811bc98a42cSDavid Howells UFSD("flag %u\n", (int)(sb_rdonly(sb)));
8121da177e4SLinus Torvalds
813e4f95517SFabian Frederick mutex_init(&sbi->s_lock);
8149e9ad5f4SArtem Bityutskiy spin_lock_init(&sbi->work_lock);
8159e9ad5f4SArtem Bityutskiy INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs);
8161da177e4SLinus Torvalds /*
8171da177e4SLinus Torvalds * Set default mount options
8181da177e4SLinus Torvalds * Parse mount options
8191da177e4SLinus Torvalds */
8201da177e4SLinus Torvalds sbi->s_mount_opt = 0;
8211da177e4SLinus Torvalds ufs_set_opt (sbi->s_mount_opt, ONERROR_LOCK);
8221da177e4SLinus Torvalds if (!ufs_parse_options ((char *) data, &sbi->s_mount_opt)) {
823a9814c5dSFabian Frederick pr_err("wrong mount options\n");
8241da177e4SLinus Torvalds goto failed;
8251da177e4SLinus Torvalds }
8261da177e4SLinus Torvalds if (!(sbi->s_mount_opt & UFS_MOUNT_UFSTYPE)) {
8271da177e4SLinus Torvalds if (!silent)
828a9814c5dSFabian Frederick pr_err("You didn't specify the type of your ufs filesystem\n\n"
8291da177e4SLinus Torvalds "mount -t ufs -o ufstype="
830c690a722SMichael Owen "sun|sunx86|44bsd|ufs2|5xbsd|old|hp|nextstep|nextstep-cd|openstep ...\n\n"
8311da177e4SLinus Torvalds ">>>WARNING<<< Wrong ufstype may corrupt your filesystem, "
8321da177e4SLinus Torvalds "default is ufstype=old\n");
8331da177e4SLinus Torvalds ufs_set_opt (sbi->s_mount_opt, UFSTYPE_OLD);
8341da177e4SLinus Torvalds }
8351da177e4SLinus Torvalds
836252e211eSMark Fortescue uspi = kzalloc(sizeof(struct ufs_sb_private_info), GFP_KERNEL);
837252e211eSMark Fortescue sbi->s_uspi = uspi;
8381da177e4SLinus Torvalds if (!uspi)
8391da177e4SLinus Torvalds goto failed;
840f336953bSEvgeniy Dushistov uspi->s_dirblksize = UFS_SECTOR_SIZE;
8417b4ee73eSEvgeniy super_block_offset=UFS_SBLOCK;
8427b4ee73eSEvgeniy
843239e250eSRichard Narron sb->s_maxbytes = MAX_LFS_FILESIZE;
844239e250eSRichard Narron
84522b13969SDeepa Dinamani sb->s_time_gran = NSEC_PER_SEC;
84622b13969SDeepa Dinamani sb->s_time_min = S32_MIN;
84722b13969SDeepa Dinamani sb->s_time_max = S32_MAX;
84822b13969SDeepa Dinamani
8491da177e4SLinus Torvalds switch (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) {
8501da177e4SLinus Torvalds case UFS_MOUNT_UFSTYPE_44BSD:
851abf5d15fSEvgeniy Dushistov UFSD("ufstype=44bsd\n");
8521da177e4SLinus Torvalds uspi->s_fsize = block_size = 512;
8531da177e4SLinus Torvalds uspi->s_fmask = ~(512 - 1);
8541da177e4SLinus Torvalds uspi->s_fshift = 9;
8551da177e4SLinus Torvalds uspi->s_sbsize = super_block_size = 1536;
8561da177e4SLinus Torvalds uspi->s_sbbase = 0;
8571da177e4SLinus Torvalds flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
8581da177e4SLinus Torvalds break;
8591da177e4SLinus Torvalds case UFS_MOUNT_UFSTYPE_UFS2:
860abf5d15fSEvgeniy Dushistov UFSD("ufstype=ufs2\n");
8617b4ee73eSEvgeniy super_block_offset=SBLOCK_UFS2;
8621da177e4SLinus Torvalds uspi->s_fsize = block_size = 512;
8631da177e4SLinus Torvalds uspi->s_fmask = ~(512 - 1);
8641da177e4SLinus Torvalds uspi->s_fshift = 9;
8651da177e4SLinus Torvalds uspi->s_sbsize = super_block_size = 1536;
8661da177e4SLinus Torvalds uspi->s_sbbase = 0;
86722b13969SDeepa Dinamani sb->s_time_gran = 1;
86822b13969SDeepa Dinamani sb->s_time_min = S64_MIN;
86922b13969SDeepa Dinamani sb->s_time_max = S64_MAX;
8701da177e4SLinus Torvalds flags |= UFS_TYPE_UFS2 | UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
8711da177e4SLinus Torvalds break;
8721da177e4SLinus Torvalds
8731da177e4SLinus Torvalds case UFS_MOUNT_UFSTYPE_SUN:
874abf5d15fSEvgeniy Dushistov UFSD("ufstype=sun\n");
8751da177e4SLinus Torvalds uspi->s_fsize = block_size = 1024;
8761da177e4SLinus Torvalds uspi->s_fmask = ~(1024 - 1);
8771da177e4SLinus Torvalds uspi->s_fshift = 10;
8781da177e4SLinus Torvalds uspi->s_sbsize = super_block_size = 2048;
8791da177e4SLinus Torvalds uspi->s_sbbase = 0;
880252e211eSMark Fortescue uspi->s_maxsymlinklen = 0; /* Not supported on disk */
8811da177e4SLinus Torvalds flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUN | UFS_CG_SUN;
8821da177e4SLinus Torvalds break;
8831da177e4SLinus Torvalds
884252e211eSMark Fortescue case UFS_MOUNT_UFSTYPE_SUNOS:
885d4beaabdSFabian Frederick UFSD("ufstype=sunos\n");
886252e211eSMark Fortescue uspi->s_fsize = block_size = 1024;
887252e211eSMark Fortescue uspi->s_fmask = ~(1024 - 1);
888252e211eSMark Fortescue uspi->s_fshift = 10;
889252e211eSMark Fortescue uspi->s_sbsize = 2048;
890252e211eSMark Fortescue super_block_size = 2048;
891252e211eSMark Fortescue uspi->s_sbbase = 0;
892252e211eSMark Fortescue uspi->s_maxsymlinklen = 0; /* Not supported on disk */
893252e211eSMark Fortescue flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_SUNOS | UFS_CG_SUN;
894252e211eSMark Fortescue break;
895252e211eSMark Fortescue
8961da177e4SLinus Torvalds case UFS_MOUNT_UFSTYPE_SUNx86:
897abf5d15fSEvgeniy Dushistov UFSD("ufstype=sunx86\n");
8981da177e4SLinus Torvalds uspi->s_fsize = block_size = 1024;
8991da177e4SLinus Torvalds uspi->s_fmask = ~(1024 - 1);
9001da177e4SLinus Torvalds uspi->s_fshift = 10;
9011da177e4SLinus Torvalds uspi->s_sbsize = super_block_size = 2048;
9021da177e4SLinus Torvalds uspi->s_sbbase = 0;
903252e211eSMark Fortescue uspi->s_maxsymlinklen = 0; /* Not supported on disk */
9041da177e4SLinus Torvalds flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUNx86 | UFS_CG_SUN;
9051da177e4SLinus Torvalds break;
9061da177e4SLinus Torvalds
9071da177e4SLinus Torvalds case UFS_MOUNT_UFSTYPE_OLD:
908abf5d15fSEvgeniy Dushistov UFSD("ufstype=old\n");
9091da177e4SLinus Torvalds uspi->s_fsize = block_size = 1024;
9101da177e4SLinus Torvalds uspi->s_fmask = ~(1024 - 1);
9111da177e4SLinus Torvalds uspi->s_fshift = 10;
9121da177e4SLinus Torvalds uspi->s_sbsize = super_block_size = 2048;
9131da177e4SLinus Torvalds uspi->s_sbbase = 0;
9141da177e4SLinus Torvalds flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
915bc98a42cSDavid Howells if (!sb_rdonly(sb)) {
9161da177e4SLinus Torvalds if (!silent)
917a9814c5dSFabian Frederick pr_info("ufstype=old is supported read-only\n");
9181751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY;
9191da177e4SLinus Torvalds }
9201da177e4SLinus Torvalds break;
9211da177e4SLinus Torvalds
9221da177e4SLinus Torvalds case UFS_MOUNT_UFSTYPE_NEXTSTEP:
923abf5d15fSEvgeniy Dushistov UFSD("ufstype=nextstep\n");
9241da177e4SLinus Torvalds uspi->s_fsize = block_size = 1024;
9251da177e4SLinus Torvalds uspi->s_fmask = ~(1024 - 1);
9261da177e4SLinus Torvalds uspi->s_fshift = 10;
9271da177e4SLinus Torvalds uspi->s_sbsize = super_block_size = 2048;
9281da177e4SLinus Torvalds uspi->s_sbbase = 0;
9290c664f97SEvgeniy Dushistov uspi->s_dirblksize = 1024;
9301da177e4SLinus Torvalds flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
931bc98a42cSDavid Howells if (!sb_rdonly(sb)) {
9321da177e4SLinus Torvalds if (!silent)
933a9814c5dSFabian Frederick pr_info("ufstype=nextstep is supported read-only\n");
9341751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY;
9351da177e4SLinus Torvalds }
9361da177e4SLinus Torvalds break;
9371da177e4SLinus Torvalds
9381da177e4SLinus Torvalds case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD:
939abf5d15fSEvgeniy Dushistov UFSD("ufstype=nextstep-cd\n");
9401da177e4SLinus Torvalds uspi->s_fsize = block_size = 2048;
9411da177e4SLinus Torvalds uspi->s_fmask = ~(2048 - 1);
9421da177e4SLinus Torvalds uspi->s_fshift = 11;
9431da177e4SLinus Torvalds uspi->s_sbsize = super_block_size = 2048;
9441da177e4SLinus Torvalds uspi->s_sbbase = 0;
9450c664f97SEvgeniy Dushistov uspi->s_dirblksize = 1024;
9461da177e4SLinus Torvalds flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
947bc98a42cSDavid Howells if (!sb_rdonly(sb)) {
9481da177e4SLinus Torvalds if (!silent)
949a9814c5dSFabian Frederick pr_info("ufstype=nextstep-cd is supported read-only\n");
9501751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY;
9511da177e4SLinus Torvalds }
9521da177e4SLinus Torvalds break;
9531da177e4SLinus Torvalds
9541da177e4SLinus Torvalds case UFS_MOUNT_UFSTYPE_OPENSTEP:
955abf5d15fSEvgeniy Dushistov UFSD("ufstype=openstep\n");
9561da177e4SLinus Torvalds uspi->s_fsize = block_size = 1024;
9571da177e4SLinus Torvalds uspi->s_fmask = ~(1024 - 1);
9581da177e4SLinus Torvalds uspi->s_fshift = 10;
9591da177e4SLinus Torvalds uspi->s_sbsize = super_block_size = 2048;
9601da177e4SLinus Torvalds uspi->s_sbbase = 0;
961f336953bSEvgeniy Dushistov uspi->s_dirblksize = 1024;
9621da177e4SLinus Torvalds flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
963bc98a42cSDavid Howells if (!sb_rdonly(sb)) {
9641da177e4SLinus Torvalds if (!silent)
965a9814c5dSFabian Frederick pr_info("ufstype=openstep is supported read-only\n");
9661751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY;
9671da177e4SLinus Torvalds }
9681da177e4SLinus Torvalds break;
9691da177e4SLinus Torvalds
9701da177e4SLinus Torvalds case UFS_MOUNT_UFSTYPE_HP:
971abf5d15fSEvgeniy Dushistov UFSD("ufstype=hp\n");
9721da177e4SLinus Torvalds uspi->s_fsize = block_size = 1024;
9731da177e4SLinus Torvalds uspi->s_fmask = ~(1024 - 1);
9741da177e4SLinus Torvalds uspi->s_fshift = 10;
9751da177e4SLinus Torvalds uspi->s_sbsize = super_block_size = 2048;
9761da177e4SLinus Torvalds uspi->s_sbbase = 0;
9771da177e4SLinus Torvalds flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
978bc98a42cSDavid Howells if (!sb_rdonly(sb)) {
9791da177e4SLinus Torvalds if (!silent)
980a9814c5dSFabian Frederick pr_info("ufstype=hp is supported read-only\n");
9811751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY;
9821da177e4SLinus Torvalds }
9831da177e4SLinus Torvalds break;
9841da177e4SLinus Torvalds default:
9851da177e4SLinus Torvalds if (!silent)
986a9814c5dSFabian Frederick pr_err("unknown ufstype\n");
9871da177e4SLinus Torvalds goto failed;
9881da177e4SLinus Torvalds }
9891da177e4SLinus Torvalds
9901da177e4SLinus Torvalds again:
9911da177e4SLinus Torvalds if (!sb_set_blocksize(sb, block_size)) {
992de771bdaSFabian Frederick pr_err("failed to set blocksize\n");
9931da177e4SLinus Torvalds goto failed;
9941da177e4SLinus Torvalds }
9951da177e4SLinus Torvalds
9961da177e4SLinus Torvalds /*
9971da177e4SLinus Torvalds * read ufs super block from device
9981da177e4SLinus Torvalds */
9997b4ee73eSEvgeniy
10007b4ee73eSEvgeniy ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size);
10017b4ee73eSEvgeniy
10021da177e4SLinus Torvalds if (!ubh)
10031da177e4SLinus Torvalds goto failed;
10041da177e4SLinus Torvalds
10057b4ee73eSEvgeniy usb1 = ubh_get_usb_first(uspi);
10067b4ee73eSEvgeniy usb2 = ubh_get_usb_second(uspi);
10077b4ee73eSEvgeniy usb3 = ubh_get_usb_third(uspi);
10081da177e4SLinus Torvalds
1009252e211eSMark Fortescue /* Sort out mod used on SunOS 4.1.3 for fs_state */
1010252e211eSMark Fortescue uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);
1011252e211eSMark Fortescue if (((flags & UFS_ST_MASK) == UFS_ST_SUNOS) &&
1012252e211eSMark Fortescue (uspi->s_postblformat != UFS_42POSTBLFMT)) {
1013252e211eSMark Fortescue flags &= ~UFS_ST_MASK;
1014252e211eSMark Fortescue flags |= UFS_ST_SUN;
1015252e211eSMark Fortescue }
1016252e211eSMark Fortescue
101796ecff14SAl Viro if ((flags & UFS_ST_MASK) == UFS_ST_44BSD &&
101896ecff14SAl Viro uspi->s_postblformat == UFS_42POSTBLFMT) {
101996ecff14SAl Viro if (!silent)
102096ecff14SAl Viro pr_err("this is not a 44bsd filesystem");
102196ecff14SAl Viro goto failed;
102296ecff14SAl Viro }
102396ecff14SAl Viro
10241da177e4SLinus Torvalds /*
10251da177e4SLinus Torvalds * Check ufs magic number
10261da177e4SLinus Torvalds */
10271da177e4SLinus Torvalds sbi->s_bytesex = BYTESEX_LE;
10281da177e4SLinus Torvalds switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
10291da177e4SLinus Torvalds case UFS_MAGIC:
1030d27d7a9aSThomas Stewart case UFS_MAGIC_BW:
10311da177e4SLinus Torvalds case UFS2_MAGIC:
10321da177e4SLinus Torvalds case UFS_MAGIC_LFN:
10331da177e4SLinus Torvalds case UFS_MAGIC_FEA:
10341da177e4SLinus Torvalds case UFS_MAGIC_4GB:
10351da177e4SLinus Torvalds goto magic_found;
10361da177e4SLinus Torvalds }
10371da177e4SLinus Torvalds sbi->s_bytesex = BYTESEX_BE;
10381da177e4SLinus Torvalds switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
10391da177e4SLinus Torvalds case UFS_MAGIC:
1040d27d7a9aSThomas Stewart case UFS_MAGIC_BW:
10411da177e4SLinus Torvalds case UFS2_MAGIC:
10421da177e4SLinus Torvalds case UFS_MAGIC_LFN:
10431da177e4SLinus Torvalds case UFS_MAGIC_FEA:
10441da177e4SLinus Torvalds case UFS_MAGIC_4GB:
10451da177e4SLinus Torvalds goto magic_found;
10461da177e4SLinus Torvalds }
10471da177e4SLinus Torvalds
10481da177e4SLinus Torvalds if ((((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP)
10491da177e4SLinus Torvalds || ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD)
10501da177e4SLinus Torvalds || ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_OPENSTEP))
10511da177e4SLinus Torvalds && uspi->s_sbbase < 256) {
10521da177e4SLinus Torvalds ubh_brelse_uspi(uspi);
10531da177e4SLinus Torvalds ubh = NULL;
10541da177e4SLinus Torvalds uspi->s_sbbase += 8;
10551da177e4SLinus Torvalds goto again;
10561da177e4SLinus Torvalds }
10571da177e4SLinus Torvalds if (!silent)
105807bc94fdSFabian Frederick pr_err("%s(): bad magic number\n", __func__);
10591da177e4SLinus Torvalds goto failed;
10601da177e4SLinus Torvalds
10611da177e4SLinus Torvalds magic_found:
10621da177e4SLinus Torvalds /*
10631da177e4SLinus Torvalds * Check block and fragment sizes
10641da177e4SLinus Torvalds */
10651da177e4SLinus Torvalds uspi->s_bsize = fs32_to_cpu(sb, usb1->fs_bsize);
10661da177e4SLinus Torvalds uspi->s_fsize = fs32_to_cpu(sb, usb1->fs_fsize);
10671da177e4SLinus Torvalds uspi->s_sbsize = fs32_to_cpu(sb, usb1->fs_sbsize);
10681da177e4SLinus Torvalds uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
10691da177e4SLinus Torvalds uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
10701da177e4SLinus Torvalds
10719e8c4273Svignesh babu if (!is_power_of_2(uspi->s_fsize)) {
107207bc94fdSFabian Frederick pr_err("%s(): fragment size %u is not a power of 2\n",
107307bc94fdSFabian Frederick __func__, uspi->s_fsize);
10741da177e4SLinus Torvalds goto failed;
10751da177e4SLinus Torvalds }
10761da177e4SLinus Torvalds if (uspi->s_fsize < 512) {
107707bc94fdSFabian Frederick pr_err("%s(): fragment size %u is too small\n",
107807bc94fdSFabian Frederick __func__, uspi->s_fsize);
10791da177e4SLinus Torvalds goto failed;
10801da177e4SLinus Torvalds }
10811da177e4SLinus Torvalds if (uspi->s_fsize > 4096) {
108207bc94fdSFabian Frederick pr_err("%s(): fragment size %u is too large\n",
108307bc94fdSFabian Frederick __func__, uspi->s_fsize);
10841da177e4SLinus Torvalds goto failed;
10851da177e4SLinus Torvalds }
10869e8c4273Svignesh babu if (!is_power_of_2(uspi->s_bsize)) {
108707bc94fdSFabian Frederick pr_err("%s(): block size %u is not a power of 2\n",
108807bc94fdSFabian Frederick __func__, uspi->s_bsize);
10891da177e4SLinus Torvalds goto failed;
10901da177e4SLinus Torvalds }
10911da177e4SLinus Torvalds if (uspi->s_bsize < 4096) {
109207bc94fdSFabian Frederick pr_err("%s(): block size %u is too small\n",
109307bc94fdSFabian Frederick __func__, uspi->s_bsize);
10941da177e4SLinus Torvalds goto failed;
10951da177e4SLinus Torvalds }
10961da177e4SLinus Torvalds if (uspi->s_bsize / uspi->s_fsize > 8) {
109707bc94fdSFabian Frederick pr_err("%s(): too many fragments per block (%u)\n",
109807bc94fdSFabian Frederick __func__, uspi->s_bsize / uspi->s_fsize);
10991da177e4SLinus Torvalds goto failed;
11001da177e4SLinus Torvalds }
11011da177e4SLinus Torvalds if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) {
11021da177e4SLinus Torvalds ubh_brelse_uspi(uspi);
11031da177e4SLinus Torvalds ubh = NULL;
11041da177e4SLinus Torvalds block_size = uspi->s_fsize;
11051da177e4SLinus Torvalds super_block_size = uspi->s_sbsize;
1106abf5d15fSEvgeniy Dushistov UFSD("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size);
11071da177e4SLinus Torvalds goto again;
11081da177e4SLinus Torvalds }
11091da177e4SLinus Torvalds
1110f664f1f9SAndrew Morton sbi->s_flags = flags;/*after that line some functions use s_flags*/
11113313e292SEvgeniy Dushistov ufs_print_super_stuff(sb, usb1, usb2, usb3);
11121da177e4SLinus Torvalds
11131da177e4SLinus Torvalds /*
11141da177e4SLinus Torvalds * Check, if file system was correctly unmounted.
11151da177e4SLinus Torvalds * If not, make it read only.
11161da177e4SLinus Torvalds */
1117f664f1f9SAndrew Morton if (((flags & UFS_ST_MASK) == UFS_ST_44BSD) ||
11181da177e4SLinus Torvalds ((flags & UFS_ST_MASK) == UFS_ST_OLD) ||
1119f664f1f9SAndrew Morton (((flags & UFS_ST_MASK) == UFS_ST_SUN ||
1120f664f1f9SAndrew Morton (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
1121f664f1f9SAndrew Morton (flags & UFS_ST_MASK) == UFS_ST_SUNx86) &&
1122f664f1f9SAndrew Morton (ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time))))) {
11231da177e4SLinus Torvalds switch(usb1->fs_clean) {
11241da177e4SLinus Torvalds case UFS_FSCLEAN:
1125abf5d15fSEvgeniy Dushistov UFSD("fs is clean\n");
11261da177e4SLinus Torvalds break;
11271da177e4SLinus Torvalds case UFS_FSSTABLE:
1128abf5d15fSEvgeniy Dushistov UFSD("fs is stable\n");
11291da177e4SLinus Torvalds break;
1130b3a0fd4dSAlex Viskovatoff case UFS_FSLOG:
1131b3a0fd4dSAlex Viskovatoff UFSD("fs is logging fs\n");
1132b3a0fd4dSAlex Viskovatoff break;
11331da177e4SLinus Torvalds case UFS_FSOSF1:
1134abf5d15fSEvgeniy Dushistov UFSD("fs is DEC OSF/1\n");
11351da177e4SLinus Torvalds break;
11361da177e4SLinus Torvalds case UFS_FSACTIVE:
113707bc94fdSFabian Frederick pr_err("%s(): fs is active\n", __func__);
11381751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY;
11391da177e4SLinus Torvalds break;
11401da177e4SLinus Torvalds case UFS_FSBAD:
114107bc94fdSFabian Frederick pr_err("%s(): fs is bad\n", __func__);
11421751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY;
11431da177e4SLinus Torvalds break;
11441da177e4SLinus Torvalds default:
114507bc94fdSFabian Frederick pr_err("%s(): can't grok fs_clean 0x%x\n",
114607bc94fdSFabian Frederick __func__, usb1->fs_clean);
11471751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY;
11481da177e4SLinus Torvalds break;
11491da177e4SLinus Torvalds }
1150ee3ffd6cSEvgeniy Dushistov } else {
115107bc94fdSFabian Frederick pr_err("%s(): fs needs fsck\n", __func__);
11521751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY;
11531da177e4SLinus Torvalds }
11541da177e4SLinus Torvalds
11551da177e4SLinus Torvalds /*
11561da177e4SLinus Torvalds * Read ufs_super_block into internal data structures
11571da177e4SLinus Torvalds */
11581da177e4SLinus Torvalds sb->s_op = &ufs_super_ops;
1159f3e2a520SAlexey Dobriyan sb->s_export_op = &ufs_export_ops;
1160123e9cafSChristoph Hellwig
11611da177e4SLinus Torvalds sb->s_magic = fs32_to_cpu(sb, usb3->fs_magic);
11621da177e4SLinus Torvalds
11631da177e4SLinus Torvalds uspi->s_sblkno = fs32_to_cpu(sb, usb1->fs_sblkno);
11641da177e4SLinus Torvalds uspi->s_cblkno = fs32_to_cpu(sb, usb1->fs_cblkno);
11651da177e4SLinus Torvalds uspi->s_iblkno = fs32_to_cpu(sb, usb1->fs_iblkno);
11661da177e4SLinus Torvalds uspi->s_dblkno = fs32_to_cpu(sb, usb1->fs_dblkno);
11671da177e4SLinus Torvalds uspi->s_cgoffset = fs32_to_cpu(sb, usb1->fs_cgoffset);
11681da177e4SLinus Torvalds uspi->s_cgmask = fs32_to_cpu(sb, usb1->fs_cgmask);
11691da177e4SLinus Torvalds
11701da177e4SLinus Torvalds if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
1171c596961dSAl Viro uspi->s_size = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size);
1172c596961dSAl Viro uspi->s_dsize = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);
1173647b7e87SEvgeniy Dushistov } else {
11741da177e4SLinus Torvalds uspi->s_size = fs32_to_cpu(sb, usb1->fs_size);
11751da177e4SLinus Torvalds uspi->s_dsize = fs32_to_cpu(sb, usb1->fs_dsize);
11761da177e4SLinus Torvalds }
11771da177e4SLinus Torvalds
11781da177e4SLinus Torvalds uspi->s_ncg = fs32_to_cpu(sb, usb1->fs_ncg);
11791da177e4SLinus Torvalds /* s_bsize already set */
11801da177e4SLinus Torvalds /* s_fsize already set */
11811da177e4SLinus Torvalds uspi->s_fpb = fs32_to_cpu(sb, usb1->fs_frag);
11821da177e4SLinus Torvalds uspi->s_minfree = fs32_to_cpu(sb, usb1->fs_minfree);
11831da177e4SLinus Torvalds uspi->s_bmask = fs32_to_cpu(sb, usb1->fs_bmask);
11841da177e4SLinus Torvalds uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
11851da177e4SLinus Torvalds uspi->s_bshift = fs32_to_cpu(sb, usb1->fs_bshift);
11861da177e4SLinus Torvalds uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
1187abf5d15fSEvgeniy Dushistov UFSD("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi->s_bshift,
1188abf5d15fSEvgeniy Dushistov uspi->s_fshift);
11891da177e4SLinus Torvalds uspi->s_fpbshift = fs32_to_cpu(sb, usb1->fs_fragshift);
11901da177e4SLinus Torvalds uspi->s_fsbtodb = fs32_to_cpu(sb, usb1->fs_fsbtodb);
11911da177e4SLinus Torvalds /* s_sbsize already set */
11921da177e4SLinus Torvalds uspi->s_csmask = fs32_to_cpu(sb, usb1->fs_csmask);
11931da177e4SLinus Torvalds uspi->s_csshift = fs32_to_cpu(sb, usb1->fs_csshift);
11941da177e4SLinus Torvalds uspi->s_nindir = fs32_to_cpu(sb, usb1->fs_nindir);
11951da177e4SLinus Torvalds uspi->s_inopb = fs32_to_cpu(sb, usb1->fs_inopb);
11961da177e4SLinus Torvalds uspi->s_nspf = fs32_to_cpu(sb, usb1->fs_nspf);
11971da177e4SLinus Torvalds uspi->s_npsect = ufs_get_fs_npsect(sb, usb1, usb3);
11981da177e4SLinus Torvalds uspi->s_interleave = fs32_to_cpu(sb, usb1->fs_interleave);
11991da177e4SLinus Torvalds uspi->s_trackskew = fs32_to_cpu(sb, usb1->fs_trackskew);
12003313e292SEvgeniy Dushistov
12013313e292SEvgeniy Dushistov if (uspi->fs_magic == UFS2_MAGIC)
12023313e292SEvgeniy Dushistov uspi->s_csaddr = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_csaddr);
12033313e292SEvgeniy Dushistov else
12041da177e4SLinus Torvalds uspi->s_csaddr = fs32_to_cpu(sb, usb1->fs_csaddr);
12053313e292SEvgeniy Dushistov
12061da177e4SLinus Torvalds uspi->s_cssize = fs32_to_cpu(sb, usb1->fs_cssize);
12071da177e4SLinus Torvalds uspi->s_cgsize = fs32_to_cpu(sb, usb1->fs_cgsize);
12081da177e4SLinus Torvalds uspi->s_ntrak = fs32_to_cpu(sb, usb1->fs_ntrak);
12091da177e4SLinus Torvalds uspi->s_nsect = fs32_to_cpu(sb, usb1->fs_nsect);
12101da177e4SLinus Torvalds uspi->s_spc = fs32_to_cpu(sb, usb1->fs_spc);
12111da177e4SLinus Torvalds uspi->s_ipg = fs32_to_cpu(sb, usb1->fs_ipg);
12121da177e4SLinus Torvalds uspi->s_fpg = fs32_to_cpu(sb, usb1->fs_fpg);
1213647b7e87SEvgeniy Dushistov uspi->s_cpc = fs32_to_cpu(sb, usb2->fs_un.fs_u1.fs_cpc);
1214647b7e87SEvgeniy Dushistov uspi->s_contigsumsize = fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_contigsumsize);
12151da177e4SLinus Torvalds uspi->s_qbmask = ufs_get_fs_qbmask(sb, usb3);
12161da177e4SLinus Torvalds uspi->s_qfmask = ufs_get_fs_qfmask(sb, usb3);
12171da177e4SLinus Torvalds uspi->s_nrpos = fs32_to_cpu(sb, usb3->fs_nrpos);
12181da177e4SLinus Torvalds uspi->s_postbloff = fs32_to_cpu(sb, usb3->fs_postbloff);
12191da177e4SLinus Torvalds uspi->s_rotbloff = fs32_to_cpu(sb, usb3->fs_rotbloff);
12201da177e4SLinus Torvalds
1221c596961dSAl Viro uspi->s_root_blocks = mul_u64_u32_div(uspi->s_dsize,
1222c596961dSAl Viro uspi->s_minfree, 100);
122377e9ce32SAl Viro if (uspi->s_minfree <= 5) {
122477e9ce32SAl Viro uspi->s_time_to_space = ~0ULL;
122577e9ce32SAl Viro uspi->s_space_to_time = 0;
122677e9ce32SAl Viro usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTSPACE);
122777e9ce32SAl Viro } else {
122877e9ce32SAl Viro uspi->s_time_to_space = (uspi->s_root_blocks / 2) + 1;
122977e9ce32SAl Viro uspi->s_space_to_time = mul_u64_u32_div(uspi->s_dsize,
123077e9ce32SAl Viro uspi->s_minfree - 2, 100) - 1;
123177e9ce32SAl Viro }
1232c596961dSAl Viro
12331da177e4SLinus Torvalds /*
12341da177e4SLinus Torvalds * Compute another frequently used values
12351da177e4SLinus Torvalds */
12361da177e4SLinus Torvalds uspi->s_fpbmask = uspi->s_fpb - 1;
1237abf5d15fSEvgeniy Dushistov if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
12381da177e4SLinus Torvalds uspi->s_apbshift = uspi->s_bshift - 3;
1239abf5d15fSEvgeniy Dushistov else
12401da177e4SLinus Torvalds uspi->s_apbshift = uspi->s_bshift - 2;
1241abf5d15fSEvgeniy Dushistov
12421da177e4SLinus Torvalds uspi->s_2apbshift = uspi->s_apbshift * 2;
12431da177e4SLinus Torvalds uspi->s_3apbshift = uspi->s_apbshift * 3;
12441da177e4SLinus Torvalds uspi->s_apb = 1 << uspi->s_apbshift;
12451da177e4SLinus Torvalds uspi->s_2apb = 1 << uspi->s_2apbshift;
12461da177e4SLinus Torvalds uspi->s_3apb = 1 << uspi->s_3apbshift;
12471da177e4SLinus Torvalds uspi->s_apbmask = uspi->s_apb - 1;
12481da177e4SLinus Torvalds uspi->s_nspfshift = uspi->s_fshift - UFS_SECTOR_BITS;
12491da177e4SLinus Torvalds uspi->s_nspb = uspi->s_nspf << uspi->s_fpbshift;
12501da177e4SLinus Torvalds uspi->s_inopf = uspi->s_inopb >> uspi->s_fpbshift;
12511da177e4SLinus Torvalds uspi->s_bpf = uspi->s_fsize << 3;
12521da177e4SLinus Torvalds uspi->s_bpfshift = uspi->s_fshift + 3;
12531da177e4SLinus Torvalds uspi->s_bpfmask = uspi->s_bpf - 1;
125490b315afSEvgeniy Dushistov if ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_44BSD ||
125590b315afSEvgeniy Dushistov (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_UFS2)
12561da177e4SLinus Torvalds uspi->s_maxsymlinklen =
1257647b7e87SEvgeniy Dushistov fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen);
12581da177e4SLinus Torvalds
12599e6766ccSDuane Griffin if (uspi->fs_magic == UFS2_MAGIC)
12609e6766ccSDuane Griffin maxsymlen = 2 * 4 * (UFS_NDADDR + UFS_NINDIR);
12619e6766ccSDuane Griffin else
12629e6766ccSDuane Griffin maxsymlen = 4 * (UFS_NDADDR + UFS_NINDIR);
12639e6766ccSDuane Griffin if (uspi->s_maxsymlinklen > maxsymlen) {
12649e6766ccSDuane Griffin ufs_warning(sb, __func__, "ufs_read_super: excessive maximum "
12659e6766ccSDuane Griffin "fast symlink size (%u)\n", uspi->s_maxsymlinklen);
12669e6766ccSDuane Griffin uspi->s_maxsymlinklen = maxsymlen;
12679e6766ccSDuane Griffin }
12686b0d144fSAl Viro sb->s_maxbytes = ufs_max_bytes(sb);
12698de52778SAl Viro sb->s_max_links = UFS_LINK_MAX;
12709e6766ccSDuane Griffin
1271b55c460dSDavid Howells inode = ufs_iget(sb, UFS_ROOTINO);
1272b55c460dSDavid Howells if (IS_ERR(inode)) {
1273b55c460dSDavid Howells ret = PTR_ERR(inode);
12741da177e4SLinus Torvalds goto failed;
1275b55c460dSDavid Howells }
127648fde701SAl Viro sb->s_root = d_make_root(inode);
1277b55c460dSDavid Howells if (!sb->s_root) {
1278b55c460dSDavid Howells ret = -ENOMEM;
127948fde701SAl Viro goto failed;
1280b55c460dSDavid Howells }
12811da177e4SLinus Torvalds
1282ee3ffd6cSEvgeniy Dushistov ufs_setup_cstotal(sb);
12831da177e4SLinus Torvalds /*
12841da177e4SLinus Torvalds * Read cylinder group structures
12851da177e4SLinus Torvalds */
1286bc98a42cSDavid Howells if (!sb_rdonly(sb))
12871da177e4SLinus Torvalds if (!ufs_read_cylinder_structures(sb))
12881da177e4SLinus Torvalds goto failed;
12891da177e4SLinus Torvalds
1290abf5d15fSEvgeniy Dushistov UFSD("EXIT\n");
12911da177e4SLinus Torvalds return 0;
12921da177e4SLinus Torvalds
12931da177e4SLinus Torvalds failed:
1294f99d49adSJesper Juhl if (ubh)
1295f99d49adSJesper Juhl ubh_brelse_uspi (uspi);
1296f99d49adSJesper Juhl kfree (uspi);
1297f99d49adSJesper Juhl kfree(sbi);
12981da177e4SLinus Torvalds sb->s_fs_info = NULL;
1299abf5d15fSEvgeniy Dushistov UFSD("EXIT (FAILED)\n");
1300b55c460dSDavid Howells return ret;
13011da177e4SLinus Torvalds
13021da177e4SLinus Torvalds failed_nomem:
1303abf5d15fSEvgeniy Dushistov UFSD("EXIT (NOMEM)\n");
13041da177e4SLinus Torvalds return -ENOMEM;
13051da177e4SLinus Torvalds }
13061da177e4SLinus Torvalds
ufs_remount(struct super_block * sb,int * mount_flags,char * data)13071da177e4SLinus Torvalds static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
13081da177e4SLinus Torvalds {
13091da177e4SLinus Torvalds struct ufs_sb_private_info * uspi;
13101da177e4SLinus Torvalds struct ufs_super_block_first * usb1;
13111da177e4SLinus Torvalds struct ufs_super_block_third * usb3;
13121da177e4SLinus Torvalds unsigned new_mount_opt, ufstype;
13131da177e4SLinus Torvalds unsigned flags;
13141da177e4SLinus Torvalds
131502b9984dSTheodore Ts'o sync_filesystem(sb);
1316cdd9eefdSFabian Frederick mutex_lock(&UFS_SB(sb)->s_lock);
13171da177e4SLinus Torvalds uspi = UFS_SB(sb)->s_uspi;
13181da177e4SLinus Torvalds flags = UFS_SB(sb)->s_flags;
13197b4ee73eSEvgeniy usb1 = ubh_get_usb_first(uspi);
13207b4ee73eSEvgeniy usb3 = ubh_get_usb_third(uspi);
13211da177e4SLinus Torvalds
13221da177e4SLinus Torvalds /*
13231da177e4SLinus Torvalds * Allow the "check" option to be passed as a remount option.
13241da177e4SLinus Torvalds * It is not possible to change ufstype option during remount
13251da177e4SLinus Torvalds */
13261da177e4SLinus Torvalds ufstype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE;
13271da177e4SLinus Torvalds new_mount_opt = 0;
13281da177e4SLinus Torvalds ufs_set_opt (new_mount_opt, ONERROR_LOCK);
1329bbd6851aSAl Viro if (!ufs_parse_options (data, &new_mount_opt)) {
1330cdd9eefdSFabian Frederick mutex_unlock(&UFS_SB(sb)->s_lock);
13311da177e4SLinus Torvalds return -EINVAL;
1332bbd6851aSAl Viro }
13331da177e4SLinus Torvalds if (!(new_mount_opt & UFS_MOUNT_UFSTYPE)) {
13341da177e4SLinus Torvalds new_mount_opt |= ufstype;
1335ee3ffd6cSEvgeniy Dushistov } else if ((new_mount_opt & UFS_MOUNT_UFSTYPE) != ufstype) {
1336a9814c5dSFabian Frederick pr_err("ufstype can't be changed during remount\n");
1337cdd9eefdSFabian Frederick mutex_unlock(&UFS_SB(sb)->s_lock);
13381da177e4SLinus Torvalds return -EINVAL;
13391da177e4SLinus Torvalds }
13401da177e4SLinus Torvalds
13411751e8a6SLinus Torvalds if ((bool)(*mount_flags & SB_RDONLY) == sb_rdonly(sb)) {
13421da177e4SLinus Torvalds UFS_SB(sb)->s_mount_opt = new_mount_opt;
1343cdd9eefdSFabian Frederick mutex_unlock(&UFS_SB(sb)->s_lock);
13441da177e4SLinus Torvalds return 0;
13451da177e4SLinus Torvalds }
13461da177e4SLinus Torvalds
13471da177e4SLinus Torvalds /*
13481da177e4SLinus Torvalds * fs was mouted as rw, remounting ro
13491da177e4SLinus Torvalds */
13501751e8a6SLinus Torvalds if (*mount_flags & SB_RDONLY) {
1351ee3ffd6cSEvgeniy Dushistov ufs_put_super_internal(sb);
1352a3fda0ffSArnd Bergmann usb1->fs_time = ufs_get_seconds(sb);
13531da177e4SLinus Torvalds if ((flags & UFS_ST_MASK) == UFS_ST_SUN
1354252e211eSMark Fortescue || (flags & UFS_ST_MASK) == UFS_ST_SUNOS
13551da177e4SLinus Torvalds || (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
13561da177e4SLinus Torvalds ufs_set_fs_state(sb, usb1, usb3,
13571da177e4SLinus Torvalds UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
13589695ef16SEvgeniy Dushistov ubh_mark_buffer_dirty (USPI_UBH(uspi));
13591751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY;
1360ee3ffd6cSEvgeniy Dushistov } else {
13611da177e4SLinus Torvalds /*
13621da177e4SLinus Torvalds * fs was mounted as ro, remounting rw
13631da177e4SLinus Torvalds */
13641da177e4SLinus Torvalds #ifndef CONFIG_UFS_FS_WRITE
1365a9814c5dSFabian Frederick pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
1366cdd9eefdSFabian Frederick mutex_unlock(&UFS_SB(sb)->s_lock);
13671da177e4SLinus Torvalds return -EINVAL;
13681da177e4SLinus Torvalds #else
13691da177e4SLinus Torvalds if (ufstype != UFS_MOUNT_UFSTYPE_SUN &&
1370252e211eSMark Fortescue ufstype != UFS_MOUNT_UFSTYPE_SUNOS &&
13711da177e4SLinus Torvalds ufstype != UFS_MOUNT_UFSTYPE_44BSD &&
1372cbcae39fSEvgeniy Dushistov ufstype != UFS_MOUNT_UFSTYPE_SUNx86 &&
1373cbcae39fSEvgeniy Dushistov ufstype != UFS_MOUNT_UFSTYPE_UFS2) {
1374a9814c5dSFabian Frederick pr_err("this ufstype is read-only supported\n");
1375cdd9eefdSFabian Frederick mutex_unlock(&UFS_SB(sb)->s_lock);
13761da177e4SLinus Torvalds return -EINVAL;
13771da177e4SLinus Torvalds }
13781da177e4SLinus Torvalds if (!ufs_read_cylinder_structures(sb)) {
1379a9814c5dSFabian Frederick pr_err("failed during remounting\n");
1380cdd9eefdSFabian Frederick mutex_unlock(&UFS_SB(sb)->s_lock);
13811da177e4SLinus Torvalds return -EPERM;
13821da177e4SLinus Torvalds }
13831751e8a6SLinus Torvalds sb->s_flags &= ~SB_RDONLY;
13841da177e4SLinus Torvalds #endif
13851da177e4SLinus Torvalds }
13861da177e4SLinus Torvalds UFS_SB(sb)->s_mount_opt = new_mount_opt;
1387cdd9eefdSFabian Frederick mutex_unlock(&UFS_SB(sb)->s_lock);
13881da177e4SLinus Torvalds return 0;
13891da177e4SLinus Torvalds }
13901da177e4SLinus Torvalds
ufs_show_options(struct seq_file * seq,struct dentry * root)139134c80b1dSAl Viro static int ufs_show_options(struct seq_file *seq, struct dentry *root)
13922a9807c0SEvgeniy Dushistov {
139334c80b1dSAl Viro struct ufs_sb_info *sbi = UFS_SB(root->d_sb);
13942a9807c0SEvgeniy Dushistov unsigned mval = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE;
1395a447c093SSteven Whitehouse const struct match_token *tp = tokens;
13962a9807c0SEvgeniy Dushistov
13972a9807c0SEvgeniy Dushistov while (tp->token != Opt_onerror_panic && tp->token != mval)
13982a9807c0SEvgeniy Dushistov ++tp;
13992a9807c0SEvgeniy Dushistov BUG_ON(tp->token == Opt_onerror_panic);
14002a9807c0SEvgeniy Dushistov seq_printf(seq, ",%s", tp->pattern);
14012a9807c0SEvgeniy Dushistov
14022a9807c0SEvgeniy Dushistov mval = sbi->s_mount_opt & UFS_MOUNT_ONERROR;
14032a9807c0SEvgeniy Dushistov while (tp->token != Opt_err && tp->token != mval)
14042a9807c0SEvgeniy Dushistov ++tp;
14052a9807c0SEvgeniy Dushistov BUG_ON(tp->token == Opt_err);
14062a9807c0SEvgeniy Dushistov seq_printf(seq, ",%s", tp->pattern);
14072a9807c0SEvgeniy Dushistov
14082a9807c0SEvgeniy Dushistov return 0;
14092a9807c0SEvgeniy Dushistov }
14102a9807c0SEvgeniy Dushistov
ufs_statfs(struct dentry * dentry,struct kstatfs * buf)1411726c3342SDavid Howells static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf)
14121da177e4SLinus Torvalds {
1413726c3342SDavid Howells struct super_block *sb = dentry->d_sb;
1414647b7e87SEvgeniy Dushistov struct ufs_sb_private_info *uspi= UFS_SB(sb)->s_uspi;
1415647b7e87SEvgeniy Dushistov unsigned flags = UFS_SB(sb)->s_flags;
141641d577aaSColy Li u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
14171da177e4SLinus Torvalds
1418dff7cfd3SAl Viro mutex_lock(&UFS_SB(sb)->s_lock);
14191da177e4SLinus Torvalds
1420c596961dSAl Viro if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
14211da177e4SLinus Torvalds buf->f_type = UFS2_MAGIC;
1422c596961dSAl Viro else
14231da177e4SLinus Torvalds buf->f_type = UFS_MAGIC;
1424c596961dSAl Viro
14251da177e4SLinus Torvalds buf->f_blocks = uspi->s_dsize;
1426c596961dSAl Viro buf->f_bfree = ufs_freefrags(uspi);
1427ee3ffd6cSEvgeniy Dushistov buf->f_ffree = uspi->cs_total.cs_nifree;
14281da177e4SLinus Torvalds buf->f_bsize = sb->s_blocksize;
1429c596961dSAl Viro buf->f_bavail = (buf->f_bfree > uspi->s_root_blocks)
1430c596961dSAl Viro ? (buf->f_bfree - uspi->s_root_blocks) : 0;
14311da177e4SLinus Torvalds buf->f_files = uspi->s_ncg * uspi->s_ipg;
14321da177e4SLinus Torvalds buf->f_namelen = UFS_MAXNAMLEN;
14336d1349c7SAl Viro buf->f_fsid = u64_to_fsid(id);
14341da177e4SLinus Torvalds
1435dff7cfd3SAl Viro mutex_unlock(&UFS_SB(sb)->s_lock);
14361da177e4SLinus Torvalds
14371da177e4SLinus Torvalds return 0;
14381da177e4SLinus Torvalds }
14391da177e4SLinus Torvalds
1440e18b890bSChristoph Lameter static struct kmem_cache * ufs_inode_cachep;
14411da177e4SLinus Torvalds
ufs_alloc_inode(struct super_block * sb)14421da177e4SLinus Torvalds static struct inode *ufs_alloc_inode(struct super_block *sb)
14431da177e4SLinus Torvalds {
14441da177e4SLinus Torvalds struct ufs_inode_info *ei;
144561da3ae2SFabian Frederick
1446*fd60b288SMuchun Song ei = alloc_inode_sb(sb, ufs_inode_cachep, GFP_NOFS);
14471da177e4SLinus Torvalds if (!ei)
14481da177e4SLinus Torvalds return NULL;
144961da3ae2SFabian Frederick
1450bb8c2d66SJeff Layton inode_set_iversion(&ei->vfs_inode, 1);
1451724bb09fSAl Viro seqlock_init(&ei->meta_lock);
1452724bb09fSAl Viro mutex_init(&ei->truncate_mutex);
14531da177e4SLinus Torvalds return &ei->vfs_inode;
14541da177e4SLinus Torvalds }
14551da177e4SLinus Torvalds
ufs_free_in_core_inode(struct inode * inode)145698835e88SAl Viro static void ufs_free_in_core_inode(struct inode *inode)
1457fa0d7e3dSNick Piggin {
1458fa0d7e3dSNick Piggin kmem_cache_free(ufs_inode_cachep, UFS_I(inode));
1459fa0d7e3dSNick Piggin }
1460fa0d7e3dSNick Piggin
init_once(void * foo)146151cc5068SAlexey Dobriyan static void init_once(void *foo)
14621da177e4SLinus Torvalds {
14631da177e4SLinus Torvalds struct ufs_inode_info *ei = (struct ufs_inode_info *) foo;
14641da177e4SLinus Torvalds
14651da177e4SLinus Torvalds inode_init_once(&ei->vfs_inode);
14661da177e4SLinus Torvalds }
14671da177e4SLinus Torvalds
init_inodecache(void)146876ee4735SFabian Frederick static int __init init_inodecache(void)
14691da177e4SLinus Torvalds {
1470df5f3cfcSDavid Windsor ufs_inode_cachep = kmem_cache_create_usercopy("ufs_inode_cache",
1471df5f3cfcSDavid Windsor sizeof(struct ufs_inode_info), 0,
1472df5f3cfcSDavid Windsor (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
1473df5f3cfcSDavid Windsor SLAB_ACCOUNT),
1474df5f3cfcSDavid Windsor offsetof(struct ufs_inode_info, i_u1.i_symlink),
1475df5f3cfcSDavid Windsor sizeof_field(struct ufs_inode_info,
1476df5f3cfcSDavid Windsor i_u1.i_symlink),
147720c2df83SPaul Mundt init_once);
14781da177e4SLinus Torvalds if (ufs_inode_cachep == NULL)
14791da177e4SLinus Torvalds return -ENOMEM;
14801da177e4SLinus Torvalds return 0;
14811da177e4SLinus Torvalds }
14821da177e4SLinus Torvalds
destroy_inodecache(void)14831da177e4SLinus Torvalds static void destroy_inodecache(void)
14841da177e4SLinus Torvalds {
14858c0a8537SKirill A. Shutemov /*
14868c0a8537SKirill A. Shutemov * Make sure all delayed rcu free inodes are flushed before we
14878c0a8537SKirill A. Shutemov * destroy cache.
14888c0a8537SKirill A. Shutemov */
14898c0a8537SKirill A. Shutemov rcu_barrier();
14901a1d92c1SAlexey Dobriyan kmem_cache_destroy(ufs_inode_cachep);
14911da177e4SLinus Torvalds }
14921da177e4SLinus Torvalds
1493ee9b6d61SJosef 'Jeff' Sipek static const struct super_operations ufs_super_ops = {
14941da177e4SLinus Torvalds .alloc_inode = ufs_alloc_inode,
149598835e88SAl Viro .free_inode = ufs_free_in_core_inode,
14961da177e4SLinus Torvalds .write_inode = ufs_write_inode,
149758e8268cSAl Viro .evict_inode = ufs_evict_inode,
14981da177e4SLinus Torvalds .put_super = ufs_put_super,
14998c800656SChristoph Hellwig .sync_fs = ufs_sync_fs,
15001da177e4SLinus Torvalds .statfs = ufs_statfs,
15011da177e4SLinus Torvalds .remount_fs = ufs_remount,
15022a9807c0SEvgeniy Dushistov .show_options = ufs_show_options,
15031da177e4SLinus Torvalds };
15041da177e4SLinus Torvalds
ufs_mount(struct file_system_type * fs_type,int flags,const char * dev_name,void * data)1505152a0836SAl Viro static struct dentry *ufs_mount(struct file_system_type *fs_type,
1506152a0836SAl Viro int flags, const char *dev_name, void *data)
15071da177e4SLinus Torvalds {
1508152a0836SAl Viro return mount_bdev(fs_type, flags, dev_name, data, ufs_fill_super);
15091da177e4SLinus Torvalds }
15101da177e4SLinus Torvalds
15111da177e4SLinus Torvalds static struct file_system_type ufs_fs_type = {
15121da177e4SLinus Torvalds .owner = THIS_MODULE,
15131da177e4SLinus Torvalds .name = "ufs",
1514152a0836SAl Viro .mount = ufs_mount,
15151da177e4SLinus Torvalds .kill_sb = kill_block_super,
15161da177e4SLinus Torvalds .fs_flags = FS_REQUIRES_DEV,
15171da177e4SLinus Torvalds };
15187f78e035SEric W. Biederman MODULE_ALIAS_FS("ufs");
15191da177e4SLinus Torvalds
init_ufs_fs(void)15201da177e4SLinus Torvalds static int __init init_ufs_fs(void)
15211da177e4SLinus Torvalds {
15221da177e4SLinus Torvalds int err = init_inodecache();
15231da177e4SLinus Torvalds if (err)
15241da177e4SLinus Torvalds goto out1;
15251da177e4SLinus Torvalds err = register_filesystem(&ufs_fs_type);
15261da177e4SLinus Torvalds if (err)
15271da177e4SLinus Torvalds goto out;
15281da177e4SLinus Torvalds return 0;
15291da177e4SLinus Torvalds out:
15301da177e4SLinus Torvalds destroy_inodecache();
15311da177e4SLinus Torvalds out1:
15321da177e4SLinus Torvalds return err;
15331da177e4SLinus Torvalds }
15341da177e4SLinus Torvalds
exit_ufs_fs(void)15351da177e4SLinus Torvalds static void __exit exit_ufs_fs(void)
15361da177e4SLinus Torvalds {
15371da177e4SLinus Torvalds unregister_filesystem(&ufs_fs_type);
15381da177e4SLinus Torvalds destroy_inodecache();
15391da177e4SLinus Torvalds }
15401da177e4SLinus Torvalds
15411da177e4SLinus Torvalds module_init(init_ufs_fs)
15421da177e4SLinus Torvalds module_exit(exit_ufs_fs)
15431da177e4SLinus Torvalds MODULE_LICENSE("GPL");
1544