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
69 #include <linux/exportfs.h>
70 #include <linux/module.h>
71 #include <linux/bitops.h>
75 #include <asm/uaccess.h>
76 #include <asm/system.h>
78 #include <linux/errno.h>
80 #include <linux/slab.h>
81 #include <linux/time.h>
82 #include <linux/stat.h>
83 #include <linux/string.h>
84 #include <linux/blkdev.h>
85 #include <linux/init.h>
86 #include <linux/parser.h>
87 #include <linux/smp_lock.h>
88 #include <linux/buffer_head.h>
89 #include <linux/vfs.h>
90 #include <linux/log2.h>
91 #include <linux/mount.h>
92 #include <linux/seq_file.h>
99 static struct inode
*ufs_nfs_get_inode(struct super_block
*sb
, u64 ino
, u32 generation
)
101 struct ufs_sb_private_info
*uspi
= UFS_SB(sb
)->s_uspi
;
104 if (ino
< UFS_ROOTINO
|| ino
> uspi
->s_ncg
* uspi
->s_ipg
)
105 return ERR_PTR(-ESTALE
);
107 inode
= ufs_iget(sb
, ino
);
109 return ERR_CAST(inode
);
110 if (generation
&& inode
->i_generation
!= generation
) {
112 return ERR_PTR(-ESTALE
);
117 static struct dentry
*ufs_fh_to_dentry(struct super_block
*sb
, struct fid
*fid
,
118 int fh_len
, int fh_type
)
120 return generic_fh_to_dentry(sb
, fid
, fh_len
, fh_type
, ufs_nfs_get_inode
);
123 static struct dentry
*ufs_fh_to_parent(struct super_block
*sb
, struct fid
*fid
,
124 int fh_len
, int fh_type
)
126 return generic_fh_to_parent(sb
, fid
, fh_len
, fh_type
, ufs_nfs_get_inode
);
129 static struct dentry
*ufs_get_parent(struct dentry
*child
)
131 struct qstr dot_dot
= {
137 ino
= ufs_inode_by_name(child
->d_inode
, &dot_dot
);
139 return ERR_PTR(-ENOENT
);
140 return d_obtain_alias(ufs_iget(child
->d_inode
->i_sb
, ino
));
143 static const struct export_operations ufs_export_ops
= {
144 .fh_to_dentry
= ufs_fh_to_dentry
,
145 .fh_to_parent
= ufs_fh_to_parent
,
146 .get_parent
= ufs_get_parent
,
149 #ifdef CONFIG_UFS_DEBUG
151 * Print contents of ufs_super_block, useful for debugging
153 static void ufs_print_super_stuff(struct super_block
*sb
,
154 struct ufs_super_block_first
*usb1
,
155 struct ufs_super_block_second
*usb2
,
156 struct ufs_super_block_third
*usb3
)
158 u32 magic
= fs32_to_cpu(sb
, usb3
->fs_magic
);
160 printk("ufs_print_super_stuff\n");
161 printk(" magic: 0x%x\n", magic
);
162 if (fs32_to_cpu(sb
, usb3
->fs_magic
) == UFS2_MAGIC
) {
163 printk(" fs_size: %llu\n", (unsigned long long)
164 fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_size
));
165 printk(" fs_dsize: %llu\n", (unsigned long long)
166 fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_dsize
));
167 printk(" bsize: %u\n",
168 fs32_to_cpu(sb
, usb1
->fs_bsize
));
169 printk(" fsize: %u\n",
170 fs32_to_cpu(sb
, usb1
->fs_fsize
));
171 printk(" fs_volname: %s\n", usb2
->fs_un
.fs_u2
.fs_volname
);
172 printk(" fs_sblockloc: %llu\n", (unsigned long long)
173 fs64_to_cpu(sb
, usb2
->fs_un
.fs_u2
.fs_sblockloc
));
174 printk(" cs_ndir(No of dirs): %llu\n", (unsigned long long)
175 fs64_to_cpu(sb
, usb2
->fs_un
.fs_u2
.cs_ndir
));
176 printk(" cs_nbfree(No of free blocks): %llu\n",
178 fs64_to_cpu(sb
, usb2
->fs_un
.fs_u2
.cs_nbfree
));
179 printk(KERN_INFO
" cs_nifree(Num of free inodes): %llu\n",
181 fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.cs_nifree
));
182 printk(KERN_INFO
" cs_nffree(Num of free frags): %llu\n",
184 fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.cs_nffree
));
185 printk(KERN_INFO
" fs_maxsymlinklen: %u\n",
186 fs32_to_cpu(sb
, usb3
->fs_un2
.fs_44
.fs_maxsymlinklen
));
188 printk(" sblkno: %u\n", fs32_to_cpu(sb
, usb1
->fs_sblkno
));
189 printk(" cblkno: %u\n", fs32_to_cpu(sb
, usb1
->fs_cblkno
));
190 printk(" iblkno: %u\n", fs32_to_cpu(sb
, usb1
->fs_iblkno
));
191 printk(" dblkno: %u\n", fs32_to_cpu(sb
, usb1
->fs_dblkno
));
192 printk(" cgoffset: %u\n",
193 fs32_to_cpu(sb
, usb1
->fs_cgoffset
));
194 printk(" ~cgmask: 0x%x\n",
195 ~fs32_to_cpu(sb
, usb1
->fs_cgmask
));
196 printk(" size: %u\n", fs32_to_cpu(sb
, usb1
->fs_size
));
197 printk(" dsize: %u\n", fs32_to_cpu(sb
, usb1
->fs_dsize
));
198 printk(" ncg: %u\n", fs32_to_cpu(sb
, usb1
->fs_ncg
));
199 printk(" bsize: %u\n", fs32_to_cpu(sb
, usb1
->fs_bsize
));
200 printk(" fsize: %u\n", fs32_to_cpu(sb
, usb1
->fs_fsize
));
201 printk(" frag: %u\n", fs32_to_cpu(sb
, usb1
->fs_frag
));
202 printk(" fragshift: %u\n",
203 fs32_to_cpu(sb
, usb1
->fs_fragshift
));
204 printk(" ~fmask: %u\n", ~fs32_to_cpu(sb
, usb1
->fs_fmask
));
205 printk(" fshift: %u\n", fs32_to_cpu(sb
, usb1
->fs_fshift
));
206 printk(" sbsize: %u\n", fs32_to_cpu(sb
, usb1
->fs_sbsize
));
207 printk(" spc: %u\n", fs32_to_cpu(sb
, usb1
->fs_spc
));
208 printk(" cpg: %u\n", fs32_to_cpu(sb
, usb1
->fs_cpg
));
209 printk(" ipg: %u\n", fs32_to_cpu(sb
, usb1
->fs_ipg
));
210 printk(" fpg: %u\n", fs32_to_cpu(sb
, usb1
->fs_fpg
));
211 printk(" csaddr: %u\n", fs32_to_cpu(sb
, usb1
->fs_csaddr
));
212 printk(" cssize: %u\n", fs32_to_cpu(sb
, usb1
->fs_cssize
));
213 printk(" cgsize: %u\n", fs32_to_cpu(sb
, usb1
->fs_cgsize
));
214 printk(" fstodb: %u\n",
215 fs32_to_cpu(sb
, usb1
->fs_fsbtodb
));
216 printk(" nrpos: %u\n", fs32_to_cpu(sb
, usb3
->fs_nrpos
));
218 fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_ndir
));
219 printk(" nifree %u\n",
220 fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nifree
));
221 printk(" nbfree %u\n",
222 fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nbfree
));
223 printk(" nffree %u\n",
224 fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nffree
));
230 * Print contents of ufs_cylinder_group, useful for debugging
232 static void ufs_print_cylinder_stuff(struct super_block
*sb
,
233 struct ufs_cylinder_group
*cg
)
235 printk("\nufs_print_cylinder_stuff\n");
236 printk("size of ucg: %zu\n", sizeof(struct ufs_cylinder_group
));
237 printk(" magic: %x\n", fs32_to_cpu(sb
, cg
->cg_magic
));
238 printk(" time: %u\n", fs32_to_cpu(sb
, cg
->cg_time
));
239 printk(" cgx: %u\n", fs32_to_cpu(sb
, cg
->cg_cgx
));
240 printk(" ncyl: %u\n", fs16_to_cpu(sb
, cg
->cg_ncyl
));
241 printk(" niblk: %u\n", fs16_to_cpu(sb
, cg
->cg_niblk
));
242 printk(" ndblk: %u\n", fs32_to_cpu(sb
, cg
->cg_ndblk
));
243 printk(" cs_ndir: %u\n", fs32_to_cpu(sb
, cg
->cg_cs
.cs_ndir
));
244 printk(" cs_nbfree: %u\n", fs32_to_cpu(sb
, cg
->cg_cs
.cs_nbfree
));
245 printk(" cs_nifree: %u\n", fs32_to_cpu(sb
, cg
->cg_cs
.cs_nifree
));
246 printk(" cs_nffree: %u\n", fs32_to_cpu(sb
, cg
->cg_cs
.cs_nffree
));
247 printk(" rotor: %u\n", fs32_to_cpu(sb
, cg
->cg_rotor
));
248 printk(" frotor: %u\n", fs32_to_cpu(sb
, cg
->cg_frotor
));
249 printk(" irotor: %u\n", fs32_to_cpu(sb
, cg
->cg_irotor
));
250 printk(" frsum: %u, %u, %u, %u, %u, %u, %u, %u\n",
251 fs32_to_cpu(sb
, cg
->cg_frsum
[0]), fs32_to_cpu(sb
, cg
->cg_frsum
[1]),
252 fs32_to_cpu(sb
, cg
->cg_frsum
[2]), fs32_to_cpu(sb
, cg
->cg_frsum
[3]),
253 fs32_to_cpu(sb
, cg
->cg_frsum
[4]), fs32_to_cpu(sb
, cg
->cg_frsum
[5]),
254 fs32_to_cpu(sb
, cg
->cg_frsum
[6]), fs32_to_cpu(sb
, cg
->cg_frsum
[7]));
255 printk(" btotoff: %u\n", fs32_to_cpu(sb
, cg
->cg_btotoff
));
256 printk(" boff: %u\n", fs32_to_cpu(sb
, cg
->cg_boff
));
257 printk(" iuseoff: %u\n", fs32_to_cpu(sb
, cg
->cg_iusedoff
));
258 printk(" freeoff: %u\n", fs32_to_cpu(sb
, cg
->cg_freeoff
));
259 printk(" nextfreeoff: %u\n", fs32_to_cpu(sb
, cg
->cg_nextfreeoff
));
260 printk(" clustersumoff %u\n",
261 fs32_to_cpu(sb
, cg
->cg_u
.cg_44
.cg_clustersumoff
));
262 printk(" clusteroff %u\n",
263 fs32_to_cpu(sb
, cg
->cg_u
.cg_44
.cg_clusteroff
));
264 printk(" nclusterblks %u\n",
265 fs32_to_cpu(sb
, cg
->cg_u
.cg_44
.cg_nclusterblks
));
269 # define ufs_print_super_stuff(sb, usb1, usb2, usb3) /**/
270 # define ufs_print_cylinder_stuff(sb, cg) /**/
271 #endif /* CONFIG_UFS_DEBUG */
273 static const struct super_operations ufs_super_ops
;
275 static char error_buf
[1024];
277 void ufs_error (struct super_block
* sb
, const char * function
,
278 const char * fmt
, ...)
280 struct ufs_sb_private_info
* uspi
;
281 struct ufs_super_block_first
* usb1
;
284 uspi
= UFS_SB(sb
)->s_uspi
;
285 usb1
= ubh_get_usb_first(uspi
);
287 if (!(sb
->s_flags
& MS_RDONLY
)) {
288 usb1
->fs_clean
= UFS_FSBAD
;
289 ubh_mark_buffer_dirty(USPI_UBH(uspi
));
291 sb
->s_flags
|= MS_RDONLY
;
293 va_start (args
, fmt
);
294 vsnprintf (error_buf
, sizeof(error_buf
), fmt
, args
);
296 switch (UFS_SB(sb
)->s_mount_opt
& UFS_MOUNT_ONERROR
) {
297 case UFS_MOUNT_ONERROR_PANIC
:
298 panic ("UFS-fs panic (device %s): %s: %s\n",
299 sb
->s_id
, function
, error_buf
);
301 case UFS_MOUNT_ONERROR_LOCK
:
302 case UFS_MOUNT_ONERROR_UMOUNT
:
303 case UFS_MOUNT_ONERROR_REPAIR
:
304 printk (KERN_CRIT
"UFS-fs error (device %s): %s: %s\n",
305 sb
->s_id
, function
, error_buf
);
309 void ufs_panic (struct super_block
* sb
, const char * function
,
310 const char * fmt
, ...)
312 struct ufs_sb_private_info
* uspi
;
313 struct ufs_super_block_first
* usb1
;
317 uspi
= UFS_SB(sb
)->s_uspi
;
318 usb1
= ubh_get_usb_first(uspi
);
320 if (!(sb
->s_flags
& MS_RDONLY
)) {
321 usb1
->fs_clean
= UFS_FSBAD
;
322 ubh_mark_buffer_dirty(USPI_UBH(uspi
));
325 va_start (args
, fmt
);
326 vsnprintf (error_buf
, sizeof(error_buf
), fmt
, args
);
328 sb
->s_flags
|= MS_RDONLY
;
329 printk (KERN_CRIT
"UFS-fs panic (device %s): %s: %s\n",
330 sb
->s_id
, function
, error_buf
);
333 void ufs_warning (struct super_block
* sb
, const char * function
,
334 const char * fmt
, ...)
338 va_start (args
, fmt
);
339 vsnprintf (error_buf
, sizeof(error_buf
), fmt
, args
);
341 printk (KERN_WARNING
"UFS-fs warning (device %s): %s: %s\n",
342 sb
->s_id
, function
, error_buf
);
346 Opt_type_old
= UFS_MOUNT_UFSTYPE_OLD
,
347 Opt_type_sunx86
= UFS_MOUNT_UFSTYPE_SUNx86
,
348 Opt_type_sun
= UFS_MOUNT_UFSTYPE_SUN
,
349 Opt_type_sunos
= UFS_MOUNT_UFSTYPE_SUNOS
,
350 Opt_type_44bsd
= UFS_MOUNT_UFSTYPE_44BSD
,
351 Opt_type_ufs2
= UFS_MOUNT_UFSTYPE_UFS2
,
352 Opt_type_hp
= UFS_MOUNT_UFSTYPE_HP
,
353 Opt_type_nextstepcd
= UFS_MOUNT_UFSTYPE_NEXTSTEP_CD
,
354 Opt_type_nextstep
= UFS_MOUNT_UFSTYPE_NEXTSTEP
,
355 Opt_type_openstep
= UFS_MOUNT_UFSTYPE_OPENSTEP
,
356 Opt_onerror_panic
= UFS_MOUNT_ONERROR_PANIC
,
357 Opt_onerror_lock
= UFS_MOUNT_ONERROR_LOCK
,
358 Opt_onerror_umount
= UFS_MOUNT_ONERROR_UMOUNT
,
359 Opt_onerror_repair
= UFS_MOUNT_ONERROR_REPAIR
,
363 static const match_table_t tokens
= {
364 {Opt_type_old
, "ufstype=old"},
365 {Opt_type_sunx86
, "ufstype=sunx86"},
366 {Opt_type_sun
, "ufstype=sun"},
367 {Opt_type_sunos
, "ufstype=sunos"},
368 {Opt_type_44bsd
, "ufstype=44bsd"},
369 {Opt_type_ufs2
, "ufstype=ufs2"},
370 {Opt_type_ufs2
, "ufstype=5xbsd"},
371 {Opt_type_hp
, "ufstype=hp"},
372 {Opt_type_nextstepcd
, "ufstype=nextstep-cd"},
373 {Opt_type_nextstep
, "ufstype=nextstep"},
374 {Opt_type_openstep
, "ufstype=openstep"},
375 /*end of possible ufs types */
376 {Opt_onerror_panic
, "onerror=panic"},
377 {Opt_onerror_lock
, "onerror=lock"},
378 {Opt_onerror_umount
, "onerror=umount"},
379 {Opt_onerror_repair
, "onerror=repair"},
383 static int ufs_parse_options (char * options
, unsigned * mount_options
)
392 while ((p
= strsep(&options
, ",")) != NULL
) {
393 substring_t args
[MAX_OPT_ARGS
];
398 token
= match_token(p
, tokens
, args
);
401 ufs_clear_opt (*mount_options
, UFSTYPE
);
402 ufs_set_opt (*mount_options
, UFSTYPE_OLD
);
404 case Opt_type_sunx86
:
405 ufs_clear_opt (*mount_options
, UFSTYPE
);
406 ufs_set_opt (*mount_options
, UFSTYPE_SUNx86
);
409 ufs_clear_opt (*mount_options
, UFSTYPE
);
410 ufs_set_opt (*mount_options
, UFSTYPE_SUN
);
413 ufs_clear_opt(*mount_options
, UFSTYPE
);
414 ufs_set_opt(*mount_options
, UFSTYPE_SUNOS
);
417 ufs_clear_opt (*mount_options
, UFSTYPE
);
418 ufs_set_opt (*mount_options
, UFSTYPE_44BSD
);
421 ufs_clear_opt(*mount_options
, UFSTYPE
);
422 ufs_set_opt(*mount_options
, UFSTYPE_UFS2
);
425 ufs_clear_opt (*mount_options
, UFSTYPE
);
426 ufs_set_opt (*mount_options
, UFSTYPE_HP
);
428 case Opt_type_nextstepcd
:
429 ufs_clear_opt (*mount_options
, UFSTYPE
);
430 ufs_set_opt (*mount_options
, UFSTYPE_NEXTSTEP_CD
);
432 case Opt_type_nextstep
:
433 ufs_clear_opt (*mount_options
, UFSTYPE
);
434 ufs_set_opt (*mount_options
, UFSTYPE_NEXTSTEP
);
436 case Opt_type_openstep
:
437 ufs_clear_opt (*mount_options
, UFSTYPE
);
438 ufs_set_opt (*mount_options
, UFSTYPE_OPENSTEP
);
440 case Opt_onerror_panic
:
441 ufs_clear_opt (*mount_options
, ONERROR
);
442 ufs_set_opt (*mount_options
, ONERROR_PANIC
);
444 case Opt_onerror_lock
:
445 ufs_clear_opt (*mount_options
, ONERROR
);
446 ufs_set_opt (*mount_options
, ONERROR_LOCK
);
448 case Opt_onerror_umount
:
449 ufs_clear_opt (*mount_options
, ONERROR
);
450 ufs_set_opt (*mount_options
, ONERROR_UMOUNT
);
452 case Opt_onerror_repair
:
453 printk("UFS-fs: Unable to do repair on error, "
454 "will lock lock instead\n");
455 ufs_clear_opt (*mount_options
, ONERROR
);
456 ufs_set_opt (*mount_options
, ONERROR_REPAIR
);
459 printk("UFS-fs: Invalid option: \"%s\" "
460 "or missing value\n", p
);
468 * Diffrent types of UFS hold fs_cstotal in different
469 * places, and use diffrent data structure for it.
470 * To make things simplier we just copy fs_cstotal to ufs_sb_private_info
472 static void ufs_setup_cstotal(struct super_block
*sb
)
474 struct ufs_sb_info
*sbi
= UFS_SB(sb
);
475 struct ufs_sb_private_info
*uspi
= sbi
->s_uspi
;
476 struct ufs_super_block_first
*usb1
;
477 struct ufs_super_block_second
*usb2
;
478 struct ufs_super_block_third
*usb3
;
479 unsigned mtype
= sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
;
481 UFSD("ENTER, mtype=%u\n", mtype
);
482 usb1
= ubh_get_usb_first(uspi
);
483 usb2
= ubh_get_usb_second(uspi
);
484 usb3
= ubh_get_usb_third(uspi
);
486 if ((mtype
== UFS_MOUNT_UFSTYPE_44BSD
&&
487 (usb1
->fs_flags
& UFS_FLAGS_UPDATED
)) ||
488 mtype
== UFS_MOUNT_UFSTYPE_UFS2
) {
489 /*we have statistic in different place, then usual*/
490 uspi
->cs_total
.cs_ndir
= fs64_to_cpu(sb
, usb2
->fs_un
.fs_u2
.cs_ndir
);
491 uspi
->cs_total
.cs_nbfree
= fs64_to_cpu(sb
, usb2
->fs_un
.fs_u2
.cs_nbfree
);
492 uspi
->cs_total
.cs_nifree
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.cs_nifree
);
493 uspi
->cs_total
.cs_nffree
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.cs_nffree
);
495 uspi
->cs_total
.cs_ndir
= fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_ndir
);
496 uspi
->cs_total
.cs_nbfree
= fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nbfree
);
497 uspi
->cs_total
.cs_nifree
= fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nifree
);
498 uspi
->cs_total
.cs_nffree
= fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nffree
);
504 * Read on-disk structures associated with cylinder groups
506 static int ufs_read_cylinder_structures(struct super_block
*sb
)
508 struct ufs_sb_info
*sbi
= UFS_SB(sb
);
509 struct ufs_sb_private_info
*uspi
= sbi
->s_uspi
;
510 struct ufs_buffer_head
* ubh
;
511 unsigned char * base
, * space
;
512 unsigned size
, blks
, i
;
513 struct ufs_super_block_third
*usb3
;
517 usb3
= ubh_get_usb_third(uspi
);
519 * Read cs structures from (usually) first data block
522 size
= uspi
->s_cssize
;
523 blks
= (size
+ uspi
->s_fsize
- 1) >> uspi
->s_fshift
;
524 base
= space
= kmalloc(size
, GFP_KERNEL
);
527 sbi
->s_csp
= (struct ufs_csum
*)space
;
528 for (i
= 0; i
< blks
; i
+= uspi
->s_fpb
) {
529 size
= uspi
->s_bsize
;
530 if (i
+ uspi
->s_fpb
> blks
)
531 size
= (blks
- i
) * uspi
->s_fsize
;
533 ubh
= ubh_bread(sb
, uspi
->s_csaddr
+ i
, size
);
538 ubh_ubhcpymem (space
, ubh
, size
);
546 * Read cylinder group (we read only first fragment from block
547 * at this time) and prepare internal data structures for cg caching.
549 if (!(sbi
->s_ucg
= kmalloc (sizeof(struct buffer_head
*) * uspi
->s_ncg
, GFP_KERNEL
)))
551 for (i
= 0; i
< uspi
->s_ncg
; i
++)
552 sbi
->s_ucg
[i
] = NULL
;
553 for (i
= 0; i
< UFS_MAX_GROUP_LOADED
; i
++) {
554 sbi
->s_ucpi
[i
] = NULL
;
555 sbi
->s_cgno
[i
] = UFS_CGNO_EMPTY
;
557 for (i
= 0; i
< uspi
->s_ncg
; i
++) {
558 UFSD("read cg %u\n", i
);
559 if (!(sbi
->s_ucg
[i
] = sb_bread(sb
, ufs_cgcmin(i
))))
561 if (!ufs_cg_chkmagic (sb
, (struct ufs_cylinder_group
*) sbi
->s_ucg
[i
]->b_data
))
564 ufs_print_cylinder_stuff(sb
, (struct ufs_cylinder_group
*) sbi
->s_ucg
[i
]->b_data
);
566 for (i
= 0; i
< UFS_MAX_GROUP_LOADED
; i
++) {
567 if (!(sbi
->s_ucpi
[i
] = kmalloc (sizeof(struct ufs_cg_private_info
), GFP_KERNEL
)))
569 sbi
->s_cgno
[i
] = UFS_CGNO_EMPTY
;
571 sbi
->s_cg_loaded
= 0;
578 for (i
= 0; i
< uspi
->s_ncg
; i
++)
580 brelse (sbi
->s_ucg
[i
]);
582 for (i
= 0; i
< UFS_MAX_GROUP_LOADED
; i
++)
583 kfree (sbi
->s_ucpi
[i
]);
585 UFSD("EXIT (FAILED)\n");
590 * Sync our internal copy of fs_cstotal with disk
592 static void ufs_put_cstotal(struct super_block
*sb
)
594 unsigned mtype
= UFS_SB(sb
)->s_mount_opt
& UFS_MOUNT_UFSTYPE
;
595 struct ufs_sb_private_info
*uspi
= UFS_SB(sb
)->s_uspi
;
596 struct ufs_super_block_first
*usb1
;
597 struct ufs_super_block_second
*usb2
;
598 struct ufs_super_block_third
*usb3
;
601 usb1
= ubh_get_usb_first(uspi
);
602 usb2
= ubh_get_usb_second(uspi
);
603 usb3
= ubh_get_usb_third(uspi
);
605 if ((mtype
== UFS_MOUNT_UFSTYPE_44BSD
&&
606 (usb1
->fs_flags
& UFS_FLAGS_UPDATED
)) ||
607 mtype
== UFS_MOUNT_UFSTYPE_UFS2
) {
608 /*we have statistic in different place, then usual*/
609 usb2
->fs_un
.fs_u2
.cs_ndir
=
610 cpu_to_fs64(sb
, uspi
->cs_total
.cs_ndir
);
611 usb2
->fs_un
.fs_u2
.cs_nbfree
=
612 cpu_to_fs64(sb
, uspi
->cs_total
.cs_nbfree
);
613 usb3
->fs_un1
.fs_u2
.cs_nifree
=
614 cpu_to_fs64(sb
, uspi
->cs_total
.cs_nifree
);
615 usb3
->fs_un1
.fs_u2
.cs_nffree
=
616 cpu_to_fs64(sb
, uspi
->cs_total
.cs_nffree
);
618 usb1
->fs_cstotal
.cs_ndir
=
619 cpu_to_fs32(sb
, uspi
->cs_total
.cs_ndir
);
620 usb1
->fs_cstotal
.cs_nbfree
=
621 cpu_to_fs32(sb
, uspi
->cs_total
.cs_nbfree
);
622 usb1
->fs_cstotal
.cs_nifree
=
623 cpu_to_fs32(sb
, uspi
->cs_total
.cs_nifree
);
624 usb1
->fs_cstotal
.cs_nffree
=
625 cpu_to_fs32(sb
, uspi
->cs_total
.cs_nffree
);
627 ubh_mark_buffer_dirty(USPI_UBH(uspi
));
628 ufs_print_super_stuff(sb
, usb1
, usb2
, usb3
);
633 * ufs_put_super_internal() - put on-disk intrenal structures
634 * @sb: pointer to super_block structure
635 * Put on-disk structures associated with cylinder groups
636 * and write them back to disk, also update cs_total on disk
638 static void ufs_put_super_internal(struct super_block
*sb
)
640 struct ufs_sb_info
*sbi
= UFS_SB(sb
);
641 struct ufs_sb_private_info
*uspi
= sbi
->s_uspi
;
642 struct ufs_buffer_head
* ubh
;
643 unsigned char * base
, * space
;
644 unsigned blks
, size
, i
;
652 size
= uspi
->s_cssize
;
653 blks
= (size
+ uspi
->s_fsize
- 1) >> uspi
->s_fshift
;
654 base
= space
= (char*) sbi
->s_csp
;
655 for (i
= 0; i
< blks
; i
+= uspi
->s_fpb
) {
656 size
= uspi
->s_bsize
;
657 if (i
+ uspi
->s_fpb
> blks
)
658 size
= (blks
- i
) * uspi
->s_fsize
;
660 ubh
= ubh_bread(sb
, uspi
->s_csaddr
+ i
, size
);
662 ubh_memcpyubh (ubh
, space
, size
);
664 ubh_mark_buffer_uptodate (ubh
, 1);
665 ubh_mark_buffer_dirty (ubh
);
668 for (i
= 0; i
< sbi
->s_cg_loaded
; i
++) {
669 ufs_put_cylinder (sb
, i
);
670 kfree (sbi
->s_ucpi
[i
]);
672 for (; i
< UFS_MAX_GROUP_LOADED
; i
++)
673 kfree (sbi
->s_ucpi
[i
]);
674 for (i
= 0; i
< uspi
->s_ncg
; i
++)
675 brelse (sbi
->s_ucg
[i
]);
684 static int ufs_fill_super(struct super_block
*sb
, void *data
, int silent
)
686 struct ufs_sb_info
* sbi
;
687 struct ufs_sb_private_info
* uspi
;
688 struct ufs_super_block_first
* usb1
;
689 struct ufs_super_block_second
* usb2
;
690 struct ufs_super_block_third
* usb3
;
691 struct ufs_buffer_head
* ubh
;
693 unsigned block_size
, super_block_size
;
695 unsigned super_block_offset
;
705 sbi
= kzalloc(sizeof(struct ufs_sb_info
), GFP_KERNEL
);
710 UFSD("flag %u\n", (int)(sb
->s_flags
& MS_RDONLY
));
712 #ifndef CONFIG_UFS_FS_WRITE
713 if (!(sb
->s_flags
& MS_RDONLY
)) {
714 printk("ufs was compiled with read-only support, "
715 "can't be mounted as read-write\n");
720 * Set default mount options
721 * Parse mount options
723 sbi
->s_mount_opt
= 0;
724 ufs_set_opt (sbi
->s_mount_opt
, ONERROR_LOCK
);
725 if (!ufs_parse_options ((char *) data
, &sbi
->s_mount_opt
)) {
726 printk("wrong mount options\n");
729 if (!(sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
)) {
731 printk("You didn't specify the type of your ufs filesystem\n\n"
732 "mount -t ufs -o ufstype="
733 "sun|sunx86|44bsd|ufs2|5xbsd|old|hp|nextstep|nextstep-cd|openstep ...\n\n"
734 ">>>WARNING<<< Wrong ufstype may corrupt your filesystem, "
735 "default is ufstype=old\n");
736 ufs_set_opt (sbi
->s_mount_opt
, UFSTYPE_OLD
);
739 uspi
= kzalloc(sizeof(struct ufs_sb_private_info
), GFP_KERNEL
);
743 uspi
->s_dirblksize
= UFS_SECTOR_SIZE
;
744 super_block_offset
=UFS_SBLOCK
;
746 /* Keep 2Gig file limit. Some UFS variants need to override
747 this but as I don't know which I'll let those in the know loosen
749 switch (sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) {
750 case UFS_MOUNT_UFSTYPE_44BSD
:
751 UFSD("ufstype=44bsd\n");
752 uspi
->s_fsize
= block_size
= 512;
753 uspi
->s_fmask
= ~(512 - 1);
755 uspi
->s_sbsize
= super_block_size
= 1536;
757 flags
|= UFS_DE_44BSD
| UFS_UID_44BSD
| UFS_ST_44BSD
| UFS_CG_44BSD
;
759 case UFS_MOUNT_UFSTYPE_UFS2
:
760 UFSD("ufstype=ufs2\n");
761 super_block_offset
=SBLOCK_UFS2
;
762 uspi
->s_fsize
= block_size
= 512;
763 uspi
->s_fmask
= ~(512 - 1);
765 uspi
->s_sbsize
= super_block_size
= 1536;
767 flags
|= UFS_TYPE_UFS2
| UFS_DE_44BSD
| UFS_UID_44BSD
| UFS_ST_44BSD
| UFS_CG_44BSD
;
770 case UFS_MOUNT_UFSTYPE_SUN
:
771 UFSD("ufstype=sun\n");
772 uspi
->s_fsize
= block_size
= 1024;
773 uspi
->s_fmask
= ~(1024 - 1);
775 uspi
->s_sbsize
= super_block_size
= 2048;
777 uspi
->s_maxsymlinklen
= 0; /* Not supported on disk */
778 flags
|= UFS_DE_OLD
| UFS_UID_EFT
| UFS_ST_SUN
| UFS_CG_SUN
;
781 case UFS_MOUNT_UFSTYPE_SUNOS
:
782 UFSD(("ufstype=sunos\n"))
783 uspi
->s_fsize
= block_size
= 1024;
784 uspi
->s_fmask
= ~(1024 - 1);
786 uspi
->s_sbsize
= 2048;
787 super_block_size
= 2048;
789 uspi
->s_maxsymlinklen
= 0; /* Not supported on disk */
790 flags
|= UFS_DE_OLD
| UFS_UID_OLD
| UFS_ST_SUNOS
| UFS_CG_SUN
;
793 case UFS_MOUNT_UFSTYPE_SUNx86
:
794 UFSD("ufstype=sunx86\n");
795 uspi
->s_fsize
= block_size
= 1024;
796 uspi
->s_fmask
= ~(1024 - 1);
798 uspi
->s_sbsize
= super_block_size
= 2048;
800 uspi
->s_maxsymlinklen
= 0; /* Not supported on disk */
801 flags
|= UFS_DE_OLD
| UFS_UID_EFT
| UFS_ST_SUNx86
| UFS_CG_SUN
;
804 case UFS_MOUNT_UFSTYPE_OLD
:
805 UFSD("ufstype=old\n");
806 uspi
->s_fsize
= block_size
= 1024;
807 uspi
->s_fmask
= ~(1024 - 1);
809 uspi
->s_sbsize
= super_block_size
= 2048;
811 flags
|= UFS_DE_OLD
| UFS_UID_OLD
| UFS_ST_OLD
| UFS_CG_OLD
;
812 if (!(sb
->s_flags
& MS_RDONLY
)) {
814 printk(KERN_INFO
"ufstype=old is supported read-only\n");
815 sb
->s_flags
|= MS_RDONLY
;
819 case UFS_MOUNT_UFSTYPE_NEXTSTEP
:
820 UFSD("ufstype=nextstep\n");
821 uspi
->s_fsize
= block_size
= 1024;
822 uspi
->s_fmask
= ~(1024 - 1);
824 uspi
->s_sbsize
= super_block_size
= 2048;
826 uspi
->s_dirblksize
= 1024;
827 flags
|= UFS_DE_OLD
| UFS_UID_OLD
| UFS_ST_OLD
| UFS_CG_OLD
;
828 if (!(sb
->s_flags
& MS_RDONLY
)) {
830 printk(KERN_INFO
"ufstype=nextstep is supported read-only\n");
831 sb
->s_flags
|= MS_RDONLY
;
835 case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD
:
836 UFSD("ufstype=nextstep-cd\n");
837 uspi
->s_fsize
= block_size
= 2048;
838 uspi
->s_fmask
= ~(2048 - 1);
840 uspi
->s_sbsize
= super_block_size
= 2048;
842 uspi
->s_dirblksize
= 1024;
843 flags
|= UFS_DE_OLD
| UFS_UID_OLD
| UFS_ST_OLD
| UFS_CG_OLD
;
844 if (!(sb
->s_flags
& MS_RDONLY
)) {
846 printk(KERN_INFO
"ufstype=nextstep-cd is supported read-only\n");
847 sb
->s_flags
|= MS_RDONLY
;
851 case UFS_MOUNT_UFSTYPE_OPENSTEP
:
852 UFSD("ufstype=openstep\n");
853 uspi
->s_fsize
= block_size
= 1024;
854 uspi
->s_fmask
= ~(1024 - 1);
856 uspi
->s_sbsize
= super_block_size
= 2048;
858 uspi
->s_dirblksize
= 1024;
859 flags
|= UFS_DE_44BSD
| UFS_UID_44BSD
| UFS_ST_44BSD
| UFS_CG_44BSD
;
860 if (!(sb
->s_flags
& MS_RDONLY
)) {
862 printk(KERN_INFO
"ufstype=openstep is supported read-only\n");
863 sb
->s_flags
|= MS_RDONLY
;
867 case UFS_MOUNT_UFSTYPE_HP
:
868 UFSD("ufstype=hp\n");
869 uspi
->s_fsize
= block_size
= 1024;
870 uspi
->s_fmask
= ~(1024 - 1);
872 uspi
->s_sbsize
= super_block_size
= 2048;
874 flags
|= UFS_DE_OLD
| UFS_UID_OLD
| UFS_ST_OLD
| UFS_CG_OLD
;
875 if (!(sb
->s_flags
& MS_RDONLY
)) {
877 printk(KERN_INFO
"ufstype=hp is supported read-only\n");
878 sb
->s_flags
|= MS_RDONLY
;
883 printk("unknown ufstype\n");
888 if (!sb_set_blocksize(sb
, block_size
)) {
889 printk(KERN_ERR
"UFS: failed to set blocksize\n");
894 * read ufs super block from device
897 ubh
= ubh_bread_uspi(uspi
, sb
, uspi
->s_sbbase
+ super_block_offset
/block_size
, super_block_size
);
902 usb1
= ubh_get_usb_first(uspi
);
903 usb2
= ubh_get_usb_second(uspi
);
904 usb3
= ubh_get_usb_third(uspi
);
906 /* Sort out mod used on SunOS 4.1.3 for fs_state */
907 uspi
->s_postblformat
= fs32_to_cpu(sb
, usb3
->fs_postblformat
);
908 if (((flags
& UFS_ST_MASK
) == UFS_ST_SUNOS
) &&
909 (uspi
->s_postblformat
!= UFS_42POSTBLFMT
)) {
910 flags
&= ~UFS_ST_MASK
;
915 * Check ufs magic number
917 sbi
->s_bytesex
= BYTESEX_LE
;
918 switch ((uspi
->fs_magic
= fs32_to_cpu(sb
, usb3
->fs_magic
))) {
926 sbi
->s_bytesex
= BYTESEX_BE
;
927 switch ((uspi
->fs_magic
= fs32_to_cpu(sb
, usb3
->fs_magic
))) {
936 if ((((sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) == UFS_MOUNT_UFSTYPE_NEXTSTEP
)
937 || ((sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD
)
938 || ((sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) == UFS_MOUNT_UFSTYPE_OPENSTEP
))
939 && uspi
->s_sbbase
< 256) {
940 ubh_brelse_uspi(uspi
);
946 printk("ufs_read_super: bad magic number\n");
951 * Check block and fragment sizes
953 uspi
->s_bsize
= fs32_to_cpu(sb
, usb1
->fs_bsize
);
954 uspi
->s_fsize
= fs32_to_cpu(sb
, usb1
->fs_fsize
);
955 uspi
->s_sbsize
= fs32_to_cpu(sb
, usb1
->fs_sbsize
);
956 uspi
->s_fmask
= fs32_to_cpu(sb
, usb1
->fs_fmask
);
957 uspi
->s_fshift
= fs32_to_cpu(sb
, usb1
->fs_fshift
);
959 if (!is_power_of_2(uspi
->s_fsize
)) {
960 printk(KERN_ERR
"ufs_read_super: fragment size %u is not a power of 2\n",
964 if (uspi
->s_fsize
< 512) {
965 printk(KERN_ERR
"ufs_read_super: fragment size %u is too small\n",
969 if (uspi
->s_fsize
> 4096) {
970 printk(KERN_ERR
"ufs_read_super: fragment size %u is too large\n",
974 if (!is_power_of_2(uspi
->s_bsize
)) {
975 printk(KERN_ERR
"ufs_read_super: block size %u is not a power of 2\n",
979 if (uspi
->s_bsize
< 4096) {
980 printk(KERN_ERR
"ufs_read_super: block size %u is too small\n",
984 if (uspi
->s_bsize
/ uspi
->s_fsize
> 8) {
985 printk(KERN_ERR
"ufs_read_super: too many fragments per block (%u)\n",
986 uspi
->s_bsize
/ uspi
->s_fsize
);
989 if (uspi
->s_fsize
!= block_size
|| uspi
->s_sbsize
!= super_block_size
) {
990 ubh_brelse_uspi(uspi
);
992 block_size
= uspi
->s_fsize
;
993 super_block_size
= uspi
->s_sbsize
;
994 UFSD("another value of block_size or super_block_size %u, %u\n", block_size
, super_block_size
);
998 sbi
->s_flags
= flags
;/*after that line some functions use s_flags*/
999 ufs_print_super_stuff(sb
, usb1
, usb2
, usb3
);
1002 * Check, if file system was correctly unmounted.
1003 * If not, make it read only.
1005 if (((flags
& UFS_ST_MASK
) == UFS_ST_44BSD
) ||
1006 ((flags
& UFS_ST_MASK
) == UFS_ST_OLD
) ||
1007 (((flags
& UFS_ST_MASK
) == UFS_ST_SUN
||
1008 (flags
& UFS_ST_MASK
) == UFS_ST_SUNOS
||
1009 (flags
& UFS_ST_MASK
) == UFS_ST_SUNx86
) &&
1010 (ufs_get_fs_state(sb
, usb1
, usb3
) == (UFS_FSOK
- fs32_to_cpu(sb
, usb1
->fs_time
))))) {
1011 switch(usb1
->fs_clean
) {
1013 UFSD("fs is clean\n");
1016 UFSD("fs is stable\n");
1019 UFSD("fs is logging fs\n");
1022 UFSD("fs is DEC OSF/1\n");
1025 printk("ufs_read_super: fs is active\n");
1026 sb
->s_flags
|= MS_RDONLY
;
1029 printk("ufs_read_super: fs is bad\n");
1030 sb
->s_flags
|= MS_RDONLY
;
1033 printk("ufs_read_super: can't grok fs_clean 0x%x\n", usb1
->fs_clean
);
1034 sb
->s_flags
|= MS_RDONLY
;
1038 printk("ufs_read_super: fs needs fsck\n");
1039 sb
->s_flags
|= MS_RDONLY
;
1043 * Read ufs_super_block into internal data structures
1045 sb
->s_op
= &ufs_super_ops
;
1046 sb
->s_export_op
= &ufs_export_ops
;
1048 sb
->s_magic
= fs32_to_cpu(sb
, usb3
->fs_magic
);
1050 uspi
->s_sblkno
= fs32_to_cpu(sb
, usb1
->fs_sblkno
);
1051 uspi
->s_cblkno
= fs32_to_cpu(sb
, usb1
->fs_cblkno
);
1052 uspi
->s_iblkno
= fs32_to_cpu(sb
, usb1
->fs_iblkno
);
1053 uspi
->s_dblkno
= fs32_to_cpu(sb
, usb1
->fs_dblkno
);
1054 uspi
->s_cgoffset
= fs32_to_cpu(sb
, usb1
->fs_cgoffset
);
1055 uspi
->s_cgmask
= fs32_to_cpu(sb
, usb1
->fs_cgmask
);
1057 if ((flags
& UFS_TYPE_MASK
) == UFS_TYPE_UFS2
) {
1058 uspi
->s_u2_size
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_size
);
1059 uspi
->s_u2_dsize
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_dsize
);
1061 uspi
->s_size
= fs32_to_cpu(sb
, usb1
->fs_size
);
1062 uspi
->s_dsize
= fs32_to_cpu(sb
, usb1
->fs_dsize
);
1065 uspi
->s_ncg
= fs32_to_cpu(sb
, usb1
->fs_ncg
);
1066 /* s_bsize already set */
1067 /* s_fsize already set */
1068 uspi
->s_fpb
= fs32_to_cpu(sb
, usb1
->fs_frag
);
1069 uspi
->s_minfree
= fs32_to_cpu(sb
, usb1
->fs_minfree
);
1070 uspi
->s_bmask
= fs32_to_cpu(sb
, usb1
->fs_bmask
);
1071 uspi
->s_fmask
= fs32_to_cpu(sb
, usb1
->fs_fmask
);
1072 uspi
->s_bshift
= fs32_to_cpu(sb
, usb1
->fs_bshift
);
1073 uspi
->s_fshift
= fs32_to_cpu(sb
, usb1
->fs_fshift
);
1074 UFSD("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi
->s_bshift
,
1076 uspi
->s_fpbshift
= fs32_to_cpu(sb
, usb1
->fs_fragshift
);
1077 uspi
->s_fsbtodb
= fs32_to_cpu(sb
, usb1
->fs_fsbtodb
);
1078 /* s_sbsize already set */
1079 uspi
->s_csmask
= fs32_to_cpu(sb
, usb1
->fs_csmask
);
1080 uspi
->s_csshift
= fs32_to_cpu(sb
, usb1
->fs_csshift
);
1081 uspi
->s_nindir
= fs32_to_cpu(sb
, usb1
->fs_nindir
);
1082 uspi
->s_inopb
= fs32_to_cpu(sb
, usb1
->fs_inopb
);
1083 uspi
->s_nspf
= fs32_to_cpu(sb
, usb1
->fs_nspf
);
1084 uspi
->s_npsect
= ufs_get_fs_npsect(sb
, usb1
, usb3
);
1085 uspi
->s_interleave
= fs32_to_cpu(sb
, usb1
->fs_interleave
);
1086 uspi
->s_trackskew
= fs32_to_cpu(sb
, usb1
->fs_trackskew
);
1088 if (uspi
->fs_magic
== UFS2_MAGIC
)
1089 uspi
->s_csaddr
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_csaddr
);
1091 uspi
->s_csaddr
= fs32_to_cpu(sb
, usb1
->fs_csaddr
);
1093 uspi
->s_cssize
= fs32_to_cpu(sb
, usb1
->fs_cssize
);
1094 uspi
->s_cgsize
= fs32_to_cpu(sb
, usb1
->fs_cgsize
);
1095 uspi
->s_ntrak
= fs32_to_cpu(sb
, usb1
->fs_ntrak
);
1096 uspi
->s_nsect
= fs32_to_cpu(sb
, usb1
->fs_nsect
);
1097 uspi
->s_spc
= fs32_to_cpu(sb
, usb1
->fs_spc
);
1098 uspi
->s_ipg
= fs32_to_cpu(sb
, usb1
->fs_ipg
);
1099 uspi
->s_fpg
= fs32_to_cpu(sb
, usb1
->fs_fpg
);
1100 uspi
->s_cpc
= fs32_to_cpu(sb
, usb2
->fs_un
.fs_u1
.fs_cpc
);
1101 uspi
->s_contigsumsize
= fs32_to_cpu(sb
, usb3
->fs_un2
.fs_44
.fs_contigsumsize
);
1102 uspi
->s_qbmask
= ufs_get_fs_qbmask(sb
, usb3
);
1103 uspi
->s_qfmask
= ufs_get_fs_qfmask(sb
, usb3
);
1104 uspi
->s_nrpos
= fs32_to_cpu(sb
, usb3
->fs_nrpos
);
1105 uspi
->s_postbloff
= fs32_to_cpu(sb
, usb3
->fs_postbloff
);
1106 uspi
->s_rotbloff
= fs32_to_cpu(sb
, usb3
->fs_rotbloff
);
1109 * Compute another frequently used values
1111 uspi
->s_fpbmask
= uspi
->s_fpb
- 1;
1112 if ((flags
& UFS_TYPE_MASK
) == UFS_TYPE_UFS2
)
1113 uspi
->s_apbshift
= uspi
->s_bshift
- 3;
1115 uspi
->s_apbshift
= uspi
->s_bshift
- 2;
1117 uspi
->s_2apbshift
= uspi
->s_apbshift
* 2;
1118 uspi
->s_3apbshift
= uspi
->s_apbshift
* 3;
1119 uspi
->s_apb
= 1 << uspi
->s_apbshift
;
1120 uspi
->s_2apb
= 1 << uspi
->s_2apbshift
;
1121 uspi
->s_3apb
= 1 << uspi
->s_3apbshift
;
1122 uspi
->s_apbmask
= uspi
->s_apb
- 1;
1123 uspi
->s_nspfshift
= uspi
->s_fshift
- UFS_SECTOR_BITS
;
1124 uspi
->s_nspb
= uspi
->s_nspf
<< uspi
->s_fpbshift
;
1125 uspi
->s_inopf
= uspi
->s_inopb
>> uspi
->s_fpbshift
;
1126 uspi
->s_bpf
= uspi
->s_fsize
<< 3;
1127 uspi
->s_bpfshift
= uspi
->s_fshift
+ 3;
1128 uspi
->s_bpfmask
= uspi
->s_bpf
- 1;
1129 if ((sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) == UFS_MOUNT_UFSTYPE_44BSD
||
1130 (sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) == UFS_MOUNT_UFSTYPE_UFS2
)
1131 uspi
->s_maxsymlinklen
=
1132 fs32_to_cpu(sb
, usb3
->fs_un2
.fs_44
.fs_maxsymlinklen
);
1134 if (uspi
->fs_magic
== UFS2_MAGIC
)
1135 maxsymlen
= 2 * 4 * (UFS_NDADDR
+ UFS_NINDIR
);
1137 maxsymlen
= 4 * (UFS_NDADDR
+ UFS_NINDIR
);
1138 if (uspi
->s_maxsymlinklen
> maxsymlen
) {
1139 ufs_warning(sb
, __func__
, "ufs_read_super: excessive maximum "
1140 "fast symlink size (%u)\n", uspi
->s_maxsymlinklen
);
1141 uspi
->s_maxsymlinklen
= maxsymlen
;
1144 inode
= ufs_iget(sb
, UFS_ROOTINO
);
1145 if (IS_ERR(inode
)) {
1146 ret
= PTR_ERR(inode
);
1149 sb
->s_root
= d_alloc_root(inode
);
1155 ufs_setup_cstotal(sb
);
1157 * Read cylinder group structures
1159 if (!(sb
->s_flags
& MS_RDONLY
))
1160 if (!ufs_read_cylinder_structures(sb
))
1170 ubh_brelse_uspi (uspi
);
1173 sb
->s_fs_info
= NULL
;
1174 UFSD("EXIT (FAILED)\n");
1178 UFSD("EXIT (NOMEM)\n");
1182 static int ufs_sync_fs(struct super_block
*sb
, int wait
)
1184 struct ufs_sb_private_info
* uspi
;
1185 struct ufs_super_block_first
* usb1
;
1186 struct ufs_super_block_third
* usb3
;
1194 flags
= UFS_SB(sb
)->s_flags
;
1195 uspi
= UFS_SB(sb
)->s_uspi
;
1196 usb1
= ubh_get_usb_first(uspi
);
1197 usb3
= ubh_get_usb_third(uspi
);
1199 usb1
->fs_time
= cpu_to_fs32(sb
, get_seconds());
1200 if ((flags
& UFS_ST_MASK
) == UFS_ST_SUN
||
1201 (flags
& UFS_ST_MASK
) == UFS_ST_SUNOS
||
1202 (flags
& UFS_ST_MASK
) == UFS_ST_SUNx86
)
1203 ufs_set_fs_state(sb
, usb1
, usb3
,
1204 UFS_FSOK
- fs32_to_cpu(sb
, usb1
->fs_time
));
1205 ufs_put_cstotal(sb
);
1215 static void ufs_write_super(struct super_block
*sb
)
1217 if (!(sb
->s_flags
& MS_RDONLY
))
1223 static void ufs_put_super(struct super_block
*sb
)
1225 struct ufs_sb_info
* sbi
= UFS_SB(sb
);
1230 ufs_write_super(sb
);
1232 if (!(sb
->s_flags
& MS_RDONLY
))
1233 ufs_put_super_internal(sb
);
1235 ubh_brelse_uspi (sbi
->s_uspi
);
1236 kfree (sbi
->s_uspi
);
1238 sb
->s_fs_info
= NULL
;
1244 static int ufs_remount (struct super_block
*sb
, int *mount_flags
, char *data
)
1246 struct ufs_sb_private_info
* uspi
;
1247 struct ufs_super_block_first
* usb1
;
1248 struct ufs_super_block_third
* usb3
;
1249 unsigned new_mount_opt
, ufstype
;
1254 uspi
= UFS_SB(sb
)->s_uspi
;
1255 flags
= UFS_SB(sb
)->s_flags
;
1256 usb1
= ubh_get_usb_first(uspi
);
1257 usb3
= ubh_get_usb_third(uspi
);
1260 * Allow the "check" option to be passed as a remount option.
1261 * It is not possible to change ufstype option during remount
1263 ufstype
= UFS_SB(sb
)->s_mount_opt
& UFS_MOUNT_UFSTYPE
;
1265 ufs_set_opt (new_mount_opt
, ONERROR_LOCK
);
1266 if (!ufs_parse_options (data
, &new_mount_opt
)) {
1271 if (!(new_mount_opt
& UFS_MOUNT_UFSTYPE
)) {
1272 new_mount_opt
|= ufstype
;
1273 } else if ((new_mount_opt
& UFS_MOUNT_UFSTYPE
) != ufstype
) {
1274 printk("ufstype can't be changed during remount\n");
1280 if ((*mount_flags
& MS_RDONLY
) == (sb
->s_flags
& MS_RDONLY
)) {
1281 UFS_SB(sb
)->s_mount_opt
= new_mount_opt
;
1288 * fs was mouted as rw, remounting ro
1290 if (*mount_flags
& MS_RDONLY
) {
1291 ufs_put_super_internal(sb
);
1292 usb1
->fs_time
= cpu_to_fs32(sb
, get_seconds());
1293 if ((flags
& UFS_ST_MASK
) == UFS_ST_SUN
1294 || (flags
& UFS_ST_MASK
) == UFS_ST_SUNOS
1295 || (flags
& UFS_ST_MASK
) == UFS_ST_SUNx86
)
1296 ufs_set_fs_state(sb
, usb1
, usb3
,
1297 UFS_FSOK
- fs32_to_cpu(sb
, usb1
->fs_time
));
1298 ubh_mark_buffer_dirty (USPI_UBH(uspi
));
1300 sb
->s_flags
|= MS_RDONLY
;
1303 * fs was mounted as ro, remounting rw
1305 #ifndef CONFIG_UFS_FS_WRITE
1306 printk("ufs was compiled with read-only support, "
1307 "can't be mounted as read-write\n");
1312 if (ufstype
!= UFS_MOUNT_UFSTYPE_SUN
&&
1313 ufstype
!= UFS_MOUNT_UFSTYPE_SUNOS
&&
1314 ufstype
!= UFS_MOUNT_UFSTYPE_44BSD
&&
1315 ufstype
!= UFS_MOUNT_UFSTYPE_SUNx86
&&
1316 ufstype
!= UFS_MOUNT_UFSTYPE_UFS2
) {
1317 printk("this ufstype is read-only supported\n");
1322 if (!ufs_read_cylinder_structures(sb
)) {
1323 printk("failed during remounting\n");
1328 sb
->s_flags
&= ~MS_RDONLY
;
1331 UFS_SB(sb
)->s_mount_opt
= new_mount_opt
;
1337 static int ufs_show_options(struct seq_file
*seq
, struct vfsmount
*vfs
)
1339 struct ufs_sb_info
*sbi
= UFS_SB(vfs
->mnt_sb
);
1340 unsigned mval
= sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
;
1341 const struct match_token
*tp
= tokens
;
1343 while (tp
->token
!= Opt_onerror_panic
&& tp
->token
!= mval
)
1345 BUG_ON(tp
->token
== Opt_onerror_panic
);
1346 seq_printf(seq
, ",%s", tp
->pattern
);
1348 mval
= sbi
->s_mount_opt
& UFS_MOUNT_ONERROR
;
1349 while (tp
->token
!= Opt_err
&& tp
->token
!= mval
)
1351 BUG_ON(tp
->token
== Opt_err
);
1352 seq_printf(seq
, ",%s", tp
->pattern
);
1357 static int ufs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
1359 struct super_block
*sb
= dentry
->d_sb
;
1360 struct ufs_sb_private_info
*uspi
= UFS_SB(sb
)->s_uspi
;
1361 unsigned flags
= UFS_SB(sb
)->s_flags
;
1362 struct ufs_super_block_first
*usb1
;
1363 struct ufs_super_block_second
*usb2
;
1364 struct ufs_super_block_third
*usb3
;
1365 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
1369 usb1
= ubh_get_usb_first(uspi
);
1370 usb2
= ubh_get_usb_second(uspi
);
1371 usb3
= ubh_get_usb_third(uspi
);
1373 if ((flags
& UFS_TYPE_MASK
) == UFS_TYPE_UFS2
) {
1374 buf
->f_type
= UFS2_MAGIC
;
1375 buf
->f_blocks
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_dsize
);
1377 buf
->f_type
= UFS_MAGIC
;
1378 buf
->f_blocks
= uspi
->s_dsize
;
1380 buf
->f_bfree
= ufs_blkstofrags(uspi
->cs_total
.cs_nbfree
) +
1381 uspi
->cs_total
.cs_nffree
;
1382 buf
->f_ffree
= uspi
->cs_total
.cs_nifree
;
1383 buf
->f_bsize
= sb
->s_blocksize
;
1384 buf
->f_bavail
= (buf
->f_bfree
> (((long)buf
->f_blocks
/ 100) * uspi
->s_minfree
))
1385 ? (buf
->f_bfree
- (((long)buf
->f_blocks
/ 100) * uspi
->s_minfree
)) : 0;
1386 buf
->f_files
= uspi
->s_ncg
* uspi
->s_ipg
;
1387 buf
->f_namelen
= UFS_MAXNAMLEN
;
1388 buf
->f_fsid
.val
[0] = (u32
)id
;
1389 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
1396 static struct kmem_cache
* ufs_inode_cachep
;
1398 static struct inode
*ufs_alloc_inode(struct super_block
*sb
)
1400 struct ufs_inode_info
*ei
;
1401 ei
= (struct ufs_inode_info
*)kmem_cache_alloc(ufs_inode_cachep
, GFP_KERNEL
);
1404 ei
->vfs_inode
.i_version
= 1;
1405 return &ei
->vfs_inode
;
1408 static void ufs_destroy_inode(struct inode
*inode
)
1410 kmem_cache_free(ufs_inode_cachep
, UFS_I(inode
));
1413 static void init_once(void *foo
)
1415 struct ufs_inode_info
*ei
= (struct ufs_inode_info
*) foo
;
1417 inode_init_once(&ei
->vfs_inode
);
1420 static int init_inodecache(void)
1422 ufs_inode_cachep
= kmem_cache_create("ufs_inode_cache",
1423 sizeof(struct ufs_inode_info
),
1424 0, (SLAB_RECLAIM_ACCOUNT
|
1427 if (ufs_inode_cachep
== NULL
)
1432 static void destroy_inodecache(void)
1434 kmem_cache_destroy(ufs_inode_cachep
);
1437 static const struct super_operations ufs_super_ops
= {
1438 .alloc_inode
= ufs_alloc_inode
,
1439 .destroy_inode
= ufs_destroy_inode
,
1440 .write_inode
= ufs_write_inode
,
1441 .delete_inode
= ufs_delete_inode
,
1442 .put_super
= ufs_put_super
,
1443 .write_super
= ufs_write_super
,
1444 .sync_fs
= ufs_sync_fs
,
1445 .statfs
= ufs_statfs
,
1446 .remount_fs
= ufs_remount
,
1447 .show_options
= ufs_show_options
,
1450 static int ufs_get_sb(struct file_system_type
*fs_type
,
1451 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
1453 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, ufs_fill_super
, mnt
);
1456 static struct file_system_type ufs_fs_type
= {
1457 .owner
= THIS_MODULE
,
1459 .get_sb
= ufs_get_sb
,
1460 .kill_sb
= kill_block_super
,
1461 .fs_flags
= FS_REQUIRES_DEV
,
1464 static int __init
init_ufs_fs(void)
1466 int err
= init_inodecache();
1469 err
= register_filesystem(&ufs_fs_type
);
1474 destroy_inodecache();
1479 static void __exit
exit_ufs_fs(void)
1481 unregister_filesystem(&ufs_fs_type
);
1482 destroy_inodecache();
1485 module_init(init_ufs_fs
)
1486 module_exit(exit_ufs_fs
)
1487 MODULE_LICENSE("GPL");