5 * Daniel Pirkl <daniel.pirkl@email.cz>
6 * Charles University, Faculty of Mathematics and Physics
11 * linux/fs/ext2/super.c
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)
20 * linux/fs/minix/inode.c
22 * Copyright (C) 1991, 1992 Linus Torvalds
24 * Big-endian to little-endian byte-swapping/bitmaps by
25 * David S. Miller (davem@caip.rutgers.edu), 1995
31 * linux/fs/ufs/super.c
34 * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
35 * Laboratory for Computer Science Research Computing Facility
36 * Rutgers, The State University of New Jersey
38 * Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
40 * Kernel module support added on 96/04/26 by
41 * Stefan Reinauer <stepan@home.culture.mipt.ru>
43 * Module usage counts added on 96/04/29 by
44 * Gertjan van Wingerde <gwingerde@gmail.com>
46 * Clean swab support on 19970406 by
47 * Francois-Rene Rideau <fare@tunes.org>
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>.
53 * NeXTstep support added on February 5th 1998 by
54 * Niels Kristian Bech Jensen <nkbj@image.dk>.
56 * write support Daniel Pirkl <daniel.pirkl@email.cz> 1998
58 * HP/UX hfs filesystem support added by
59 * Martin K. Petersen <mkp@mkp.net>, August 1999
61 * UFS2 (of FreeBSD 5.x) support added by
62 * Niraj Kumar <niraj17@iitbombay.org>, Jan 2004
64 * UFS2 write support added by
65 * Evgeniy Dushistov <dushistov@mail.ru>, 2007
68 #include <linux/exportfs.h>
69 #include <linux/module.h>
70 #include <linux/bitops.h>
74 #include <asm/uaccess.h>
76 #include <linux/errno.h>
78 #include <linux/slab.h>
79 #include <linux/time.h>
80 #include <linux/stat.h>
81 #include <linux/string.h>
82 #include <linux/blkdev.h>
83 #include <linux/init.h>
84 #include <linux/parser.h>
85 #include <linux/buffer_head.h>
86 #include <linux/vfs.h>
87 #include <linux/log2.h>
88 #include <linux/mount.h>
89 #include <linux/seq_file.h>
96 void lock_ufs(struct super_block
*sb
)
98 struct ufs_sb_info
*sbi
= UFS_SB(sb
);
100 mutex_lock(&sbi
->mutex
);
101 sbi
->mutex_owner
= current
;
104 void unlock_ufs(struct super_block
*sb
)
106 struct ufs_sb_info
*sbi
= UFS_SB(sb
);
108 sbi
->mutex_owner
= NULL
;
109 mutex_unlock(&sbi
->mutex
);
112 static struct inode
*ufs_nfs_get_inode(struct super_block
*sb
, u64 ino
, u32 generation
)
114 struct ufs_sb_private_info
*uspi
= UFS_SB(sb
)->s_uspi
;
117 if (ino
< UFS_ROOTINO
|| ino
> uspi
->s_ncg
* uspi
->s_ipg
)
118 return ERR_PTR(-ESTALE
);
120 inode
= ufs_iget(sb
, ino
);
122 return ERR_CAST(inode
);
123 if (generation
&& inode
->i_generation
!= generation
) {
125 return ERR_PTR(-ESTALE
);
130 static struct dentry
*ufs_fh_to_dentry(struct super_block
*sb
, struct fid
*fid
,
131 int fh_len
, int fh_type
)
133 return generic_fh_to_dentry(sb
, fid
, fh_len
, fh_type
, ufs_nfs_get_inode
);
136 static struct dentry
*ufs_fh_to_parent(struct super_block
*sb
, struct fid
*fid
,
137 int fh_len
, int fh_type
)
139 return generic_fh_to_parent(sb
, fid
, fh_len
, fh_type
, ufs_nfs_get_inode
);
142 static struct dentry
*ufs_get_parent(struct dentry
*child
)
144 struct qstr dot_dot
= QSTR_INIT("..", 2);
147 ino
= ufs_inode_by_name(child
->d_inode
, &dot_dot
);
149 return ERR_PTR(-ENOENT
);
150 return d_obtain_alias(ufs_iget(child
->d_inode
->i_sb
, ino
));
153 static const struct export_operations ufs_export_ops
= {
154 .fh_to_dentry
= ufs_fh_to_dentry
,
155 .fh_to_parent
= ufs_fh_to_parent
,
156 .get_parent
= ufs_get_parent
,
159 #ifdef CONFIG_UFS_DEBUG
161 * Print contents of ufs_super_block, useful for debugging
163 static void ufs_print_super_stuff(struct super_block
*sb
,
164 struct ufs_super_block_first
*usb1
,
165 struct ufs_super_block_second
*usb2
,
166 struct ufs_super_block_third
*usb3
)
168 u32 magic
= fs32_to_cpu(sb
, usb3
->fs_magic
);
170 pr_debug("ufs_print_super_stuff\n");
171 pr_debug(" magic: 0x%x\n", magic
);
172 if (fs32_to_cpu(sb
, usb3
->fs_magic
) == UFS2_MAGIC
) {
173 pr_debug(" fs_size: %llu\n", (unsigned long long)
174 fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_size
));
175 pr_debug(" fs_dsize: %llu\n", (unsigned long long)
176 fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_dsize
));
177 pr_debug(" bsize: %u\n",
178 fs32_to_cpu(sb
, usb1
->fs_bsize
));
179 pr_debug(" fsize: %u\n",
180 fs32_to_cpu(sb
, usb1
->fs_fsize
));
181 pr_debug(" fs_volname: %s\n", usb2
->fs_un
.fs_u2
.fs_volname
);
182 pr_debug(" fs_sblockloc: %llu\n", (unsigned long long)
183 fs64_to_cpu(sb
, usb2
->fs_un
.fs_u2
.fs_sblockloc
));
184 pr_debug(" cs_ndir(No of dirs): %llu\n", (unsigned long long)
185 fs64_to_cpu(sb
, usb2
->fs_un
.fs_u2
.cs_ndir
));
186 pr_debug(" cs_nbfree(No of free blocks): %llu\n",
188 fs64_to_cpu(sb
, usb2
->fs_un
.fs_u2
.cs_nbfree
));
189 pr_info(" cs_nifree(Num of free inodes): %llu\n",
191 fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.cs_nifree
));
192 pr_info(" cs_nffree(Num of free frags): %llu\n",
194 fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.cs_nffree
));
195 pr_info(" fs_maxsymlinklen: %u\n",
196 fs32_to_cpu(sb
, usb3
->fs_un2
.fs_44
.fs_maxsymlinklen
));
198 pr_debug(" sblkno: %u\n", fs32_to_cpu(sb
, usb1
->fs_sblkno
));
199 pr_debug(" cblkno: %u\n", fs32_to_cpu(sb
, usb1
->fs_cblkno
));
200 pr_debug(" iblkno: %u\n", fs32_to_cpu(sb
, usb1
->fs_iblkno
));
201 pr_debug(" dblkno: %u\n", fs32_to_cpu(sb
, usb1
->fs_dblkno
));
202 pr_debug(" cgoffset: %u\n",
203 fs32_to_cpu(sb
, usb1
->fs_cgoffset
));
204 pr_debug(" ~cgmask: 0x%x\n",
205 ~fs32_to_cpu(sb
, usb1
->fs_cgmask
));
206 pr_debug(" size: %u\n", fs32_to_cpu(sb
, usb1
->fs_size
));
207 pr_debug(" dsize: %u\n", fs32_to_cpu(sb
, usb1
->fs_dsize
));
208 pr_debug(" ncg: %u\n", fs32_to_cpu(sb
, usb1
->fs_ncg
));
209 pr_debug(" bsize: %u\n", fs32_to_cpu(sb
, usb1
->fs_bsize
));
210 pr_debug(" fsize: %u\n", fs32_to_cpu(sb
, usb1
->fs_fsize
));
211 pr_debug(" frag: %u\n", fs32_to_cpu(sb
, usb1
->fs_frag
));
212 pr_debug(" fragshift: %u\n",
213 fs32_to_cpu(sb
, usb1
->fs_fragshift
));
214 pr_debug(" ~fmask: %u\n", ~fs32_to_cpu(sb
, usb1
->fs_fmask
));
215 pr_debug(" fshift: %u\n", fs32_to_cpu(sb
, usb1
->fs_fshift
));
216 pr_debug(" sbsize: %u\n", fs32_to_cpu(sb
, usb1
->fs_sbsize
));
217 pr_debug(" spc: %u\n", fs32_to_cpu(sb
, usb1
->fs_spc
));
218 pr_debug(" cpg: %u\n", fs32_to_cpu(sb
, usb1
->fs_cpg
));
219 pr_debug(" ipg: %u\n", fs32_to_cpu(sb
, usb1
->fs_ipg
));
220 pr_debug(" fpg: %u\n", fs32_to_cpu(sb
, usb1
->fs_fpg
));
221 pr_debug(" csaddr: %u\n", fs32_to_cpu(sb
, usb1
->fs_csaddr
));
222 pr_debug(" cssize: %u\n", fs32_to_cpu(sb
, usb1
->fs_cssize
));
223 pr_debug(" cgsize: %u\n", fs32_to_cpu(sb
, usb1
->fs_cgsize
));
224 pr_debug(" fstodb: %u\n",
225 fs32_to_cpu(sb
, usb1
->fs_fsbtodb
));
226 pr_debug(" nrpos: %u\n", fs32_to_cpu(sb
, usb3
->fs_nrpos
));
227 pr_debug(" ndir %u\n",
228 fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_ndir
));
229 pr_debug(" nifree %u\n",
230 fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nifree
));
231 pr_debug(" nbfree %u\n",
232 fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nbfree
));
233 pr_debug(" nffree %u\n",
234 fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nffree
));
240 * Print contents of ufs_cylinder_group, useful for debugging
242 static void ufs_print_cylinder_stuff(struct super_block
*sb
,
243 struct ufs_cylinder_group
*cg
)
245 pr_debug("\nufs_print_cylinder_stuff\n");
246 pr_debug("size of ucg: %zu\n", sizeof(struct ufs_cylinder_group
));
247 pr_debug(" magic: %x\n", fs32_to_cpu(sb
, cg
->cg_magic
));
248 pr_debug(" time: %u\n", fs32_to_cpu(sb
, cg
->cg_time
));
249 pr_debug(" cgx: %u\n", fs32_to_cpu(sb
, cg
->cg_cgx
));
250 pr_debug(" ncyl: %u\n", fs16_to_cpu(sb
, cg
->cg_ncyl
));
251 pr_debug(" niblk: %u\n", fs16_to_cpu(sb
, cg
->cg_niblk
));
252 pr_debug(" ndblk: %u\n", fs32_to_cpu(sb
, cg
->cg_ndblk
));
253 pr_debug(" cs_ndir: %u\n", fs32_to_cpu(sb
, cg
->cg_cs
.cs_ndir
));
254 pr_debug(" cs_nbfree: %u\n", fs32_to_cpu(sb
, cg
->cg_cs
.cs_nbfree
));
255 pr_debug(" cs_nifree: %u\n", fs32_to_cpu(sb
, cg
->cg_cs
.cs_nifree
));
256 pr_debug(" cs_nffree: %u\n", fs32_to_cpu(sb
, cg
->cg_cs
.cs_nffree
));
257 pr_debug(" rotor: %u\n", fs32_to_cpu(sb
, cg
->cg_rotor
));
258 pr_debug(" frotor: %u\n", fs32_to_cpu(sb
, cg
->cg_frotor
));
259 pr_debug(" irotor: %u\n", fs32_to_cpu(sb
, cg
->cg_irotor
));
260 pr_debug(" frsum: %u, %u, %u, %u, %u, %u, %u, %u\n",
261 fs32_to_cpu(sb
, cg
->cg_frsum
[0]), fs32_to_cpu(sb
, cg
->cg_frsum
[1]),
262 fs32_to_cpu(sb
, cg
->cg_frsum
[2]), fs32_to_cpu(sb
, cg
->cg_frsum
[3]),
263 fs32_to_cpu(sb
, cg
->cg_frsum
[4]), fs32_to_cpu(sb
, cg
->cg_frsum
[5]),
264 fs32_to_cpu(sb
, cg
->cg_frsum
[6]), fs32_to_cpu(sb
, cg
->cg_frsum
[7]));
265 pr_debug(" btotoff: %u\n", fs32_to_cpu(sb
, cg
->cg_btotoff
));
266 pr_debug(" boff: %u\n", fs32_to_cpu(sb
, cg
->cg_boff
));
267 pr_debug(" iuseoff: %u\n", fs32_to_cpu(sb
, cg
->cg_iusedoff
));
268 pr_debug(" freeoff: %u\n", fs32_to_cpu(sb
, cg
->cg_freeoff
));
269 pr_debug(" nextfreeoff: %u\n", fs32_to_cpu(sb
, cg
->cg_nextfreeoff
));
270 pr_debug(" clustersumoff %u\n",
271 fs32_to_cpu(sb
, cg
->cg_u
.cg_44
.cg_clustersumoff
));
272 pr_debug(" clusteroff %u\n",
273 fs32_to_cpu(sb
, cg
->cg_u
.cg_44
.cg_clusteroff
));
274 pr_debug(" nclusterblks %u\n",
275 fs32_to_cpu(sb
, cg
->cg_u
.cg_44
.cg_nclusterblks
));
279 # define ufs_print_super_stuff(sb, usb1, usb2, usb3) /**/
280 # define ufs_print_cylinder_stuff(sb, cg) /**/
281 #endif /* CONFIG_UFS_DEBUG */
283 static const struct super_operations ufs_super_ops
;
285 void ufs_error (struct super_block
* sb
, const char * function
,
286 const char * fmt
, ...)
288 struct ufs_sb_private_info
* uspi
;
289 struct ufs_super_block_first
* usb1
;
290 struct va_format vaf
;
293 uspi
= UFS_SB(sb
)->s_uspi
;
294 usb1
= ubh_get_usb_first(uspi
);
296 if (!(sb
->s_flags
& MS_RDONLY
)) {
297 usb1
->fs_clean
= UFS_FSBAD
;
298 ubh_mark_buffer_dirty(USPI_UBH(uspi
));
299 ufs_mark_sb_dirty(sb
);
300 sb
->s_flags
|= MS_RDONLY
;
305 switch (UFS_SB(sb
)->s_mount_opt
& UFS_MOUNT_ONERROR
) {
306 case UFS_MOUNT_ONERROR_PANIC
:
307 panic("panic (device %s): %s: %pV\n",
308 sb
->s_id
, function
, &vaf
);
310 case UFS_MOUNT_ONERROR_LOCK
:
311 case UFS_MOUNT_ONERROR_UMOUNT
:
312 case UFS_MOUNT_ONERROR_REPAIR
:
313 pr_crit("error (device %s): %s: %pV\n",
314 sb
->s_id
, function
, &vaf
);
319 void ufs_panic (struct super_block
* sb
, const char * function
,
320 const char * fmt
, ...)
322 struct ufs_sb_private_info
* uspi
;
323 struct ufs_super_block_first
* usb1
;
324 struct va_format vaf
;
327 uspi
= UFS_SB(sb
)->s_uspi
;
328 usb1
= ubh_get_usb_first(uspi
);
330 if (!(sb
->s_flags
& MS_RDONLY
)) {
331 usb1
->fs_clean
= UFS_FSBAD
;
332 ubh_mark_buffer_dirty(USPI_UBH(uspi
));
333 ufs_mark_sb_dirty(sb
);
338 sb
->s_flags
|= MS_RDONLY
;
339 pr_crit("panic (device %s): %s: %pV\n",
340 sb
->s_id
, function
, &vaf
);
344 void ufs_warning (struct super_block
* sb
, const char * function
,
345 const char * fmt
, ...)
347 struct va_format vaf
;
353 pr_warn("(device %s): %s: %pV\n",
354 sb
->s_id
, function
, &vaf
);
359 Opt_type_old
= UFS_MOUNT_UFSTYPE_OLD
,
360 Opt_type_sunx86
= UFS_MOUNT_UFSTYPE_SUNx86
,
361 Opt_type_sun
= UFS_MOUNT_UFSTYPE_SUN
,
362 Opt_type_sunos
= UFS_MOUNT_UFSTYPE_SUNOS
,
363 Opt_type_44bsd
= UFS_MOUNT_UFSTYPE_44BSD
,
364 Opt_type_ufs2
= UFS_MOUNT_UFSTYPE_UFS2
,
365 Opt_type_hp
= UFS_MOUNT_UFSTYPE_HP
,
366 Opt_type_nextstepcd
= UFS_MOUNT_UFSTYPE_NEXTSTEP_CD
,
367 Opt_type_nextstep
= UFS_MOUNT_UFSTYPE_NEXTSTEP
,
368 Opt_type_openstep
= UFS_MOUNT_UFSTYPE_OPENSTEP
,
369 Opt_onerror_panic
= UFS_MOUNT_ONERROR_PANIC
,
370 Opt_onerror_lock
= UFS_MOUNT_ONERROR_LOCK
,
371 Opt_onerror_umount
= UFS_MOUNT_ONERROR_UMOUNT
,
372 Opt_onerror_repair
= UFS_MOUNT_ONERROR_REPAIR
,
376 static const match_table_t tokens
= {
377 {Opt_type_old
, "ufstype=old"},
378 {Opt_type_sunx86
, "ufstype=sunx86"},
379 {Opt_type_sun
, "ufstype=sun"},
380 {Opt_type_sunos
, "ufstype=sunos"},
381 {Opt_type_44bsd
, "ufstype=44bsd"},
382 {Opt_type_ufs2
, "ufstype=ufs2"},
383 {Opt_type_ufs2
, "ufstype=5xbsd"},
384 {Opt_type_hp
, "ufstype=hp"},
385 {Opt_type_nextstepcd
, "ufstype=nextstep-cd"},
386 {Opt_type_nextstep
, "ufstype=nextstep"},
387 {Opt_type_openstep
, "ufstype=openstep"},
388 /*end of possible ufs types */
389 {Opt_onerror_panic
, "onerror=panic"},
390 {Opt_onerror_lock
, "onerror=lock"},
391 {Opt_onerror_umount
, "onerror=umount"},
392 {Opt_onerror_repair
, "onerror=repair"},
396 static int ufs_parse_options (char * options
, unsigned * mount_options
)
405 while ((p
= strsep(&options
, ",")) != NULL
) {
406 substring_t args
[MAX_OPT_ARGS
];
411 token
= match_token(p
, tokens
, args
);
414 ufs_clear_opt (*mount_options
, UFSTYPE
);
415 ufs_set_opt (*mount_options
, UFSTYPE_OLD
);
417 case Opt_type_sunx86
:
418 ufs_clear_opt (*mount_options
, UFSTYPE
);
419 ufs_set_opt (*mount_options
, UFSTYPE_SUNx86
);
422 ufs_clear_opt (*mount_options
, UFSTYPE
);
423 ufs_set_opt (*mount_options
, UFSTYPE_SUN
);
426 ufs_clear_opt(*mount_options
, UFSTYPE
);
427 ufs_set_opt(*mount_options
, UFSTYPE_SUNOS
);
430 ufs_clear_opt (*mount_options
, UFSTYPE
);
431 ufs_set_opt (*mount_options
, UFSTYPE_44BSD
);
434 ufs_clear_opt(*mount_options
, UFSTYPE
);
435 ufs_set_opt(*mount_options
, UFSTYPE_UFS2
);
438 ufs_clear_opt (*mount_options
, UFSTYPE
);
439 ufs_set_opt (*mount_options
, UFSTYPE_HP
);
441 case Opt_type_nextstepcd
:
442 ufs_clear_opt (*mount_options
, UFSTYPE
);
443 ufs_set_opt (*mount_options
, UFSTYPE_NEXTSTEP_CD
);
445 case Opt_type_nextstep
:
446 ufs_clear_opt (*mount_options
, UFSTYPE
);
447 ufs_set_opt (*mount_options
, UFSTYPE_NEXTSTEP
);
449 case Opt_type_openstep
:
450 ufs_clear_opt (*mount_options
, UFSTYPE
);
451 ufs_set_opt (*mount_options
, UFSTYPE_OPENSTEP
);
453 case Opt_onerror_panic
:
454 ufs_clear_opt (*mount_options
, ONERROR
);
455 ufs_set_opt (*mount_options
, ONERROR_PANIC
);
457 case Opt_onerror_lock
:
458 ufs_clear_opt (*mount_options
, ONERROR
);
459 ufs_set_opt (*mount_options
, ONERROR_LOCK
);
461 case Opt_onerror_umount
:
462 ufs_clear_opt (*mount_options
, ONERROR
);
463 ufs_set_opt (*mount_options
, ONERROR_UMOUNT
);
465 case Opt_onerror_repair
:
466 pr_err("Unable to do repair on error, will lock lock instead\n");
467 ufs_clear_opt (*mount_options
, ONERROR
);
468 ufs_set_opt (*mount_options
, ONERROR_REPAIR
);
471 pr_err("Invalid option: \"%s\" or missing value\n", p
);
479 * Different types of UFS hold fs_cstotal in different
480 * places, and use different data structure for it.
481 * To make things simpler we just copy fs_cstotal to ufs_sb_private_info
483 static void ufs_setup_cstotal(struct super_block
*sb
)
485 struct ufs_sb_info
*sbi
= UFS_SB(sb
);
486 struct ufs_sb_private_info
*uspi
= sbi
->s_uspi
;
487 struct ufs_super_block_first
*usb1
;
488 struct ufs_super_block_second
*usb2
;
489 struct ufs_super_block_third
*usb3
;
490 unsigned mtype
= sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
;
492 UFSD("ENTER, mtype=%u\n", mtype
);
493 usb1
= ubh_get_usb_first(uspi
);
494 usb2
= ubh_get_usb_second(uspi
);
495 usb3
= ubh_get_usb_third(uspi
);
497 if ((mtype
== UFS_MOUNT_UFSTYPE_44BSD
&&
498 (usb1
->fs_flags
& UFS_FLAGS_UPDATED
)) ||
499 mtype
== UFS_MOUNT_UFSTYPE_UFS2
) {
500 /*we have statistic in different place, then usual*/
501 uspi
->cs_total
.cs_ndir
= fs64_to_cpu(sb
, usb2
->fs_un
.fs_u2
.cs_ndir
);
502 uspi
->cs_total
.cs_nbfree
= fs64_to_cpu(sb
, usb2
->fs_un
.fs_u2
.cs_nbfree
);
503 uspi
->cs_total
.cs_nifree
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.cs_nifree
);
504 uspi
->cs_total
.cs_nffree
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.cs_nffree
);
506 uspi
->cs_total
.cs_ndir
= fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_ndir
);
507 uspi
->cs_total
.cs_nbfree
= fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nbfree
);
508 uspi
->cs_total
.cs_nifree
= fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nifree
);
509 uspi
->cs_total
.cs_nffree
= fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nffree
);
515 * Read on-disk structures associated with cylinder groups
517 static int ufs_read_cylinder_structures(struct super_block
*sb
)
519 struct ufs_sb_info
*sbi
= UFS_SB(sb
);
520 struct ufs_sb_private_info
*uspi
= sbi
->s_uspi
;
521 struct ufs_buffer_head
* ubh
;
522 unsigned char * base
, * space
;
523 unsigned size
, blks
, i
;
528 * Read cs structures from (usually) first data block
531 size
= uspi
->s_cssize
;
532 blks
= (size
+ uspi
->s_fsize
- 1) >> uspi
->s_fshift
;
533 base
= space
= kmalloc(size
, GFP_NOFS
);
536 sbi
->s_csp
= (struct ufs_csum
*)space
;
537 for (i
= 0; i
< blks
; i
+= uspi
->s_fpb
) {
538 size
= uspi
->s_bsize
;
539 if (i
+ uspi
->s_fpb
> blks
)
540 size
= (blks
- i
) * uspi
->s_fsize
;
542 ubh
= ubh_bread(sb
, uspi
->s_csaddr
+ i
, size
);
547 ubh_ubhcpymem (space
, ubh
, size
);
555 * Read cylinder group (we read only first fragment from block
556 * at this time) and prepare internal data structures for cg caching.
558 if (!(sbi
->s_ucg
= kmalloc (sizeof(struct buffer_head
*) * uspi
->s_ncg
, GFP_NOFS
)))
560 for (i
= 0; i
< uspi
->s_ncg
; i
++)
561 sbi
->s_ucg
[i
] = NULL
;
562 for (i
= 0; i
< UFS_MAX_GROUP_LOADED
; i
++) {
563 sbi
->s_ucpi
[i
] = NULL
;
564 sbi
->s_cgno
[i
] = UFS_CGNO_EMPTY
;
566 for (i
= 0; i
< uspi
->s_ncg
; i
++) {
567 UFSD("read cg %u\n", i
);
568 if (!(sbi
->s_ucg
[i
] = sb_bread(sb
, ufs_cgcmin(i
))))
570 if (!ufs_cg_chkmagic (sb
, (struct ufs_cylinder_group
*) sbi
->s_ucg
[i
]->b_data
))
573 ufs_print_cylinder_stuff(sb
, (struct ufs_cylinder_group
*) sbi
->s_ucg
[i
]->b_data
);
575 for (i
= 0; i
< UFS_MAX_GROUP_LOADED
; i
++) {
576 if (!(sbi
->s_ucpi
[i
] = kmalloc (sizeof(struct ufs_cg_private_info
), GFP_NOFS
)))
578 sbi
->s_cgno
[i
] = UFS_CGNO_EMPTY
;
580 sbi
->s_cg_loaded
= 0;
587 for (i
= 0; i
< uspi
->s_ncg
; i
++)
589 brelse (sbi
->s_ucg
[i
]);
591 for (i
= 0; i
< UFS_MAX_GROUP_LOADED
; i
++)
592 kfree (sbi
->s_ucpi
[i
]);
594 UFSD("EXIT (FAILED)\n");
599 * Sync our internal copy of fs_cstotal with disk
601 static void ufs_put_cstotal(struct super_block
*sb
)
603 unsigned mtype
= UFS_SB(sb
)->s_mount_opt
& UFS_MOUNT_UFSTYPE
;
604 struct ufs_sb_private_info
*uspi
= UFS_SB(sb
)->s_uspi
;
605 struct ufs_super_block_first
*usb1
;
606 struct ufs_super_block_second
*usb2
;
607 struct ufs_super_block_third
*usb3
;
610 usb1
= ubh_get_usb_first(uspi
);
611 usb2
= ubh_get_usb_second(uspi
);
612 usb3
= ubh_get_usb_third(uspi
);
614 if ((mtype
== UFS_MOUNT_UFSTYPE_44BSD
&&
615 (usb1
->fs_flags
& UFS_FLAGS_UPDATED
)) ||
616 mtype
== UFS_MOUNT_UFSTYPE_UFS2
) {
617 /*we have statistic in different place, then usual*/
618 usb2
->fs_un
.fs_u2
.cs_ndir
=
619 cpu_to_fs64(sb
, uspi
->cs_total
.cs_ndir
);
620 usb2
->fs_un
.fs_u2
.cs_nbfree
=
621 cpu_to_fs64(sb
, uspi
->cs_total
.cs_nbfree
);
622 usb3
->fs_un1
.fs_u2
.cs_nifree
=
623 cpu_to_fs64(sb
, uspi
->cs_total
.cs_nifree
);
624 usb3
->fs_un1
.fs_u2
.cs_nffree
=
625 cpu_to_fs64(sb
, uspi
->cs_total
.cs_nffree
);
627 usb1
->fs_cstotal
.cs_ndir
=
628 cpu_to_fs32(sb
, uspi
->cs_total
.cs_ndir
);
629 usb1
->fs_cstotal
.cs_nbfree
=
630 cpu_to_fs32(sb
, uspi
->cs_total
.cs_nbfree
);
631 usb1
->fs_cstotal
.cs_nifree
=
632 cpu_to_fs32(sb
, uspi
->cs_total
.cs_nifree
);
633 usb1
->fs_cstotal
.cs_nffree
=
634 cpu_to_fs32(sb
, uspi
->cs_total
.cs_nffree
);
636 ubh_mark_buffer_dirty(USPI_UBH(uspi
));
637 ufs_print_super_stuff(sb
, usb1
, usb2
, usb3
);
642 * ufs_put_super_internal() - put on-disk intrenal structures
643 * @sb: pointer to super_block structure
644 * Put on-disk structures associated with cylinder groups
645 * and write them back to disk, also update cs_total on disk
647 static void ufs_put_super_internal(struct super_block
*sb
)
649 struct ufs_sb_info
*sbi
= UFS_SB(sb
);
650 struct ufs_sb_private_info
*uspi
= sbi
->s_uspi
;
651 struct ufs_buffer_head
* ubh
;
652 unsigned char * base
, * space
;
653 unsigned blks
, size
, i
;
659 size
= uspi
->s_cssize
;
660 blks
= (size
+ uspi
->s_fsize
- 1) >> uspi
->s_fshift
;
661 base
= space
= (char*) sbi
->s_csp
;
662 for (i
= 0; i
< blks
; i
+= uspi
->s_fpb
) {
663 size
= uspi
->s_bsize
;
664 if (i
+ uspi
->s_fpb
> blks
)
665 size
= (blks
- i
) * uspi
->s_fsize
;
667 ubh
= ubh_bread(sb
, uspi
->s_csaddr
+ i
, size
);
669 ubh_memcpyubh (ubh
, space
, size
);
671 ubh_mark_buffer_uptodate (ubh
, 1);
672 ubh_mark_buffer_dirty (ubh
);
675 for (i
= 0; i
< sbi
->s_cg_loaded
; i
++) {
676 ufs_put_cylinder (sb
, i
);
677 kfree (sbi
->s_ucpi
[i
]);
679 for (; i
< UFS_MAX_GROUP_LOADED
; i
++)
680 kfree (sbi
->s_ucpi
[i
]);
681 for (i
= 0; i
< uspi
->s_ncg
; i
++)
682 brelse (sbi
->s_ucg
[i
]);
689 static int ufs_sync_fs(struct super_block
*sb
, int wait
)
691 struct ufs_sb_private_info
* uspi
;
692 struct ufs_super_block_first
* usb1
;
693 struct ufs_super_block_third
* usb3
;
700 flags
= UFS_SB(sb
)->s_flags
;
701 uspi
= UFS_SB(sb
)->s_uspi
;
702 usb1
= ubh_get_usb_first(uspi
);
703 usb3
= ubh_get_usb_third(uspi
);
705 usb1
->fs_time
= cpu_to_fs32(sb
, get_seconds());
706 if ((flags
& UFS_ST_MASK
) == UFS_ST_SUN
||
707 (flags
& UFS_ST_MASK
) == UFS_ST_SUNOS
||
708 (flags
& UFS_ST_MASK
) == UFS_ST_SUNx86
)
709 ufs_set_fs_state(sb
, usb1
, usb3
,
710 UFS_FSOK
- fs32_to_cpu(sb
, usb1
->fs_time
));
719 static void delayed_sync_fs(struct work_struct
*work
)
721 struct ufs_sb_info
*sbi
;
723 sbi
= container_of(work
, struct ufs_sb_info
, sync_work
.work
);
725 spin_lock(&sbi
->work_lock
);
726 sbi
->work_queued
= 0;
727 spin_unlock(&sbi
->work_lock
);
729 ufs_sync_fs(sbi
->sb
, 1);
732 void ufs_mark_sb_dirty(struct super_block
*sb
)
734 struct ufs_sb_info
*sbi
= UFS_SB(sb
);
737 spin_lock(&sbi
->work_lock
);
738 if (!sbi
->work_queued
) {
739 delay
= msecs_to_jiffies(dirty_writeback_interval
* 10);
740 queue_delayed_work(system_long_wq
, &sbi
->sync_work
, delay
);
741 sbi
->work_queued
= 1;
743 spin_unlock(&sbi
->work_lock
);
746 static void ufs_put_super(struct super_block
*sb
)
748 struct ufs_sb_info
* sbi
= UFS_SB(sb
);
752 if (!(sb
->s_flags
& MS_RDONLY
))
753 ufs_put_super_internal(sb
);
754 cancel_delayed_work_sync(&sbi
->sync_work
);
756 ubh_brelse_uspi (sbi
->s_uspi
);
758 mutex_destroy(&sbi
->mutex
);
760 sb
->s_fs_info
= NULL
;
765 static int ufs_fill_super(struct super_block
*sb
, void *data
, int silent
)
767 struct ufs_sb_info
* sbi
;
768 struct ufs_sb_private_info
* uspi
;
769 struct ufs_super_block_first
* usb1
;
770 struct ufs_super_block_second
* usb2
;
771 struct ufs_super_block_third
* usb3
;
772 struct ufs_buffer_head
* ubh
;
774 unsigned block_size
, super_block_size
;
776 unsigned super_block_offset
;
786 #ifndef CONFIG_UFS_FS_WRITE
787 if (!(sb
->s_flags
& MS_RDONLY
)) {
788 pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
793 sbi
= kzalloc(sizeof(struct ufs_sb_info
), GFP_KERNEL
);
799 UFSD("flag %u\n", (int)(sb
->s_flags
& MS_RDONLY
));
801 mutex_init(&sbi
->mutex
);
802 spin_lock_init(&sbi
->work_lock
);
803 INIT_DELAYED_WORK(&sbi
->sync_work
, delayed_sync_fs
);
805 * Set default mount options
806 * Parse mount options
808 sbi
->s_mount_opt
= 0;
809 ufs_set_opt (sbi
->s_mount_opt
, ONERROR_LOCK
);
810 if (!ufs_parse_options ((char *) data
, &sbi
->s_mount_opt
)) {
811 pr_err("wrong mount options\n");
814 if (!(sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
)) {
816 pr_err("You didn't specify the type of your ufs filesystem\n\n"
817 "mount -t ufs -o ufstype="
818 "sun|sunx86|44bsd|ufs2|5xbsd|old|hp|nextstep|nextstep-cd|openstep ...\n\n"
819 ">>>WARNING<<< Wrong ufstype may corrupt your filesystem, "
820 "default is ufstype=old\n");
821 ufs_set_opt (sbi
->s_mount_opt
, UFSTYPE_OLD
);
824 uspi
= kzalloc(sizeof(struct ufs_sb_private_info
), GFP_KERNEL
);
828 uspi
->s_dirblksize
= UFS_SECTOR_SIZE
;
829 super_block_offset
=UFS_SBLOCK
;
831 /* Keep 2Gig file limit. Some UFS variants need to override
832 this but as I don't know which I'll let those in the know loosen
834 switch (sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) {
835 case UFS_MOUNT_UFSTYPE_44BSD
:
836 UFSD("ufstype=44bsd\n");
837 uspi
->s_fsize
= block_size
= 512;
838 uspi
->s_fmask
= ~(512 - 1);
840 uspi
->s_sbsize
= super_block_size
= 1536;
842 flags
|= UFS_DE_44BSD
| UFS_UID_44BSD
| UFS_ST_44BSD
| UFS_CG_44BSD
;
844 case UFS_MOUNT_UFSTYPE_UFS2
:
845 UFSD("ufstype=ufs2\n");
846 super_block_offset
=SBLOCK_UFS2
;
847 uspi
->s_fsize
= block_size
= 512;
848 uspi
->s_fmask
= ~(512 - 1);
850 uspi
->s_sbsize
= super_block_size
= 1536;
852 flags
|= UFS_TYPE_UFS2
| UFS_DE_44BSD
| UFS_UID_44BSD
| UFS_ST_44BSD
| UFS_CG_44BSD
;
855 case UFS_MOUNT_UFSTYPE_SUN
:
856 UFSD("ufstype=sun\n");
857 uspi
->s_fsize
= block_size
= 1024;
858 uspi
->s_fmask
= ~(1024 - 1);
860 uspi
->s_sbsize
= super_block_size
= 2048;
862 uspi
->s_maxsymlinklen
= 0; /* Not supported on disk */
863 flags
|= UFS_DE_OLD
| UFS_UID_EFT
| UFS_ST_SUN
| UFS_CG_SUN
;
866 case UFS_MOUNT_UFSTYPE_SUNOS
:
867 UFSD("ufstype=sunos\n");
868 uspi
->s_fsize
= block_size
= 1024;
869 uspi
->s_fmask
= ~(1024 - 1);
871 uspi
->s_sbsize
= 2048;
872 super_block_size
= 2048;
874 uspi
->s_maxsymlinklen
= 0; /* Not supported on disk */
875 flags
|= UFS_DE_OLD
| UFS_UID_OLD
| UFS_ST_SUNOS
| UFS_CG_SUN
;
878 case UFS_MOUNT_UFSTYPE_SUNx86
:
879 UFSD("ufstype=sunx86\n");
880 uspi
->s_fsize
= block_size
= 1024;
881 uspi
->s_fmask
= ~(1024 - 1);
883 uspi
->s_sbsize
= super_block_size
= 2048;
885 uspi
->s_maxsymlinklen
= 0; /* Not supported on disk */
886 flags
|= UFS_DE_OLD
| UFS_UID_EFT
| UFS_ST_SUNx86
| UFS_CG_SUN
;
889 case UFS_MOUNT_UFSTYPE_OLD
:
890 UFSD("ufstype=old\n");
891 uspi
->s_fsize
= block_size
= 1024;
892 uspi
->s_fmask
= ~(1024 - 1);
894 uspi
->s_sbsize
= super_block_size
= 2048;
896 flags
|= UFS_DE_OLD
| UFS_UID_OLD
| UFS_ST_OLD
| UFS_CG_OLD
;
897 if (!(sb
->s_flags
& MS_RDONLY
)) {
899 pr_info("ufstype=old is supported read-only\n");
900 sb
->s_flags
|= MS_RDONLY
;
904 case UFS_MOUNT_UFSTYPE_NEXTSTEP
:
905 UFSD("ufstype=nextstep\n");
906 uspi
->s_fsize
= block_size
= 1024;
907 uspi
->s_fmask
= ~(1024 - 1);
909 uspi
->s_sbsize
= super_block_size
= 2048;
911 uspi
->s_dirblksize
= 1024;
912 flags
|= UFS_DE_OLD
| UFS_UID_OLD
| UFS_ST_OLD
| UFS_CG_OLD
;
913 if (!(sb
->s_flags
& MS_RDONLY
)) {
915 pr_info("ufstype=nextstep is supported read-only\n");
916 sb
->s_flags
|= MS_RDONLY
;
920 case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD
:
921 UFSD("ufstype=nextstep-cd\n");
922 uspi
->s_fsize
= block_size
= 2048;
923 uspi
->s_fmask
= ~(2048 - 1);
925 uspi
->s_sbsize
= super_block_size
= 2048;
927 uspi
->s_dirblksize
= 1024;
928 flags
|= UFS_DE_OLD
| UFS_UID_OLD
| UFS_ST_OLD
| UFS_CG_OLD
;
929 if (!(sb
->s_flags
& MS_RDONLY
)) {
931 pr_info("ufstype=nextstep-cd is supported read-only\n");
932 sb
->s_flags
|= MS_RDONLY
;
936 case UFS_MOUNT_UFSTYPE_OPENSTEP
:
937 UFSD("ufstype=openstep\n");
938 uspi
->s_fsize
= block_size
= 1024;
939 uspi
->s_fmask
= ~(1024 - 1);
941 uspi
->s_sbsize
= super_block_size
= 2048;
943 uspi
->s_dirblksize
= 1024;
944 flags
|= UFS_DE_44BSD
| UFS_UID_44BSD
| UFS_ST_44BSD
| UFS_CG_44BSD
;
945 if (!(sb
->s_flags
& MS_RDONLY
)) {
947 pr_info("ufstype=openstep is supported read-only\n");
948 sb
->s_flags
|= MS_RDONLY
;
952 case UFS_MOUNT_UFSTYPE_HP
:
953 UFSD("ufstype=hp\n");
954 uspi
->s_fsize
= block_size
= 1024;
955 uspi
->s_fmask
= ~(1024 - 1);
957 uspi
->s_sbsize
= super_block_size
= 2048;
959 flags
|= UFS_DE_OLD
| UFS_UID_OLD
| UFS_ST_OLD
| UFS_CG_OLD
;
960 if (!(sb
->s_flags
& MS_RDONLY
)) {
962 pr_info("ufstype=hp is supported read-only\n");
963 sb
->s_flags
|= MS_RDONLY
;
968 pr_err("unknown ufstype\n");
973 if (!sb_set_blocksize(sb
, block_size
)) {
974 pr_err("failed to set blocksize\n");
979 * read ufs super block from device
982 ubh
= ubh_bread_uspi(uspi
, sb
, uspi
->s_sbbase
+ super_block_offset
/block_size
, super_block_size
);
987 usb1
= ubh_get_usb_first(uspi
);
988 usb2
= ubh_get_usb_second(uspi
);
989 usb3
= ubh_get_usb_third(uspi
);
991 /* Sort out mod used on SunOS 4.1.3 for fs_state */
992 uspi
->s_postblformat
= fs32_to_cpu(sb
, usb3
->fs_postblformat
);
993 if (((flags
& UFS_ST_MASK
) == UFS_ST_SUNOS
) &&
994 (uspi
->s_postblformat
!= UFS_42POSTBLFMT
)) {
995 flags
&= ~UFS_ST_MASK
;
1000 * Check ufs magic number
1002 sbi
->s_bytesex
= BYTESEX_LE
;
1003 switch ((uspi
->fs_magic
= fs32_to_cpu(sb
, usb3
->fs_magic
))) {
1012 sbi
->s_bytesex
= BYTESEX_BE
;
1013 switch ((uspi
->fs_magic
= fs32_to_cpu(sb
, usb3
->fs_magic
))) {
1023 if ((((sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) == UFS_MOUNT_UFSTYPE_NEXTSTEP
)
1024 || ((sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD
)
1025 || ((sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) == UFS_MOUNT_UFSTYPE_OPENSTEP
))
1026 && uspi
->s_sbbase
< 256) {
1027 ubh_brelse_uspi(uspi
);
1029 uspi
->s_sbbase
+= 8;
1033 pr_err("%s(): bad magic number\n", __func__
);
1038 * Check block and fragment sizes
1040 uspi
->s_bsize
= fs32_to_cpu(sb
, usb1
->fs_bsize
);
1041 uspi
->s_fsize
= fs32_to_cpu(sb
, usb1
->fs_fsize
);
1042 uspi
->s_sbsize
= fs32_to_cpu(sb
, usb1
->fs_sbsize
);
1043 uspi
->s_fmask
= fs32_to_cpu(sb
, usb1
->fs_fmask
);
1044 uspi
->s_fshift
= fs32_to_cpu(sb
, usb1
->fs_fshift
);
1046 if (!is_power_of_2(uspi
->s_fsize
)) {
1047 pr_err("%s(): fragment size %u is not a power of 2\n",
1048 __func__
, uspi
->s_fsize
);
1051 if (uspi
->s_fsize
< 512) {
1052 pr_err("%s(): fragment size %u is too small\n",
1053 __func__
, uspi
->s_fsize
);
1056 if (uspi
->s_fsize
> 4096) {
1057 pr_err("%s(): fragment size %u is too large\n",
1058 __func__
, uspi
->s_fsize
);
1061 if (!is_power_of_2(uspi
->s_bsize
)) {
1062 pr_err("%s(): block size %u is not a power of 2\n",
1063 __func__
, uspi
->s_bsize
);
1066 if (uspi
->s_bsize
< 4096) {
1067 pr_err("%s(): block size %u is too small\n",
1068 __func__
, uspi
->s_bsize
);
1071 if (uspi
->s_bsize
/ uspi
->s_fsize
> 8) {
1072 pr_err("%s(): too many fragments per block (%u)\n",
1073 __func__
, uspi
->s_bsize
/ uspi
->s_fsize
);
1076 if (uspi
->s_fsize
!= block_size
|| uspi
->s_sbsize
!= super_block_size
) {
1077 ubh_brelse_uspi(uspi
);
1079 block_size
= uspi
->s_fsize
;
1080 super_block_size
= uspi
->s_sbsize
;
1081 UFSD("another value of block_size or super_block_size %u, %u\n", block_size
, super_block_size
);
1085 sbi
->s_flags
= flags
;/*after that line some functions use s_flags*/
1086 ufs_print_super_stuff(sb
, usb1
, usb2
, usb3
);
1089 * Check, if file system was correctly unmounted.
1090 * If not, make it read only.
1092 if (((flags
& UFS_ST_MASK
) == UFS_ST_44BSD
) ||
1093 ((flags
& UFS_ST_MASK
) == UFS_ST_OLD
) ||
1094 (((flags
& UFS_ST_MASK
) == UFS_ST_SUN
||
1095 (flags
& UFS_ST_MASK
) == UFS_ST_SUNOS
||
1096 (flags
& UFS_ST_MASK
) == UFS_ST_SUNx86
) &&
1097 (ufs_get_fs_state(sb
, usb1
, usb3
) == (UFS_FSOK
- fs32_to_cpu(sb
, usb1
->fs_time
))))) {
1098 switch(usb1
->fs_clean
) {
1100 UFSD("fs is clean\n");
1103 UFSD("fs is stable\n");
1106 UFSD("fs is logging fs\n");
1109 UFSD("fs is DEC OSF/1\n");
1112 pr_err("%s(): fs is active\n", __func__
);
1113 sb
->s_flags
|= MS_RDONLY
;
1116 pr_err("%s(): fs is bad\n", __func__
);
1117 sb
->s_flags
|= MS_RDONLY
;
1120 pr_err("%s(): can't grok fs_clean 0x%x\n",
1121 __func__
, usb1
->fs_clean
);
1122 sb
->s_flags
|= MS_RDONLY
;
1126 pr_err("%s(): fs needs fsck\n", __func__
);
1127 sb
->s_flags
|= MS_RDONLY
;
1131 * Read ufs_super_block into internal data structures
1133 sb
->s_op
= &ufs_super_ops
;
1134 sb
->s_export_op
= &ufs_export_ops
;
1136 sb
->s_magic
= fs32_to_cpu(sb
, usb3
->fs_magic
);
1138 uspi
->s_sblkno
= fs32_to_cpu(sb
, usb1
->fs_sblkno
);
1139 uspi
->s_cblkno
= fs32_to_cpu(sb
, usb1
->fs_cblkno
);
1140 uspi
->s_iblkno
= fs32_to_cpu(sb
, usb1
->fs_iblkno
);
1141 uspi
->s_dblkno
= fs32_to_cpu(sb
, usb1
->fs_dblkno
);
1142 uspi
->s_cgoffset
= fs32_to_cpu(sb
, usb1
->fs_cgoffset
);
1143 uspi
->s_cgmask
= fs32_to_cpu(sb
, usb1
->fs_cgmask
);
1145 if ((flags
& UFS_TYPE_MASK
) == UFS_TYPE_UFS2
) {
1146 uspi
->s_u2_size
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_size
);
1147 uspi
->s_u2_dsize
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_dsize
);
1149 uspi
->s_size
= fs32_to_cpu(sb
, usb1
->fs_size
);
1150 uspi
->s_dsize
= fs32_to_cpu(sb
, usb1
->fs_dsize
);
1153 uspi
->s_ncg
= fs32_to_cpu(sb
, usb1
->fs_ncg
);
1154 /* s_bsize already set */
1155 /* s_fsize already set */
1156 uspi
->s_fpb
= fs32_to_cpu(sb
, usb1
->fs_frag
);
1157 uspi
->s_minfree
= fs32_to_cpu(sb
, usb1
->fs_minfree
);
1158 uspi
->s_bmask
= fs32_to_cpu(sb
, usb1
->fs_bmask
);
1159 uspi
->s_fmask
= fs32_to_cpu(sb
, usb1
->fs_fmask
);
1160 uspi
->s_bshift
= fs32_to_cpu(sb
, usb1
->fs_bshift
);
1161 uspi
->s_fshift
= fs32_to_cpu(sb
, usb1
->fs_fshift
);
1162 UFSD("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi
->s_bshift
,
1164 uspi
->s_fpbshift
= fs32_to_cpu(sb
, usb1
->fs_fragshift
);
1165 uspi
->s_fsbtodb
= fs32_to_cpu(sb
, usb1
->fs_fsbtodb
);
1166 /* s_sbsize already set */
1167 uspi
->s_csmask
= fs32_to_cpu(sb
, usb1
->fs_csmask
);
1168 uspi
->s_csshift
= fs32_to_cpu(sb
, usb1
->fs_csshift
);
1169 uspi
->s_nindir
= fs32_to_cpu(sb
, usb1
->fs_nindir
);
1170 uspi
->s_inopb
= fs32_to_cpu(sb
, usb1
->fs_inopb
);
1171 uspi
->s_nspf
= fs32_to_cpu(sb
, usb1
->fs_nspf
);
1172 uspi
->s_npsect
= ufs_get_fs_npsect(sb
, usb1
, usb3
);
1173 uspi
->s_interleave
= fs32_to_cpu(sb
, usb1
->fs_interleave
);
1174 uspi
->s_trackskew
= fs32_to_cpu(sb
, usb1
->fs_trackskew
);
1176 if (uspi
->fs_magic
== UFS2_MAGIC
)
1177 uspi
->s_csaddr
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_csaddr
);
1179 uspi
->s_csaddr
= fs32_to_cpu(sb
, usb1
->fs_csaddr
);
1181 uspi
->s_cssize
= fs32_to_cpu(sb
, usb1
->fs_cssize
);
1182 uspi
->s_cgsize
= fs32_to_cpu(sb
, usb1
->fs_cgsize
);
1183 uspi
->s_ntrak
= fs32_to_cpu(sb
, usb1
->fs_ntrak
);
1184 uspi
->s_nsect
= fs32_to_cpu(sb
, usb1
->fs_nsect
);
1185 uspi
->s_spc
= fs32_to_cpu(sb
, usb1
->fs_spc
);
1186 uspi
->s_ipg
= fs32_to_cpu(sb
, usb1
->fs_ipg
);
1187 uspi
->s_fpg
= fs32_to_cpu(sb
, usb1
->fs_fpg
);
1188 uspi
->s_cpc
= fs32_to_cpu(sb
, usb2
->fs_un
.fs_u1
.fs_cpc
);
1189 uspi
->s_contigsumsize
= fs32_to_cpu(sb
, usb3
->fs_un2
.fs_44
.fs_contigsumsize
);
1190 uspi
->s_qbmask
= ufs_get_fs_qbmask(sb
, usb3
);
1191 uspi
->s_qfmask
= ufs_get_fs_qfmask(sb
, usb3
);
1192 uspi
->s_nrpos
= fs32_to_cpu(sb
, usb3
->fs_nrpos
);
1193 uspi
->s_postbloff
= fs32_to_cpu(sb
, usb3
->fs_postbloff
);
1194 uspi
->s_rotbloff
= fs32_to_cpu(sb
, usb3
->fs_rotbloff
);
1197 * Compute another frequently used values
1199 uspi
->s_fpbmask
= uspi
->s_fpb
- 1;
1200 if ((flags
& UFS_TYPE_MASK
) == UFS_TYPE_UFS2
)
1201 uspi
->s_apbshift
= uspi
->s_bshift
- 3;
1203 uspi
->s_apbshift
= uspi
->s_bshift
- 2;
1205 uspi
->s_2apbshift
= uspi
->s_apbshift
* 2;
1206 uspi
->s_3apbshift
= uspi
->s_apbshift
* 3;
1207 uspi
->s_apb
= 1 << uspi
->s_apbshift
;
1208 uspi
->s_2apb
= 1 << uspi
->s_2apbshift
;
1209 uspi
->s_3apb
= 1 << uspi
->s_3apbshift
;
1210 uspi
->s_apbmask
= uspi
->s_apb
- 1;
1211 uspi
->s_nspfshift
= uspi
->s_fshift
- UFS_SECTOR_BITS
;
1212 uspi
->s_nspb
= uspi
->s_nspf
<< uspi
->s_fpbshift
;
1213 uspi
->s_inopf
= uspi
->s_inopb
>> uspi
->s_fpbshift
;
1214 uspi
->s_bpf
= uspi
->s_fsize
<< 3;
1215 uspi
->s_bpfshift
= uspi
->s_fshift
+ 3;
1216 uspi
->s_bpfmask
= uspi
->s_bpf
- 1;
1217 if ((sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) == UFS_MOUNT_UFSTYPE_44BSD
||
1218 (sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) == UFS_MOUNT_UFSTYPE_UFS2
)
1219 uspi
->s_maxsymlinklen
=
1220 fs32_to_cpu(sb
, usb3
->fs_un2
.fs_44
.fs_maxsymlinklen
);
1222 if (uspi
->fs_magic
== UFS2_MAGIC
)
1223 maxsymlen
= 2 * 4 * (UFS_NDADDR
+ UFS_NINDIR
);
1225 maxsymlen
= 4 * (UFS_NDADDR
+ UFS_NINDIR
);
1226 if (uspi
->s_maxsymlinklen
> maxsymlen
) {
1227 ufs_warning(sb
, __func__
, "ufs_read_super: excessive maximum "
1228 "fast symlink size (%u)\n", uspi
->s_maxsymlinklen
);
1229 uspi
->s_maxsymlinklen
= maxsymlen
;
1231 sb
->s_max_links
= UFS_LINK_MAX
;
1233 inode
= ufs_iget(sb
, UFS_ROOTINO
);
1234 if (IS_ERR(inode
)) {
1235 ret
= PTR_ERR(inode
);
1238 sb
->s_root
= d_make_root(inode
);
1244 ufs_setup_cstotal(sb
);
1246 * Read cylinder group structures
1248 if (!(sb
->s_flags
& MS_RDONLY
))
1249 if (!ufs_read_cylinder_structures(sb
))
1256 mutex_destroy(&sbi
->mutex
);
1258 ubh_brelse_uspi (uspi
);
1261 sb
->s_fs_info
= NULL
;
1262 UFSD("EXIT (FAILED)\n");
1266 UFSD("EXIT (NOMEM)\n");
1270 static int ufs_remount (struct super_block
*sb
, int *mount_flags
, char *data
)
1272 struct ufs_sb_private_info
* uspi
;
1273 struct ufs_super_block_first
* usb1
;
1274 struct ufs_super_block_third
* usb3
;
1275 unsigned new_mount_opt
, ufstype
;
1278 sync_filesystem(sb
);
1280 uspi
= UFS_SB(sb
)->s_uspi
;
1281 flags
= UFS_SB(sb
)->s_flags
;
1282 usb1
= ubh_get_usb_first(uspi
);
1283 usb3
= ubh_get_usb_third(uspi
);
1286 * Allow the "check" option to be passed as a remount option.
1287 * It is not possible to change ufstype option during remount
1289 ufstype
= UFS_SB(sb
)->s_mount_opt
& UFS_MOUNT_UFSTYPE
;
1291 ufs_set_opt (new_mount_opt
, ONERROR_LOCK
);
1292 if (!ufs_parse_options (data
, &new_mount_opt
)) {
1296 if (!(new_mount_opt
& UFS_MOUNT_UFSTYPE
)) {
1297 new_mount_opt
|= ufstype
;
1298 } else if ((new_mount_opt
& UFS_MOUNT_UFSTYPE
) != ufstype
) {
1299 pr_err("ufstype can't be changed during remount\n");
1304 if ((*mount_flags
& MS_RDONLY
) == (sb
->s_flags
& MS_RDONLY
)) {
1305 UFS_SB(sb
)->s_mount_opt
= new_mount_opt
;
1311 * fs was mouted as rw, remounting ro
1313 if (*mount_flags
& MS_RDONLY
) {
1314 ufs_put_super_internal(sb
);
1315 usb1
->fs_time
= cpu_to_fs32(sb
, get_seconds());
1316 if ((flags
& UFS_ST_MASK
) == UFS_ST_SUN
1317 || (flags
& UFS_ST_MASK
) == UFS_ST_SUNOS
1318 || (flags
& UFS_ST_MASK
) == UFS_ST_SUNx86
)
1319 ufs_set_fs_state(sb
, usb1
, usb3
,
1320 UFS_FSOK
- fs32_to_cpu(sb
, usb1
->fs_time
));
1321 ubh_mark_buffer_dirty (USPI_UBH(uspi
));
1322 sb
->s_flags
|= MS_RDONLY
;
1325 * fs was mounted as ro, remounting rw
1327 #ifndef CONFIG_UFS_FS_WRITE
1328 pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
1332 if (ufstype
!= UFS_MOUNT_UFSTYPE_SUN
&&
1333 ufstype
!= UFS_MOUNT_UFSTYPE_SUNOS
&&
1334 ufstype
!= UFS_MOUNT_UFSTYPE_44BSD
&&
1335 ufstype
!= UFS_MOUNT_UFSTYPE_SUNx86
&&
1336 ufstype
!= UFS_MOUNT_UFSTYPE_UFS2
) {
1337 pr_err("this ufstype is read-only supported\n");
1341 if (!ufs_read_cylinder_structures(sb
)) {
1342 pr_err("failed during remounting\n");
1346 sb
->s_flags
&= ~MS_RDONLY
;
1349 UFS_SB(sb
)->s_mount_opt
= new_mount_opt
;
1354 static int ufs_show_options(struct seq_file
*seq
, struct dentry
*root
)
1356 struct ufs_sb_info
*sbi
= UFS_SB(root
->d_sb
);
1357 unsigned mval
= sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
;
1358 const struct match_token
*tp
= tokens
;
1360 while (tp
->token
!= Opt_onerror_panic
&& tp
->token
!= mval
)
1362 BUG_ON(tp
->token
== Opt_onerror_panic
);
1363 seq_printf(seq
, ",%s", tp
->pattern
);
1365 mval
= sbi
->s_mount_opt
& UFS_MOUNT_ONERROR
;
1366 while (tp
->token
!= Opt_err
&& tp
->token
!= mval
)
1368 BUG_ON(tp
->token
== Opt_err
);
1369 seq_printf(seq
, ",%s", tp
->pattern
);
1374 static int ufs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
1376 struct super_block
*sb
= dentry
->d_sb
;
1377 struct ufs_sb_private_info
*uspi
= UFS_SB(sb
)->s_uspi
;
1378 unsigned flags
= UFS_SB(sb
)->s_flags
;
1379 struct ufs_super_block_third
*usb3
;
1380 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
1384 usb3
= ubh_get_usb_third(uspi
);
1386 if ((flags
& UFS_TYPE_MASK
) == UFS_TYPE_UFS2
) {
1387 buf
->f_type
= UFS2_MAGIC
;
1388 buf
->f_blocks
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_dsize
);
1390 buf
->f_type
= UFS_MAGIC
;
1391 buf
->f_blocks
= uspi
->s_dsize
;
1393 buf
->f_bfree
= ufs_blkstofrags(uspi
->cs_total
.cs_nbfree
) +
1394 uspi
->cs_total
.cs_nffree
;
1395 buf
->f_ffree
= uspi
->cs_total
.cs_nifree
;
1396 buf
->f_bsize
= sb
->s_blocksize
;
1397 buf
->f_bavail
= (buf
->f_bfree
> (((long)buf
->f_blocks
/ 100) * uspi
->s_minfree
))
1398 ? (buf
->f_bfree
- (((long)buf
->f_blocks
/ 100) * uspi
->s_minfree
)) : 0;
1399 buf
->f_files
= uspi
->s_ncg
* uspi
->s_ipg
;
1400 buf
->f_namelen
= UFS_MAXNAMLEN
;
1401 buf
->f_fsid
.val
[0] = (u32
)id
;
1402 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
1409 static struct kmem_cache
* ufs_inode_cachep
;
1411 static struct inode
*ufs_alloc_inode(struct super_block
*sb
)
1413 struct ufs_inode_info
*ei
;
1415 ei
= kmem_cache_alloc(ufs_inode_cachep
, GFP_NOFS
);
1419 ei
->vfs_inode
.i_version
= 1;
1420 return &ei
->vfs_inode
;
1423 static void ufs_i_callback(struct rcu_head
*head
)
1425 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
1426 kmem_cache_free(ufs_inode_cachep
, UFS_I(inode
));
1429 static void ufs_destroy_inode(struct inode
*inode
)
1431 call_rcu(&inode
->i_rcu
, ufs_i_callback
);
1434 static void init_once(void *foo
)
1436 struct ufs_inode_info
*ei
= (struct ufs_inode_info
*) foo
;
1438 inode_init_once(&ei
->vfs_inode
);
1441 static int __init
init_inodecache(void)
1443 ufs_inode_cachep
= kmem_cache_create("ufs_inode_cache",
1444 sizeof(struct ufs_inode_info
),
1445 0, (SLAB_RECLAIM_ACCOUNT
|
1448 if (ufs_inode_cachep
== NULL
)
1453 static void destroy_inodecache(void)
1456 * Make sure all delayed rcu free inodes are flushed before we
1460 kmem_cache_destroy(ufs_inode_cachep
);
1463 static const struct super_operations ufs_super_ops
= {
1464 .alloc_inode
= ufs_alloc_inode
,
1465 .destroy_inode
= ufs_destroy_inode
,
1466 .write_inode
= ufs_write_inode
,
1467 .evict_inode
= ufs_evict_inode
,
1468 .put_super
= ufs_put_super
,
1469 .sync_fs
= ufs_sync_fs
,
1470 .statfs
= ufs_statfs
,
1471 .remount_fs
= ufs_remount
,
1472 .show_options
= ufs_show_options
,
1475 static struct dentry
*ufs_mount(struct file_system_type
*fs_type
,
1476 int flags
, const char *dev_name
, void *data
)
1478 return mount_bdev(fs_type
, flags
, dev_name
, data
, ufs_fill_super
);
1481 static struct file_system_type ufs_fs_type
= {
1482 .owner
= THIS_MODULE
,
1485 .kill_sb
= kill_block_super
,
1486 .fs_flags
= FS_REQUIRES_DEV
,
1488 MODULE_ALIAS_FS("ufs");
1490 static int __init
init_ufs_fs(void)
1492 int err
= init_inodecache();
1495 err
= register_filesystem(&ufs_fs_type
);
1500 destroy_inodecache();
1505 static void __exit
exit_ufs_fs(void)
1507 unregister_filesystem(&ufs_fs_type
);
1508 destroy_inodecache();
1511 module_init(init_ufs_fs
)
1512 module_exit(exit_ufs_fs
)
1513 MODULE_LICENSE("GPL");