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/module.h>
70 #include <linux/bitops.h>
74 #include <asm/uaccess.h>
75 #include <asm/system.h>
77 #include <linux/errno.h>
79 #include <linux/quotaops.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 #ifdef CONFIG_UFS_DEBUG
101 * Print contents of ufs_super_block, useful for debugging
103 static void ufs_print_super_stuff(struct super_block
*sb
,
104 struct ufs_super_block_first
*usb1
,
105 struct ufs_super_block_second
*usb2
,
106 struct ufs_super_block_third
*usb3
)
108 u32 magic
= fs32_to_cpu(sb
, usb3
->fs_magic
);
110 printk("ufs_print_super_stuff\n");
111 printk(" magic: 0x%x\n", magic
);
112 if (fs32_to_cpu(sb
, usb3
->fs_magic
) == UFS2_MAGIC
) {
113 printk(" fs_size: %llu\n", (unsigned long long)
114 fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_size
));
115 printk(" fs_dsize: %llu\n", (unsigned long long)
116 fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_dsize
));
117 printk(" bsize: %u\n",
118 fs32_to_cpu(sb
, usb1
->fs_bsize
));
119 printk(" fsize: %u\n",
120 fs32_to_cpu(sb
, usb1
->fs_fsize
));
121 printk(" fs_volname: %s\n", usb2
->fs_un
.fs_u2
.fs_volname
);
122 printk(" fs_sblockloc: %llu\n", (unsigned long long)
123 fs64_to_cpu(sb
, usb2
->fs_un
.fs_u2
.fs_sblockloc
));
124 printk(" cs_ndir(No of dirs): %llu\n", (unsigned long long)
125 fs64_to_cpu(sb
, usb2
->fs_un
.fs_u2
.cs_ndir
));
126 printk(" cs_nbfree(No of free blocks): %llu\n",
128 fs64_to_cpu(sb
, usb2
->fs_un
.fs_u2
.cs_nbfree
));
129 printk(KERN_INFO
" cs_nifree(Num of free inodes): %llu\n",
131 fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.cs_nifree
));
132 printk(KERN_INFO
" cs_nffree(Num of free frags): %llu\n",
134 fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.cs_nffree
));
135 printk(KERN_INFO
" fs_maxsymlinklen: %u\n",
136 fs32_to_cpu(sb
, usb3
->fs_un2
.fs_44
.fs_maxsymlinklen
));
138 printk(" sblkno: %u\n", fs32_to_cpu(sb
, usb1
->fs_sblkno
));
139 printk(" cblkno: %u\n", fs32_to_cpu(sb
, usb1
->fs_cblkno
));
140 printk(" iblkno: %u\n", fs32_to_cpu(sb
, usb1
->fs_iblkno
));
141 printk(" dblkno: %u\n", fs32_to_cpu(sb
, usb1
->fs_dblkno
));
142 printk(" cgoffset: %u\n",
143 fs32_to_cpu(sb
, usb1
->fs_cgoffset
));
144 printk(" ~cgmask: 0x%x\n",
145 ~fs32_to_cpu(sb
, usb1
->fs_cgmask
));
146 printk(" size: %u\n", fs32_to_cpu(sb
, usb1
->fs_size
));
147 printk(" dsize: %u\n", fs32_to_cpu(sb
, usb1
->fs_dsize
));
148 printk(" ncg: %u\n", fs32_to_cpu(sb
, usb1
->fs_ncg
));
149 printk(" bsize: %u\n", fs32_to_cpu(sb
, usb1
->fs_bsize
));
150 printk(" fsize: %u\n", fs32_to_cpu(sb
, usb1
->fs_fsize
));
151 printk(" frag: %u\n", fs32_to_cpu(sb
, usb1
->fs_frag
));
152 printk(" fragshift: %u\n",
153 fs32_to_cpu(sb
, usb1
->fs_fragshift
));
154 printk(" ~fmask: %u\n", ~fs32_to_cpu(sb
, usb1
->fs_fmask
));
155 printk(" fshift: %u\n", fs32_to_cpu(sb
, usb1
->fs_fshift
));
156 printk(" sbsize: %u\n", fs32_to_cpu(sb
, usb1
->fs_sbsize
));
157 printk(" spc: %u\n", fs32_to_cpu(sb
, usb1
->fs_spc
));
158 printk(" cpg: %u\n", fs32_to_cpu(sb
, usb1
->fs_cpg
));
159 printk(" ipg: %u\n", fs32_to_cpu(sb
, usb1
->fs_ipg
));
160 printk(" fpg: %u\n", fs32_to_cpu(sb
, usb1
->fs_fpg
));
161 printk(" csaddr: %u\n", fs32_to_cpu(sb
, usb1
->fs_csaddr
));
162 printk(" cssize: %u\n", fs32_to_cpu(sb
, usb1
->fs_cssize
));
163 printk(" cgsize: %u\n", fs32_to_cpu(sb
, usb1
->fs_cgsize
));
164 printk(" fstodb: %u\n",
165 fs32_to_cpu(sb
, usb1
->fs_fsbtodb
));
166 printk(" nrpos: %u\n", fs32_to_cpu(sb
, usb3
->fs_nrpos
));
168 fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_ndir
));
169 printk(" nifree %u\n",
170 fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nifree
));
171 printk(" nbfree %u\n",
172 fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nbfree
));
173 printk(" nffree %u\n",
174 fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nffree
));
180 * Print contents of ufs_cylinder_group, useful for debugging
182 static void ufs_print_cylinder_stuff(struct super_block
*sb
,
183 struct ufs_cylinder_group
*cg
)
185 printk("\nufs_print_cylinder_stuff\n");
186 printk("size of ucg: %zu\n", sizeof(struct ufs_cylinder_group
));
187 printk(" magic: %x\n", fs32_to_cpu(sb
, cg
->cg_magic
));
188 printk(" time: %u\n", fs32_to_cpu(sb
, cg
->cg_time
));
189 printk(" cgx: %u\n", fs32_to_cpu(sb
, cg
->cg_cgx
));
190 printk(" ncyl: %u\n", fs16_to_cpu(sb
, cg
->cg_ncyl
));
191 printk(" niblk: %u\n", fs16_to_cpu(sb
, cg
->cg_niblk
));
192 printk(" ndblk: %u\n", fs32_to_cpu(sb
, cg
->cg_ndblk
));
193 printk(" cs_ndir: %u\n", fs32_to_cpu(sb
, cg
->cg_cs
.cs_ndir
));
194 printk(" cs_nbfree: %u\n", fs32_to_cpu(sb
, cg
->cg_cs
.cs_nbfree
));
195 printk(" cs_nifree: %u\n", fs32_to_cpu(sb
, cg
->cg_cs
.cs_nifree
));
196 printk(" cs_nffree: %u\n", fs32_to_cpu(sb
, cg
->cg_cs
.cs_nffree
));
197 printk(" rotor: %u\n", fs32_to_cpu(sb
, cg
->cg_rotor
));
198 printk(" frotor: %u\n", fs32_to_cpu(sb
, cg
->cg_frotor
));
199 printk(" irotor: %u\n", fs32_to_cpu(sb
, cg
->cg_irotor
));
200 printk(" frsum: %u, %u, %u, %u, %u, %u, %u, %u\n",
201 fs32_to_cpu(sb
, cg
->cg_frsum
[0]), fs32_to_cpu(sb
, cg
->cg_frsum
[1]),
202 fs32_to_cpu(sb
, cg
->cg_frsum
[2]), fs32_to_cpu(sb
, cg
->cg_frsum
[3]),
203 fs32_to_cpu(sb
, cg
->cg_frsum
[4]), fs32_to_cpu(sb
, cg
->cg_frsum
[5]),
204 fs32_to_cpu(sb
, cg
->cg_frsum
[6]), fs32_to_cpu(sb
, cg
->cg_frsum
[7]));
205 printk(" btotoff: %u\n", fs32_to_cpu(sb
, cg
->cg_btotoff
));
206 printk(" boff: %u\n", fs32_to_cpu(sb
, cg
->cg_boff
));
207 printk(" iuseoff: %u\n", fs32_to_cpu(sb
, cg
->cg_iusedoff
));
208 printk(" freeoff: %u\n", fs32_to_cpu(sb
, cg
->cg_freeoff
));
209 printk(" nextfreeoff: %u\n", fs32_to_cpu(sb
, cg
->cg_nextfreeoff
));
210 printk(" clustersumoff %u\n",
211 fs32_to_cpu(sb
, cg
->cg_u
.cg_44
.cg_clustersumoff
));
212 printk(" clusteroff %u\n",
213 fs32_to_cpu(sb
, cg
->cg_u
.cg_44
.cg_clusteroff
));
214 printk(" nclusterblks %u\n",
215 fs32_to_cpu(sb
, cg
->cg_u
.cg_44
.cg_nclusterblks
));
219 # define ufs_print_super_stuff(sb, usb1, usb2, usb3) /**/
220 # define ufs_print_cylinder_stuff(sb, cg) /**/
221 #endif /* CONFIG_UFS_DEBUG */
223 static const struct super_operations ufs_super_ops
;
225 static char error_buf
[1024];
227 void ufs_error (struct super_block
* sb
, const char * function
,
228 const char * fmt
, ...)
230 struct ufs_sb_private_info
* uspi
;
231 struct ufs_super_block_first
* usb1
;
234 uspi
= UFS_SB(sb
)->s_uspi
;
235 usb1
= ubh_get_usb_first(uspi
);
237 if (!(sb
->s_flags
& MS_RDONLY
)) {
238 usb1
->fs_clean
= UFS_FSBAD
;
239 ubh_mark_buffer_dirty(USPI_UBH(uspi
));
241 sb
->s_flags
|= MS_RDONLY
;
243 va_start (args
, fmt
);
244 vsnprintf (error_buf
, sizeof(error_buf
), fmt
, args
);
246 switch (UFS_SB(sb
)->s_mount_opt
& UFS_MOUNT_ONERROR
) {
247 case UFS_MOUNT_ONERROR_PANIC
:
248 panic ("UFS-fs panic (device %s): %s: %s\n",
249 sb
->s_id
, function
, error_buf
);
251 case UFS_MOUNT_ONERROR_LOCK
:
252 case UFS_MOUNT_ONERROR_UMOUNT
:
253 case UFS_MOUNT_ONERROR_REPAIR
:
254 printk (KERN_CRIT
"UFS-fs error (device %s): %s: %s\n",
255 sb
->s_id
, function
, error_buf
);
259 void ufs_panic (struct super_block
* sb
, const char * function
,
260 const char * fmt
, ...)
262 struct ufs_sb_private_info
* uspi
;
263 struct ufs_super_block_first
* usb1
;
266 uspi
= UFS_SB(sb
)->s_uspi
;
267 usb1
= ubh_get_usb_first(uspi
);
269 if (!(sb
->s_flags
& MS_RDONLY
)) {
270 usb1
->fs_clean
= UFS_FSBAD
;
271 ubh_mark_buffer_dirty(USPI_UBH(uspi
));
274 va_start (args
, fmt
);
275 vsnprintf (error_buf
, sizeof(error_buf
), fmt
, args
);
277 sb
->s_flags
|= MS_RDONLY
;
278 printk (KERN_CRIT
"UFS-fs panic (device %s): %s: %s\n",
279 sb
->s_id
, function
, error_buf
);
282 void ufs_warning (struct super_block
* sb
, const char * function
,
283 const char * fmt
, ...)
287 va_start (args
, fmt
);
288 vsnprintf (error_buf
, sizeof(error_buf
), fmt
, args
);
290 printk (KERN_WARNING
"UFS-fs warning (device %s): %s: %s\n",
291 sb
->s_id
, function
, error_buf
);
295 Opt_type_old
= UFS_MOUNT_UFSTYPE_OLD
,
296 Opt_type_sunx86
= UFS_MOUNT_UFSTYPE_SUNx86
,
297 Opt_type_sun
= UFS_MOUNT_UFSTYPE_SUN
,
298 Opt_type_sunos
= UFS_MOUNT_UFSTYPE_SUNOS
,
299 Opt_type_44bsd
= UFS_MOUNT_UFSTYPE_44BSD
,
300 Opt_type_ufs2
= UFS_MOUNT_UFSTYPE_UFS2
,
301 Opt_type_hp
= UFS_MOUNT_UFSTYPE_HP
,
302 Opt_type_nextstepcd
= UFS_MOUNT_UFSTYPE_NEXTSTEP_CD
,
303 Opt_type_nextstep
= UFS_MOUNT_UFSTYPE_NEXTSTEP
,
304 Opt_type_openstep
= UFS_MOUNT_UFSTYPE_OPENSTEP
,
305 Opt_onerror_panic
= UFS_MOUNT_ONERROR_PANIC
,
306 Opt_onerror_lock
= UFS_MOUNT_ONERROR_LOCK
,
307 Opt_onerror_umount
= UFS_MOUNT_ONERROR_UMOUNT
,
308 Opt_onerror_repair
= UFS_MOUNT_ONERROR_REPAIR
,
312 static const match_table_t tokens
= {
313 {Opt_type_old
, "ufstype=old"},
314 {Opt_type_sunx86
, "ufstype=sunx86"},
315 {Opt_type_sun
, "ufstype=sun"},
316 {Opt_type_sunos
, "ufstype=sunos"},
317 {Opt_type_44bsd
, "ufstype=44bsd"},
318 {Opt_type_ufs2
, "ufstype=ufs2"},
319 {Opt_type_ufs2
, "ufstype=5xbsd"},
320 {Opt_type_hp
, "ufstype=hp"},
321 {Opt_type_nextstepcd
, "ufstype=nextstep-cd"},
322 {Opt_type_nextstep
, "ufstype=nextstep"},
323 {Opt_type_openstep
, "ufstype=openstep"},
324 /*end of possible ufs types */
325 {Opt_onerror_panic
, "onerror=panic"},
326 {Opt_onerror_lock
, "onerror=lock"},
327 {Opt_onerror_umount
, "onerror=umount"},
328 {Opt_onerror_repair
, "onerror=repair"},
332 static int ufs_parse_options (char * options
, unsigned * mount_options
)
341 while ((p
= strsep(&options
, ",")) != NULL
) {
342 substring_t args
[MAX_OPT_ARGS
];
347 token
= match_token(p
, tokens
, args
);
350 ufs_clear_opt (*mount_options
, UFSTYPE
);
351 ufs_set_opt (*mount_options
, UFSTYPE_OLD
);
353 case Opt_type_sunx86
:
354 ufs_clear_opt (*mount_options
, UFSTYPE
);
355 ufs_set_opt (*mount_options
, UFSTYPE_SUNx86
);
358 ufs_clear_opt (*mount_options
, UFSTYPE
);
359 ufs_set_opt (*mount_options
, UFSTYPE_SUN
);
362 ufs_clear_opt(*mount_options
, UFSTYPE
);
363 ufs_set_opt(*mount_options
, UFSTYPE_SUNOS
);
366 ufs_clear_opt (*mount_options
, UFSTYPE
);
367 ufs_set_opt (*mount_options
, UFSTYPE_44BSD
);
370 ufs_clear_opt(*mount_options
, UFSTYPE
);
371 ufs_set_opt(*mount_options
, UFSTYPE_UFS2
);
374 ufs_clear_opt (*mount_options
, UFSTYPE
);
375 ufs_set_opt (*mount_options
, UFSTYPE_HP
);
377 case Opt_type_nextstepcd
:
378 ufs_clear_opt (*mount_options
, UFSTYPE
);
379 ufs_set_opt (*mount_options
, UFSTYPE_NEXTSTEP_CD
);
381 case Opt_type_nextstep
:
382 ufs_clear_opt (*mount_options
, UFSTYPE
);
383 ufs_set_opt (*mount_options
, UFSTYPE_NEXTSTEP
);
385 case Opt_type_openstep
:
386 ufs_clear_opt (*mount_options
, UFSTYPE
);
387 ufs_set_opt (*mount_options
, UFSTYPE_OPENSTEP
);
389 case Opt_onerror_panic
:
390 ufs_clear_opt (*mount_options
, ONERROR
);
391 ufs_set_opt (*mount_options
, ONERROR_PANIC
);
393 case Opt_onerror_lock
:
394 ufs_clear_opt (*mount_options
, ONERROR
);
395 ufs_set_opt (*mount_options
, ONERROR_LOCK
);
397 case Opt_onerror_umount
:
398 ufs_clear_opt (*mount_options
, ONERROR
);
399 ufs_set_opt (*mount_options
, ONERROR_UMOUNT
);
401 case Opt_onerror_repair
:
402 printk("UFS-fs: Unable to do repair on error, "
403 "will lock lock instead\n");
404 ufs_clear_opt (*mount_options
, ONERROR
);
405 ufs_set_opt (*mount_options
, ONERROR_REPAIR
);
408 printk("UFS-fs: Invalid option: \"%s\" "
409 "or missing value\n", p
);
417 * Diffrent types of UFS hold fs_cstotal in different
418 * places, and use diffrent data structure for it.
419 * To make things simplier we just copy fs_cstotal to ufs_sb_private_info
421 static void ufs_setup_cstotal(struct super_block
*sb
)
423 struct ufs_sb_info
*sbi
= UFS_SB(sb
);
424 struct ufs_sb_private_info
*uspi
= sbi
->s_uspi
;
425 struct ufs_super_block_first
*usb1
;
426 struct ufs_super_block_second
*usb2
;
427 struct ufs_super_block_third
*usb3
;
428 unsigned mtype
= sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
;
430 UFSD("ENTER, mtype=%u\n", mtype
);
431 usb1
= ubh_get_usb_first(uspi
);
432 usb2
= ubh_get_usb_second(uspi
);
433 usb3
= ubh_get_usb_third(uspi
);
435 if ((mtype
== UFS_MOUNT_UFSTYPE_44BSD
&&
436 (usb1
->fs_flags
& UFS_FLAGS_UPDATED
)) ||
437 mtype
== UFS_MOUNT_UFSTYPE_UFS2
) {
438 /*we have statistic in different place, then usual*/
439 uspi
->cs_total
.cs_ndir
= fs64_to_cpu(sb
, usb2
->fs_un
.fs_u2
.cs_ndir
);
440 uspi
->cs_total
.cs_nbfree
= fs64_to_cpu(sb
, usb2
->fs_un
.fs_u2
.cs_nbfree
);
441 uspi
->cs_total
.cs_nifree
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.cs_nifree
);
442 uspi
->cs_total
.cs_nffree
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.cs_nffree
);
444 uspi
->cs_total
.cs_ndir
= fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_ndir
);
445 uspi
->cs_total
.cs_nbfree
= fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nbfree
);
446 uspi
->cs_total
.cs_nifree
= fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nifree
);
447 uspi
->cs_total
.cs_nffree
= fs32_to_cpu(sb
, usb1
->fs_cstotal
.cs_nffree
);
453 * Read on-disk structures associated with cylinder groups
455 static int ufs_read_cylinder_structures(struct super_block
*sb
)
457 struct ufs_sb_info
*sbi
= UFS_SB(sb
);
458 struct ufs_sb_private_info
*uspi
= sbi
->s_uspi
;
459 struct ufs_buffer_head
* ubh
;
460 unsigned char * base
, * space
;
461 unsigned size
, blks
, i
;
462 struct ufs_super_block_third
*usb3
;
466 usb3
= ubh_get_usb_third(uspi
);
468 * Read cs structures from (usually) first data block
471 size
= uspi
->s_cssize
;
472 blks
= (size
+ uspi
->s_fsize
- 1) >> uspi
->s_fshift
;
473 base
= space
= kmalloc(size
, GFP_KERNEL
);
476 sbi
->s_csp
= (struct ufs_csum
*)space
;
477 for (i
= 0; i
< blks
; i
+= uspi
->s_fpb
) {
478 size
= uspi
->s_bsize
;
479 if (i
+ uspi
->s_fpb
> blks
)
480 size
= (blks
- i
) * uspi
->s_fsize
;
482 ubh
= ubh_bread(sb
, uspi
->s_csaddr
+ i
, size
);
487 ubh_ubhcpymem (space
, ubh
, size
);
495 * Read cylinder group (we read only first fragment from block
496 * at this time) and prepare internal data structures for cg caching.
498 if (!(sbi
->s_ucg
= kmalloc (sizeof(struct buffer_head
*) * uspi
->s_ncg
, GFP_KERNEL
)))
500 for (i
= 0; i
< uspi
->s_ncg
; i
++)
501 sbi
->s_ucg
[i
] = NULL
;
502 for (i
= 0; i
< UFS_MAX_GROUP_LOADED
; i
++) {
503 sbi
->s_ucpi
[i
] = NULL
;
504 sbi
->s_cgno
[i
] = UFS_CGNO_EMPTY
;
506 for (i
= 0; i
< uspi
->s_ncg
; i
++) {
507 UFSD("read cg %u\n", i
);
508 if (!(sbi
->s_ucg
[i
] = sb_bread(sb
, ufs_cgcmin(i
))))
510 if (!ufs_cg_chkmagic (sb
, (struct ufs_cylinder_group
*) sbi
->s_ucg
[i
]->b_data
))
513 ufs_print_cylinder_stuff(sb
, (struct ufs_cylinder_group
*) sbi
->s_ucg
[i
]->b_data
);
515 for (i
= 0; i
< UFS_MAX_GROUP_LOADED
; i
++) {
516 if (!(sbi
->s_ucpi
[i
] = kmalloc (sizeof(struct ufs_cg_private_info
), GFP_KERNEL
)))
518 sbi
->s_cgno
[i
] = UFS_CGNO_EMPTY
;
520 sbi
->s_cg_loaded
= 0;
527 for (i
= 0; i
< uspi
->s_ncg
; i
++)
529 brelse (sbi
->s_ucg
[i
]);
531 for (i
= 0; i
< UFS_MAX_GROUP_LOADED
; i
++)
532 kfree (sbi
->s_ucpi
[i
]);
534 UFSD("EXIT (FAILED)\n");
539 * Sync our internal copy of fs_cstotal with disk
541 static void ufs_put_cstotal(struct super_block
*sb
)
543 unsigned mtype
= UFS_SB(sb
)->s_mount_opt
& UFS_MOUNT_UFSTYPE
;
544 struct ufs_sb_private_info
*uspi
= UFS_SB(sb
)->s_uspi
;
545 struct ufs_super_block_first
*usb1
;
546 struct ufs_super_block_second
*usb2
;
547 struct ufs_super_block_third
*usb3
;
550 usb1
= ubh_get_usb_first(uspi
);
551 usb2
= ubh_get_usb_second(uspi
);
552 usb3
= ubh_get_usb_third(uspi
);
554 if ((mtype
== UFS_MOUNT_UFSTYPE_44BSD
&&
555 (usb1
->fs_flags
& UFS_FLAGS_UPDATED
)) ||
556 mtype
== UFS_MOUNT_UFSTYPE_UFS2
) {
557 /*we have statistic in different place, then usual*/
558 usb2
->fs_un
.fs_u2
.cs_ndir
=
559 cpu_to_fs64(sb
, uspi
->cs_total
.cs_ndir
);
560 usb2
->fs_un
.fs_u2
.cs_nbfree
=
561 cpu_to_fs64(sb
, uspi
->cs_total
.cs_nbfree
);
562 usb3
->fs_un1
.fs_u2
.cs_nifree
=
563 cpu_to_fs64(sb
, uspi
->cs_total
.cs_nifree
);
564 usb3
->fs_un1
.fs_u2
.cs_nffree
=
565 cpu_to_fs64(sb
, uspi
->cs_total
.cs_nffree
);
567 usb1
->fs_cstotal
.cs_ndir
=
568 cpu_to_fs32(sb
, uspi
->cs_total
.cs_ndir
);
569 usb1
->fs_cstotal
.cs_nbfree
=
570 cpu_to_fs32(sb
, uspi
->cs_total
.cs_nbfree
);
571 usb1
->fs_cstotal
.cs_nifree
=
572 cpu_to_fs32(sb
, uspi
->cs_total
.cs_nifree
);
573 usb1
->fs_cstotal
.cs_nffree
=
574 cpu_to_fs32(sb
, uspi
->cs_total
.cs_nffree
);
576 ubh_mark_buffer_dirty(USPI_UBH(uspi
));
577 ufs_print_super_stuff(sb
, usb1
, usb2
, usb3
);
582 * ufs_put_super_internal() - put on-disk intrenal structures
583 * @sb: pointer to super_block structure
584 * Put on-disk structures associated with cylinder groups
585 * and write them back to disk, also update cs_total on disk
587 static void ufs_put_super_internal(struct super_block
*sb
)
589 struct ufs_sb_info
*sbi
= UFS_SB(sb
);
590 struct ufs_sb_private_info
*uspi
= sbi
->s_uspi
;
591 struct ufs_buffer_head
* ubh
;
592 unsigned char * base
, * space
;
593 unsigned blks
, size
, i
;
601 size
= uspi
->s_cssize
;
602 blks
= (size
+ uspi
->s_fsize
- 1) >> uspi
->s_fshift
;
603 base
= space
= (char*) sbi
->s_csp
;
604 for (i
= 0; i
< blks
; i
+= uspi
->s_fpb
) {
605 size
= uspi
->s_bsize
;
606 if (i
+ uspi
->s_fpb
> blks
)
607 size
= (blks
- i
) * uspi
->s_fsize
;
609 ubh
= ubh_bread(sb
, uspi
->s_csaddr
+ i
, size
);
611 ubh_memcpyubh (ubh
, space
, size
);
613 ubh_mark_buffer_uptodate (ubh
, 1);
614 ubh_mark_buffer_dirty (ubh
);
617 for (i
= 0; i
< sbi
->s_cg_loaded
; i
++) {
618 ufs_put_cylinder (sb
, i
);
619 kfree (sbi
->s_ucpi
[i
]);
621 for (; i
< UFS_MAX_GROUP_LOADED
; i
++)
622 kfree (sbi
->s_ucpi
[i
]);
623 for (i
= 0; i
< uspi
->s_ncg
; i
++)
624 brelse (sbi
->s_ucg
[i
]);
633 static int ufs_fill_super(struct super_block
*sb
, void *data
, int silent
)
635 struct ufs_sb_info
* sbi
;
636 struct ufs_sb_private_info
* uspi
;
637 struct ufs_super_block_first
* usb1
;
638 struct ufs_super_block_second
* usb2
;
639 struct ufs_super_block_third
* usb3
;
640 struct ufs_buffer_head
* ubh
;
642 unsigned block_size
, super_block_size
;
644 unsigned super_block_offset
;
654 sbi
= kzalloc(sizeof(struct ufs_sb_info
), GFP_KERNEL
);
659 UFSD("flag %u\n", (int)(sb
->s_flags
& MS_RDONLY
));
661 #ifndef CONFIG_UFS_FS_WRITE
662 if (!(sb
->s_flags
& MS_RDONLY
)) {
663 printk("ufs was compiled with read-only support, "
664 "can't be mounted as read-write\n");
669 * Set default mount options
670 * Parse mount options
672 sbi
->s_mount_opt
= 0;
673 ufs_set_opt (sbi
->s_mount_opt
, ONERROR_LOCK
);
674 if (!ufs_parse_options ((char *) data
, &sbi
->s_mount_opt
)) {
675 printk("wrong mount options\n");
678 if (!(sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
)) {
680 printk("You didn't specify the type of your ufs filesystem\n\n"
681 "mount -t ufs -o ufstype="
682 "sun|sunx86|44bsd|ufs2|5xbsd|old|hp|nextstep|nextstep-cd|openstep ...\n\n"
683 ">>>WARNING<<< Wrong ufstype may corrupt your filesystem, "
684 "default is ufstype=old\n");
685 ufs_set_opt (sbi
->s_mount_opt
, UFSTYPE_OLD
);
688 uspi
= kzalloc(sizeof(struct ufs_sb_private_info
), GFP_KERNEL
);
692 uspi
->s_dirblksize
= UFS_SECTOR_SIZE
;
693 super_block_offset
=UFS_SBLOCK
;
695 /* Keep 2Gig file limit. Some UFS variants need to override
696 this but as I don't know which I'll let those in the know loosen
698 switch (sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) {
699 case UFS_MOUNT_UFSTYPE_44BSD
:
700 UFSD("ufstype=44bsd\n");
701 uspi
->s_fsize
= block_size
= 512;
702 uspi
->s_fmask
= ~(512 - 1);
704 uspi
->s_sbsize
= super_block_size
= 1536;
706 flags
|= UFS_DE_44BSD
| UFS_UID_44BSD
| UFS_ST_44BSD
| UFS_CG_44BSD
;
708 case UFS_MOUNT_UFSTYPE_UFS2
:
709 UFSD("ufstype=ufs2\n");
710 super_block_offset
=SBLOCK_UFS2
;
711 uspi
->s_fsize
= block_size
= 512;
712 uspi
->s_fmask
= ~(512 - 1);
714 uspi
->s_sbsize
= super_block_size
= 1536;
716 flags
|= UFS_TYPE_UFS2
| UFS_DE_44BSD
| UFS_UID_44BSD
| UFS_ST_44BSD
| UFS_CG_44BSD
;
719 case UFS_MOUNT_UFSTYPE_SUN
:
720 UFSD("ufstype=sun\n");
721 uspi
->s_fsize
= block_size
= 1024;
722 uspi
->s_fmask
= ~(1024 - 1);
724 uspi
->s_sbsize
= super_block_size
= 2048;
726 uspi
->s_maxsymlinklen
= 0; /* Not supported on disk */
727 flags
|= UFS_DE_OLD
| UFS_UID_EFT
| UFS_ST_SUN
| UFS_CG_SUN
;
730 case UFS_MOUNT_UFSTYPE_SUNOS
:
731 UFSD(("ufstype=sunos\n"))
732 uspi
->s_fsize
= block_size
= 1024;
733 uspi
->s_fmask
= ~(1024 - 1);
735 uspi
->s_sbsize
= 2048;
736 super_block_size
= 2048;
738 uspi
->s_maxsymlinklen
= 0; /* Not supported on disk */
739 flags
|= UFS_DE_OLD
| UFS_UID_OLD
| UFS_ST_SUNOS
| UFS_CG_SUN
;
742 case UFS_MOUNT_UFSTYPE_SUNx86
:
743 UFSD("ufstype=sunx86\n");
744 uspi
->s_fsize
= block_size
= 1024;
745 uspi
->s_fmask
= ~(1024 - 1);
747 uspi
->s_sbsize
= super_block_size
= 2048;
749 uspi
->s_maxsymlinklen
= 0; /* Not supported on disk */
750 flags
|= UFS_DE_OLD
| UFS_UID_EFT
| UFS_ST_SUNx86
| UFS_CG_SUN
;
753 case UFS_MOUNT_UFSTYPE_OLD
:
754 UFSD("ufstype=old\n");
755 uspi
->s_fsize
= block_size
= 1024;
756 uspi
->s_fmask
= ~(1024 - 1);
758 uspi
->s_sbsize
= super_block_size
= 2048;
760 flags
|= UFS_DE_OLD
| UFS_UID_OLD
| UFS_ST_OLD
| UFS_CG_OLD
;
761 if (!(sb
->s_flags
& MS_RDONLY
)) {
763 printk(KERN_INFO
"ufstype=old is supported read-only\n");
764 sb
->s_flags
|= MS_RDONLY
;
768 case UFS_MOUNT_UFSTYPE_NEXTSTEP
:
769 UFSD("ufstype=nextstep\n");
770 uspi
->s_fsize
= block_size
= 1024;
771 uspi
->s_fmask
= ~(1024 - 1);
773 uspi
->s_sbsize
= super_block_size
= 2048;
775 uspi
->s_dirblksize
= 1024;
776 flags
|= UFS_DE_OLD
| UFS_UID_OLD
| UFS_ST_OLD
| UFS_CG_OLD
;
777 if (!(sb
->s_flags
& MS_RDONLY
)) {
779 printk(KERN_INFO
"ufstype=nextstep is supported read-only\n");
780 sb
->s_flags
|= MS_RDONLY
;
784 case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD
:
785 UFSD("ufstype=nextstep-cd\n");
786 uspi
->s_fsize
= block_size
= 2048;
787 uspi
->s_fmask
= ~(2048 - 1);
789 uspi
->s_sbsize
= super_block_size
= 2048;
791 uspi
->s_dirblksize
= 1024;
792 flags
|= UFS_DE_OLD
| UFS_UID_OLD
| UFS_ST_OLD
| UFS_CG_OLD
;
793 if (!(sb
->s_flags
& MS_RDONLY
)) {
795 printk(KERN_INFO
"ufstype=nextstep-cd is supported read-only\n");
796 sb
->s_flags
|= MS_RDONLY
;
800 case UFS_MOUNT_UFSTYPE_OPENSTEP
:
801 UFSD("ufstype=openstep\n");
802 uspi
->s_fsize
= block_size
= 1024;
803 uspi
->s_fmask
= ~(1024 - 1);
805 uspi
->s_sbsize
= super_block_size
= 2048;
807 uspi
->s_dirblksize
= 1024;
808 flags
|= UFS_DE_44BSD
| UFS_UID_44BSD
| UFS_ST_44BSD
| UFS_CG_44BSD
;
809 if (!(sb
->s_flags
& MS_RDONLY
)) {
811 printk(KERN_INFO
"ufstype=openstep is supported read-only\n");
812 sb
->s_flags
|= MS_RDONLY
;
816 case UFS_MOUNT_UFSTYPE_HP
:
817 UFSD("ufstype=hp\n");
818 uspi
->s_fsize
= block_size
= 1024;
819 uspi
->s_fmask
= ~(1024 - 1);
821 uspi
->s_sbsize
= super_block_size
= 2048;
823 flags
|= UFS_DE_OLD
| UFS_UID_OLD
| UFS_ST_OLD
| UFS_CG_OLD
;
824 if (!(sb
->s_flags
& MS_RDONLY
)) {
826 printk(KERN_INFO
"ufstype=hp is supported read-only\n");
827 sb
->s_flags
|= MS_RDONLY
;
832 printk("unknown ufstype\n");
837 if (!sb_set_blocksize(sb
, block_size
)) {
838 printk(KERN_ERR
"UFS: failed to set blocksize\n");
843 * read ufs super block from device
846 ubh
= ubh_bread_uspi(uspi
, sb
, uspi
->s_sbbase
+ super_block_offset
/block_size
, super_block_size
);
851 usb1
= ubh_get_usb_first(uspi
);
852 usb2
= ubh_get_usb_second(uspi
);
853 usb3
= ubh_get_usb_third(uspi
);
855 /* Sort out mod used on SunOS 4.1.3 for fs_state */
856 uspi
->s_postblformat
= fs32_to_cpu(sb
, usb3
->fs_postblformat
);
857 if (((flags
& UFS_ST_MASK
) == UFS_ST_SUNOS
) &&
858 (uspi
->s_postblformat
!= UFS_42POSTBLFMT
)) {
859 flags
&= ~UFS_ST_MASK
;
864 * Check ufs magic number
866 sbi
->s_bytesex
= BYTESEX_LE
;
867 switch ((uspi
->fs_magic
= fs32_to_cpu(sb
, usb3
->fs_magic
))) {
875 sbi
->s_bytesex
= BYTESEX_BE
;
876 switch ((uspi
->fs_magic
= fs32_to_cpu(sb
, usb3
->fs_magic
))) {
885 if ((((sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) == UFS_MOUNT_UFSTYPE_NEXTSTEP
)
886 || ((sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD
)
887 || ((sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) == UFS_MOUNT_UFSTYPE_OPENSTEP
))
888 && uspi
->s_sbbase
< 256) {
889 ubh_brelse_uspi(uspi
);
895 printk("ufs_read_super: bad magic number\n");
900 * Check block and fragment sizes
902 uspi
->s_bsize
= fs32_to_cpu(sb
, usb1
->fs_bsize
);
903 uspi
->s_fsize
= fs32_to_cpu(sb
, usb1
->fs_fsize
);
904 uspi
->s_sbsize
= fs32_to_cpu(sb
, usb1
->fs_sbsize
);
905 uspi
->s_fmask
= fs32_to_cpu(sb
, usb1
->fs_fmask
);
906 uspi
->s_fshift
= fs32_to_cpu(sb
, usb1
->fs_fshift
);
908 if (!is_power_of_2(uspi
->s_fsize
)) {
909 printk(KERN_ERR
"ufs_read_super: fragment size %u is not a power of 2\n",
913 if (uspi
->s_fsize
< 512) {
914 printk(KERN_ERR
"ufs_read_super: fragment size %u is too small\n",
918 if (uspi
->s_fsize
> 4096) {
919 printk(KERN_ERR
"ufs_read_super: fragment size %u is too large\n",
923 if (!is_power_of_2(uspi
->s_bsize
)) {
924 printk(KERN_ERR
"ufs_read_super: block size %u is not a power of 2\n",
928 if (uspi
->s_bsize
< 4096) {
929 printk(KERN_ERR
"ufs_read_super: block size %u is too small\n",
933 if (uspi
->s_bsize
/ uspi
->s_fsize
> 8) {
934 printk(KERN_ERR
"ufs_read_super: too many fragments per block (%u)\n",
935 uspi
->s_bsize
/ uspi
->s_fsize
);
938 if (uspi
->s_fsize
!= block_size
|| uspi
->s_sbsize
!= super_block_size
) {
939 ubh_brelse_uspi(uspi
);
941 block_size
= uspi
->s_fsize
;
942 super_block_size
= uspi
->s_sbsize
;
943 UFSD("another value of block_size or super_block_size %u, %u\n", block_size
, super_block_size
);
947 sbi
->s_flags
= flags
;/*after that line some functions use s_flags*/
948 ufs_print_super_stuff(sb
, usb1
, usb2
, usb3
);
951 * Check, if file system was correctly unmounted.
952 * If not, make it read only.
954 if (((flags
& UFS_ST_MASK
) == UFS_ST_44BSD
) ||
955 ((flags
& UFS_ST_MASK
) == UFS_ST_OLD
) ||
956 (((flags
& UFS_ST_MASK
) == UFS_ST_SUN
||
957 (flags
& UFS_ST_MASK
) == UFS_ST_SUNOS
||
958 (flags
& UFS_ST_MASK
) == UFS_ST_SUNx86
) &&
959 (ufs_get_fs_state(sb
, usb1
, usb3
) == (UFS_FSOK
- fs32_to_cpu(sb
, usb1
->fs_time
))))) {
960 switch(usb1
->fs_clean
) {
962 UFSD("fs is clean\n");
965 UFSD("fs is stable\n");
968 UFSD("fs is DEC OSF/1\n");
971 printk("ufs_read_super: fs is active\n");
972 sb
->s_flags
|= MS_RDONLY
;
975 printk("ufs_read_super: fs is bad\n");
976 sb
->s_flags
|= MS_RDONLY
;
979 printk("ufs_read_super: can't grok fs_clean 0x%x\n", usb1
->fs_clean
);
980 sb
->s_flags
|= MS_RDONLY
;
984 printk("ufs_read_super: fs needs fsck\n");
985 sb
->s_flags
|= MS_RDONLY
;
989 * Read ufs_super_block into internal data structures
991 sb
->s_op
= &ufs_super_ops
;
992 sb
->dq_op
= NULL
; /***/
993 sb
->s_magic
= fs32_to_cpu(sb
, usb3
->fs_magic
);
995 uspi
->s_sblkno
= fs32_to_cpu(sb
, usb1
->fs_sblkno
);
996 uspi
->s_cblkno
= fs32_to_cpu(sb
, usb1
->fs_cblkno
);
997 uspi
->s_iblkno
= fs32_to_cpu(sb
, usb1
->fs_iblkno
);
998 uspi
->s_dblkno
= fs32_to_cpu(sb
, usb1
->fs_dblkno
);
999 uspi
->s_cgoffset
= fs32_to_cpu(sb
, usb1
->fs_cgoffset
);
1000 uspi
->s_cgmask
= fs32_to_cpu(sb
, usb1
->fs_cgmask
);
1002 if ((flags
& UFS_TYPE_MASK
) == UFS_TYPE_UFS2
) {
1003 uspi
->s_u2_size
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_size
);
1004 uspi
->s_u2_dsize
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_dsize
);
1006 uspi
->s_size
= fs32_to_cpu(sb
, usb1
->fs_size
);
1007 uspi
->s_dsize
= fs32_to_cpu(sb
, usb1
->fs_dsize
);
1010 uspi
->s_ncg
= fs32_to_cpu(sb
, usb1
->fs_ncg
);
1011 /* s_bsize already set */
1012 /* s_fsize already set */
1013 uspi
->s_fpb
= fs32_to_cpu(sb
, usb1
->fs_frag
);
1014 uspi
->s_minfree
= fs32_to_cpu(sb
, usb1
->fs_minfree
);
1015 uspi
->s_bmask
= fs32_to_cpu(sb
, usb1
->fs_bmask
);
1016 uspi
->s_fmask
= fs32_to_cpu(sb
, usb1
->fs_fmask
);
1017 uspi
->s_bshift
= fs32_to_cpu(sb
, usb1
->fs_bshift
);
1018 uspi
->s_fshift
= fs32_to_cpu(sb
, usb1
->fs_fshift
);
1019 UFSD("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi
->s_bshift
,
1021 uspi
->s_fpbshift
= fs32_to_cpu(sb
, usb1
->fs_fragshift
);
1022 uspi
->s_fsbtodb
= fs32_to_cpu(sb
, usb1
->fs_fsbtodb
);
1023 /* s_sbsize already set */
1024 uspi
->s_csmask
= fs32_to_cpu(sb
, usb1
->fs_csmask
);
1025 uspi
->s_csshift
= fs32_to_cpu(sb
, usb1
->fs_csshift
);
1026 uspi
->s_nindir
= fs32_to_cpu(sb
, usb1
->fs_nindir
);
1027 uspi
->s_inopb
= fs32_to_cpu(sb
, usb1
->fs_inopb
);
1028 uspi
->s_nspf
= fs32_to_cpu(sb
, usb1
->fs_nspf
);
1029 uspi
->s_npsect
= ufs_get_fs_npsect(sb
, usb1
, usb3
);
1030 uspi
->s_interleave
= fs32_to_cpu(sb
, usb1
->fs_interleave
);
1031 uspi
->s_trackskew
= fs32_to_cpu(sb
, usb1
->fs_trackskew
);
1033 if (uspi
->fs_magic
== UFS2_MAGIC
)
1034 uspi
->s_csaddr
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_csaddr
);
1036 uspi
->s_csaddr
= fs32_to_cpu(sb
, usb1
->fs_csaddr
);
1038 uspi
->s_cssize
= fs32_to_cpu(sb
, usb1
->fs_cssize
);
1039 uspi
->s_cgsize
= fs32_to_cpu(sb
, usb1
->fs_cgsize
);
1040 uspi
->s_ntrak
= fs32_to_cpu(sb
, usb1
->fs_ntrak
);
1041 uspi
->s_nsect
= fs32_to_cpu(sb
, usb1
->fs_nsect
);
1042 uspi
->s_spc
= fs32_to_cpu(sb
, usb1
->fs_spc
);
1043 uspi
->s_ipg
= fs32_to_cpu(sb
, usb1
->fs_ipg
);
1044 uspi
->s_fpg
= fs32_to_cpu(sb
, usb1
->fs_fpg
);
1045 uspi
->s_cpc
= fs32_to_cpu(sb
, usb2
->fs_un
.fs_u1
.fs_cpc
);
1046 uspi
->s_contigsumsize
= fs32_to_cpu(sb
, usb3
->fs_un2
.fs_44
.fs_contigsumsize
);
1047 uspi
->s_qbmask
= ufs_get_fs_qbmask(sb
, usb3
);
1048 uspi
->s_qfmask
= ufs_get_fs_qfmask(sb
, usb3
);
1049 uspi
->s_nrpos
= fs32_to_cpu(sb
, usb3
->fs_nrpos
);
1050 uspi
->s_postbloff
= fs32_to_cpu(sb
, usb3
->fs_postbloff
);
1051 uspi
->s_rotbloff
= fs32_to_cpu(sb
, usb3
->fs_rotbloff
);
1054 * Compute another frequently used values
1056 uspi
->s_fpbmask
= uspi
->s_fpb
- 1;
1057 if ((flags
& UFS_TYPE_MASK
) == UFS_TYPE_UFS2
)
1058 uspi
->s_apbshift
= uspi
->s_bshift
- 3;
1060 uspi
->s_apbshift
= uspi
->s_bshift
- 2;
1062 uspi
->s_2apbshift
= uspi
->s_apbshift
* 2;
1063 uspi
->s_3apbshift
= uspi
->s_apbshift
* 3;
1064 uspi
->s_apb
= 1 << uspi
->s_apbshift
;
1065 uspi
->s_2apb
= 1 << uspi
->s_2apbshift
;
1066 uspi
->s_3apb
= 1 << uspi
->s_3apbshift
;
1067 uspi
->s_apbmask
= uspi
->s_apb
- 1;
1068 uspi
->s_nspfshift
= uspi
->s_fshift
- UFS_SECTOR_BITS
;
1069 uspi
->s_nspb
= uspi
->s_nspf
<< uspi
->s_fpbshift
;
1070 uspi
->s_inopf
= uspi
->s_inopb
>> uspi
->s_fpbshift
;
1071 uspi
->s_bpf
= uspi
->s_fsize
<< 3;
1072 uspi
->s_bpfshift
= uspi
->s_fshift
+ 3;
1073 uspi
->s_bpfmask
= uspi
->s_bpf
- 1;
1074 if ((sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) == UFS_MOUNT_UFSTYPE_44BSD
||
1075 (sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
) == UFS_MOUNT_UFSTYPE_UFS2
)
1076 uspi
->s_maxsymlinklen
=
1077 fs32_to_cpu(sb
, usb3
->fs_un2
.fs_44
.fs_maxsymlinklen
);
1079 if (uspi
->fs_magic
== UFS2_MAGIC
)
1080 maxsymlen
= 2 * 4 * (UFS_NDADDR
+ UFS_NINDIR
);
1082 maxsymlen
= 4 * (UFS_NDADDR
+ UFS_NINDIR
);
1083 if (uspi
->s_maxsymlinklen
> maxsymlen
) {
1084 ufs_warning(sb
, __func__
, "ufs_read_super: excessive maximum "
1085 "fast symlink size (%u)\n", uspi
->s_maxsymlinklen
);
1086 uspi
->s_maxsymlinklen
= maxsymlen
;
1089 inode
= ufs_iget(sb
, UFS_ROOTINO
);
1090 if (IS_ERR(inode
)) {
1091 ret
= PTR_ERR(inode
);
1094 sb
->s_root
= d_alloc_root(inode
);
1100 ufs_setup_cstotal(sb
);
1102 * Read cylinder group structures
1104 if (!(sb
->s_flags
& MS_RDONLY
))
1105 if (!ufs_read_cylinder_structures(sb
))
1115 ubh_brelse_uspi (uspi
);
1118 sb
->s_fs_info
= NULL
;
1119 UFSD("EXIT (FAILED)\n");
1123 UFSD("EXIT (NOMEM)\n");
1127 static void ufs_write_super(struct super_block
*sb
)
1129 struct ufs_sb_private_info
* uspi
;
1130 struct ufs_super_block_first
* usb1
;
1131 struct ufs_super_block_third
* usb3
;
1136 flags
= UFS_SB(sb
)->s_flags
;
1137 uspi
= UFS_SB(sb
)->s_uspi
;
1138 usb1
= ubh_get_usb_first(uspi
);
1139 usb3
= ubh_get_usb_third(uspi
);
1141 if (!(sb
->s_flags
& MS_RDONLY
)) {
1142 usb1
->fs_time
= cpu_to_fs32(sb
, get_seconds());
1143 if ((flags
& UFS_ST_MASK
) == UFS_ST_SUN
1144 || (flags
& UFS_ST_MASK
) == UFS_ST_SUNOS
1145 || (flags
& UFS_ST_MASK
) == UFS_ST_SUNx86
)
1146 ufs_set_fs_state(sb
, usb1
, usb3
,
1147 UFS_FSOK
- fs32_to_cpu(sb
, usb1
->fs_time
));
1148 ufs_put_cstotal(sb
);
1155 static void ufs_put_super(struct super_block
*sb
)
1157 struct ufs_sb_info
* sbi
= UFS_SB(sb
);
1162 ufs_write_super(sb
);
1164 if (!(sb
->s_flags
& MS_RDONLY
))
1165 ufs_put_super_internal(sb
);
1167 ubh_brelse_uspi (sbi
->s_uspi
);
1168 kfree (sbi
->s_uspi
);
1170 sb
->s_fs_info
= NULL
;
1176 static int ufs_remount (struct super_block
*sb
, int *mount_flags
, char *data
)
1178 struct ufs_sb_private_info
* uspi
;
1179 struct ufs_super_block_first
* usb1
;
1180 struct ufs_super_block_third
* usb3
;
1181 unsigned new_mount_opt
, ufstype
;
1184 uspi
= UFS_SB(sb
)->s_uspi
;
1185 flags
= UFS_SB(sb
)->s_flags
;
1186 usb1
= ubh_get_usb_first(uspi
);
1187 usb3
= ubh_get_usb_third(uspi
);
1190 * Allow the "check" option to be passed as a remount option.
1191 * It is not possible to change ufstype option during remount
1193 ufstype
= UFS_SB(sb
)->s_mount_opt
& UFS_MOUNT_UFSTYPE
;
1195 ufs_set_opt (new_mount_opt
, ONERROR_LOCK
);
1196 if (!ufs_parse_options (data
, &new_mount_opt
))
1198 if (!(new_mount_opt
& UFS_MOUNT_UFSTYPE
)) {
1199 new_mount_opt
|= ufstype
;
1200 } else if ((new_mount_opt
& UFS_MOUNT_UFSTYPE
) != ufstype
) {
1201 printk("ufstype can't be changed during remount\n");
1205 if ((*mount_flags
& MS_RDONLY
) == (sb
->s_flags
& MS_RDONLY
)) {
1206 UFS_SB(sb
)->s_mount_opt
= new_mount_opt
;
1211 * fs was mouted as rw, remounting ro
1213 if (*mount_flags
& MS_RDONLY
) {
1214 ufs_put_super_internal(sb
);
1215 usb1
->fs_time
= cpu_to_fs32(sb
, get_seconds());
1216 if ((flags
& UFS_ST_MASK
) == UFS_ST_SUN
1217 || (flags
& UFS_ST_MASK
) == UFS_ST_SUNOS
1218 || (flags
& UFS_ST_MASK
) == UFS_ST_SUNx86
)
1219 ufs_set_fs_state(sb
, usb1
, usb3
,
1220 UFS_FSOK
- fs32_to_cpu(sb
, usb1
->fs_time
));
1221 ubh_mark_buffer_dirty (USPI_UBH(uspi
));
1223 sb
->s_flags
|= MS_RDONLY
;
1226 * fs was mounted as ro, remounting rw
1228 #ifndef CONFIG_UFS_FS_WRITE
1229 printk("ufs was compiled with read-only support, "
1230 "can't be mounted as read-write\n");
1233 if (ufstype
!= UFS_MOUNT_UFSTYPE_SUN
&&
1234 ufstype
!= UFS_MOUNT_UFSTYPE_SUNOS
&&
1235 ufstype
!= UFS_MOUNT_UFSTYPE_44BSD
&&
1236 ufstype
!= UFS_MOUNT_UFSTYPE_SUNx86
&&
1237 ufstype
!= UFS_MOUNT_UFSTYPE_UFS2
) {
1238 printk("this ufstype is read-only supported\n");
1241 if (!ufs_read_cylinder_structures(sb
)) {
1242 printk("failed during remounting\n");
1245 sb
->s_flags
&= ~MS_RDONLY
;
1248 UFS_SB(sb
)->s_mount_opt
= new_mount_opt
;
1252 static int ufs_show_options(struct seq_file
*seq
, struct vfsmount
*vfs
)
1254 struct ufs_sb_info
*sbi
= UFS_SB(vfs
->mnt_sb
);
1255 unsigned mval
= sbi
->s_mount_opt
& UFS_MOUNT_UFSTYPE
;
1256 const struct match_token
*tp
= tokens
;
1258 while (tp
->token
!= Opt_onerror_panic
&& tp
->token
!= mval
)
1260 BUG_ON(tp
->token
== Opt_onerror_panic
);
1261 seq_printf(seq
, ",%s", tp
->pattern
);
1263 mval
= sbi
->s_mount_opt
& UFS_MOUNT_ONERROR
;
1264 while (tp
->token
!= Opt_err
&& tp
->token
!= mval
)
1266 BUG_ON(tp
->token
== Opt_err
);
1267 seq_printf(seq
, ",%s", tp
->pattern
);
1272 static int ufs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
1274 struct super_block
*sb
= dentry
->d_sb
;
1275 struct ufs_sb_private_info
*uspi
= UFS_SB(sb
)->s_uspi
;
1276 unsigned flags
= UFS_SB(sb
)->s_flags
;
1277 struct ufs_super_block_first
*usb1
;
1278 struct ufs_super_block_second
*usb2
;
1279 struct ufs_super_block_third
*usb3
;
1280 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
1284 usb1
= ubh_get_usb_first(uspi
);
1285 usb2
= ubh_get_usb_second(uspi
);
1286 usb3
= ubh_get_usb_third(uspi
);
1288 if ((flags
& UFS_TYPE_MASK
) == UFS_TYPE_UFS2
) {
1289 buf
->f_type
= UFS2_MAGIC
;
1290 buf
->f_blocks
= fs64_to_cpu(sb
, usb3
->fs_un1
.fs_u2
.fs_dsize
);
1292 buf
->f_type
= UFS_MAGIC
;
1293 buf
->f_blocks
= uspi
->s_dsize
;
1295 buf
->f_bfree
= ufs_blkstofrags(uspi
->cs_total
.cs_nbfree
) +
1296 uspi
->cs_total
.cs_nffree
;
1297 buf
->f_ffree
= uspi
->cs_total
.cs_nifree
;
1298 buf
->f_bsize
= sb
->s_blocksize
;
1299 buf
->f_bavail
= (buf
->f_bfree
> (((long)buf
->f_blocks
/ 100) * uspi
->s_minfree
))
1300 ? (buf
->f_bfree
- (((long)buf
->f_blocks
/ 100) * uspi
->s_minfree
)) : 0;
1301 buf
->f_files
= uspi
->s_ncg
* uspi
->s_ipg
;
1302 buf
->f_namelen
= UFS_MAXNAMLEN
;
1303 buf
->f_fsid
.val
[0] = (u32
)id
;
1304 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
1311 static struct kmem_cache
* ufs_inode_cachep
;
1313 static struct inode
*ufs_alloc_inode(struct super_block
*sb
)
1315 struct ufs_inode_info
*ei
;
1316 ei
= (struct ufs_inode_info
*)kmem_cache_alloc(ufs_inode_cachep
, GFP_KERNEL
);
1319 ei
->vfs_inode
.i_version
= 1;
1320 return &ei
->vfs_inode
;
1323 static void ufs_destroy_inode(struct inode
*inode
)
1325 kmem_cache_free(ufs_inode_cachep
, UFS_I(inode
));
1328 static void init_once(void *foo
)
1330 struct ufs_inode_info
*ei
= (struct ufs_inode_info
*) foo
;
1332 inode_init_once(&ei
->vfs_inode
);
1335 static int init_inodecache(void)
1337 ufs_inode_cachep
= kmem_cache_create("ufs_inode_cache",
1338 sizeof(struct ufs_inode_info
),
1339 0, (SLAB_RECLAIM_ACCOUNT
|
1342 if (ufs_inode_cachep
== NULL
)
1347 static void destroy_inodecache(void)
1349 kmem_cache_destroy(ufs_inode_cachep
);
1353 static ssize_t
ufs_quota_read(struct super_block
*, int, char *,size_t, loff_t
);
1354 static ssize_t
ufs_quota_write(struct super_block
*, int, const char *, size_t, loff_t
);
1357 static const struct super_operations ufs_super_ops
= {
1358 .alloc_inode
= ufs_alloc_inode
,
1359 .destroy_inode
= ufs_destroy_inode
,
1360 .write_inode
= ufs_write_inode
,
1361 .delete_inode
= ufs_delete_inode
,
1362 .put_super
= ufs_put_super
,
1363 .write_super
= ufs_write_super
,
1364 .statfs
= ufs_statfs
,
1365 .remount_fs
= ufs_remount
,
1366 .show_options
= ufs_show_options
,
1368 .quota_read
= ufs_quota_read
,
1369 .quota_write
= ufs_quota_write
,
1375 /* Read data from quotafile - avoid pagecache and such because we cannot afford
1376 * acquiring the locks... As quota files are never truncated and quota code
1377 * itself serializes the operations (and noone else should touch the files)
1378 * we don't have to be afraid of races */
1379 static ssize_t
ufs_quota_read(struct super_block
*sb
, int type
, char *data
,
1380 size_t len
, loff_t off
)
1382 struct inode
*inode
= sb_dqopt(sb
)->files
[type
];
1383 sector_t blk
= off
>> sb
->s_blocksize_bits
;
1385 int offset
= off
& (sb
->s_blocksize
- 1);
1388 struct buffer_head
*bh
;
1389 loff_t i_size
= i_size_read(inode
);
1393 if (off
+len
> i_size
)
1396 while (toread
> 0) {
1397 tocopy
= sb
->s_blocksize
- offset
< toread
?
1398 sb
->s_blocksize
- offset
: toread
;
1400 bh
= ufs_bread(inode
, blk
, 0, &err
);
1403 if (!bh
) /* A hole? */
1404 memset(data
, 0, tocopy
);
1406 memcpy(data
, bh
->b_data
+offset
, tocopy
);
1417 /* Write to quotafile */
1418 static ssize_t
ufs_quota_write(struct super_block
*sb
, int type
,
1419 const char *data
, size_t len
, loff_t off
)
1421 struct inode
*inode
= sb_dqopt(sb
)->files
[type
];
1422 sector_t blk
= off
>> sb
->s_blocksize_bits
;
1424 int offset
= off
& (sb
->s_blocksize
- 1);
1426 size_t towrite
= len
;
1427 struct buffer_head
*bh
;
1429 mutex_lock_nested(&inode
->i_mutex
, I_MUTEX_QUOTA
);
1430 while (towrite
> 0) {
1431 tocopy
= sb
->s_blocksize
- offset
< towrite
?
1432 sb
->s_blocksize
- offset
: towrite
;
1434 bh
= ufs_bread(inode
, blk
, 1, &err
);
1438 memcpy(bh
->b_data
+offset
, data
, tocopy
);
1439 flush_dcache_page(bh
->b_page
);
1440 set_buffer_uptodate(bh
);
1441 mark_buffer_dirty(bh
);
1450 if (len
== towrite
) {
1451 mutex_unlock(&inode
->i_mutex
);
1454 if (inode
->i_size
< off
+len
-towrite
)
1455 i_size_write(inode
, off
+len
-towrite
);
1457 inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME_SEC
;
1458 mark_inode_dirty(inode
);
1459 mutex_unlock(&inode
->i_mutex
);
1460 return len
- towrite
;
1465 static int ufs_get_sb(struct file_system_type
*fs_type
,
1466 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
1468 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, ufs_fill_super
, mnt
);
1471 static struct file_system_type ufs_fs_type
= {
1472 .owner
= THIS_MODULE
,
1474 .get_sb
= ufs_get_sb
,
1475 .kill_sb
= kill_block_super
,
1476 .fs_flags
= FS_REQUIRES_DEV
,
1479 static int __init
init_ufs_fs(void)
1481 int err
= init_inodecache();
1484 err
= register_filesystem(&ufs_fs_type
);
1489 destroy_inodecache();
1494 static void __exit
exit_ufs_fs(void)
1496 unregister_filesystem(&ufs_fs_type
);
1497 destroy_inodecache();
1500 module_init(init_ufs_fs
)
1501 module_exit(exit_ufs_fs
)
1502 MODULE_LICENSE("GPL");