1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * linux/fs/ufs/super.c
4 *
5 * Copyright (C) 1998
6 * Daniel Pirkl <daniel.pirkl@email.cz>
7 * Charles University, Faculty of Mathematics and Physics
8 */
9
10 /* Derived from
11 *
12 * linux/fs/ext2/super.c
13 *
14 * Copyright (C) 1992, 1993, 1994, 1995
15 * Remy Card (card@masi.ibp.fr)
16 * Laboratoire MASI - Institut Blaise Pascal
17 * Universite Pierre et Marie Curie (Paris VI)
18 *
19 * from
20 *
21 * linux/fs/minix/inode.c
22 *
23 * Copyright (C) 1991, 1992 Linus Torvalds
24 *
25 * Big-endian to little-endian byte-swapping/bitmaps by
26 * David S. Miller (davem@caip.rutgers.edu), 1995
27 */
28
29 /*
30 * Inspired by
31 *
32 * linux/fs/ufs/super.c
33 *
34 * Copyright (C) 1996
35 * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
36 * Laboratory for Computer Science Research Computing Facility
37 * Rutgers, The State University of New Jersey
38 *
39 * Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
40 *
41 * Kernel module support added on 96/04/26 by
42 * Stefan Reinauer <stepan@home.culture.mipt.ru>
43 *
44 * Module usage counts added on 96/04/29 by
45 * Gertjan van Wingerde <gwingerde@gmail.com>
46 *
47 * Clean swab support on 19970406 by
48 * Francois-Rene Rideau <fare@tunes.org>
49 *
50 * 4.4BSD (FreeBSD) support added on February 1st 1998 by
51 * Niels Kristian Bech Jensen <nkbj@image.dk> partially based
52 * on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>.
53 *
54 * NeXTstep support added on February 5th 1998 by
55 * Niels Kristian Bech Jensen <nkbj@image.dk>.
56 *
57 * write support Daniel Pirkl <daniel.pirkl@email.cz> 1998
58 *
59 * HP/UX hfs filesystem support added by
60 * Martin K. Petersen <mkp@mkp.net>, August 1999
61 *
62 * UFS2 (of FreeBSD 5.x) support added by
63 * Niraj Kumar <niraj17@iitbombay.org>, Jan 2004
64 *
65 * UFS2 write support added by
66 * Evgeniy Dushistov <dushistov@mail.ru>, 2007
67 */
68
69 #include <linux/exportfs.h>
70 #include <linux/module.h>
71 #include <linux/bitops.h>
72
73 #include <linux/stdarg.h>
74
75 #include <linux/uaccess.h>
76
77 #include <linux/errno.h>
78 #include <linux/fs.h>
79 #include <linux/slab.h>
80 #include <linux/time.h>
81 #include <linux/stat.h>
82 #include <linux/string.h>
83 #include <linux/blkdev.h>
84 #include <linux/backing-dev.h>
85 #include <linux/init.h>
86 #include <linux/fs_context.h>
87 #include <linux/fs_parser.h>
88 #include <linux/buffer_head.h>
89 #include <linux/vfs.h>
90 #include <linux/log2.h>
91 #include <linux/seq_file.h>
92 #include <linux/iversion.h>
93
94 #include "ufs_fs.h"
95 #include "ufs.h"
96 #include "swab.h"
97 #include "util.h"
98
ufs_nfs_get_inode(struct super_block * sb,u64 ino,u32 generation)99 static struct inode *ufs_nfs_get_inode(struct super_block *sb, u64 ino, u32 generation)
100 {
101 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
102 struct inode *inode;
103
104 if (ino < UFS_ROOTINO || ino > (u64)uspi->s_ncg * uspi->s_ipg)
105 return ERR_PTR(-ESTALE);
106
107 inode = ufs_iget(sb, ino);
108 if (IS_ERR(inode))
109 return ERR_CAST(inode);
110 if (generation && inode->i_generation != generation) {
111 iput(inode);
112 return ERR_PTR(-ESTALE);
113 }
114 return inode;
115 }
116
ufs_fh_to_dentry(struct super_block * sb,struct fid * fid,int fh_len,int fh_type)117 static struct dentry *ufs_fh_to_dentry(struct super_block *sb, struct fid *fid,
118 int fh_len, int fh_type)
119 {
120 return generic_fh_to_dentry(sb, fid, fh_len, fh_type, ufs_nfs_get_inode);
121 }
122
ufs_fh_to_parent(struct super_block * sb,struct fid * fid,int fh_len,int fh_type)123 static struct dentry *ufs_fh_to_parent(struct super_block *sb, struct fid *fid,
124 int fh_len, int fh_type)
125 {
126 return generic_fh_to_parent(sb, fid, fh_len, fh_type, ufs_nfs_get_inode);
127 }
128
ufs_get_parent(struct dentry * child)129 static struct dentry *ufs_get_parent(struct dentry *child)
130 {
131 ino_t ino;
132
133 ino = ufs_inode_by_name(d_inode(child), &dotdot_name);
134 if (!ino)
135 return ERR_PTR(-ENOENT);
136 return d_obtain_alias(ufs_iget(child->d_sb, ino));
137 }
138
139 static const struct export_operations ufs_export_ops = {
140 .encode_fh = generic_encode_ino32_fh,
141 .fh_to_dentry = ufs_fh_to_dentry,
142 .fh_to_parent = ufs_fh_to_parent,
143 .get_parent = ufs_get_parent,
144 };
145
146 #ifdef CONFIG_UFS_DEBUG
147 /*
148 * Print contents of ufs_super_block, useful for debugging
149 */
ufs_print_super_stuff(struct super_block * sb,struct ufs_super_block_first * usb1,struct ufs_super_block_second * usb2,struct ufs_super_block_third * usb3)150 static void ufs_print_super_stuff(struct super_block *sb,
151 struct ufs_super_block_first *usb1,
152 struct ufs_super_block_second *usb2,
153 struct ufs_super_block_third *usb3)
154 {
155 u32 magic = fs32_to_cpu(sb, usb3->fs_magic);
156
157 pr_debug("ufs_print_super_stuff\n");
158 pr_debug(" magic: 0x%x\n", magic);
159 if (fs32_to_cpu(sb, usb3->fs_magic) == UFS2_MAGIC) {
160 pr_debug(" fs_size: %llu\n", (unsigned long long)
161 fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size));
162 pr_debug(" fs_dsize: %llu\n", (unsigned long long)
163 fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize));
164 pr_debug(" bsize: %u\n",
165 fs32_to_cpu(sb, usb1->fs_bsize));
166 pr_debug(" fsize: %u\n",
167 fs32_to_cpu(sb, usb1->fs_fsize));
168 pr_debug(" fs_volname: %s\n", usb2->fs_un.fs_u2.fs_volname);
169 pr_debug(" fs_sblockloc: %llu\n", (unsigned long long)
170 fs64_to_cpu(sb, usb2->fs_un.fs_u2.fs_sblockloc));
171 pr_debug(" cs_ndir(No of dirs): %llu\n", (unsigned long long)
172 fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir));
173 pr_debug(" cs_nbfree(No of free blocks): %llu\n",
174 (unsigned long long)
175 fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_nbfree));
176 pr_info(" cs_nifree(Num of free inodes): %llu\n",
177 (unsigned long long)
178 fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nifree));
179 pr_info(" cs_nffree(Num of free frags): %llu\n",
180 (unsigned long long)
181 fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nffree));
182 pr_info(" fs_maxsymlinklen: %u\n",
183 fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen));
184 } else {
185 pr_debug(" sblkno: %u\n", fs32_to_cpu(sb, usb1->fs_sblkno));
186 pr_debug(" cblkno: %u\n", fs32_to_cpu(sb, usb1->fs_cblkno));
187 pr_debug(" iblkno: %u\n", fs32_to_cpu(sb, usb1->fs_iblkno));
188 pr_debug(" dblkno: %u\n", fs32_to_cpu(sb, usb1->fs_dblkno));
189 pr_debug(" cgoffset: %u\n",
190 fs32_to_cpu(sb, usb1->fs_cgoffset));
191 pr_debug(" ~cgmask: 0x%x\n",
192 ~fs32_to_cpu(sb, usb1->fs_cgmask));
193 pr_debug(" size: %u\n", fs32_to_cpu(sb, usb1->fs_size));
194 pr_debug(" dsize: %u\n", fs32_to_cpu(sb, usb1->fs_dsize));
195 pr_debug(" ncg: %u\n", fs32_to_cpu(sb, usb1->fs_ncg));
196 pr_debug(" bsize: %u\n", fs32_to_cpu(sb, usb1->fs_bsize));
197 pr_debug(" fsize: %u\n", fs32_to_cpu(sb, usb1->fs_fsize));
198 pr_debug(" frag: %u\n", fs32_to_cpu(sb, usb1->fs_frag));
199 pr_debug(" fragshift: %u\n",
200 fs32_to_cpu(sb, usb1->fs_fragshift));
201 pr_debug(" ~fmask: %u\n", ~fs32_to_cpu(sb, usb1->fs_fmask));
202 pr_debug(" fshift: %u\n", fs32_to_cpu(sb, usb1->fs_fshift));
203 pr_debug(" sbsize: %u\n", fs32_to_cpu(sb, usb1->fs_sbsize));
204 pr_debug(" spc: %u\n", fs32_to_cpu(sb, usb1->fs_spc));
205 pr_debug(" cpg: %u\n", fs32_to_cpu(sb, usb1->fs_cpg));
206 pr_debug(" ipg: %u\n", fs32_to_cpu(sb, usb1->fs_ipg));
207 pr_debug(" fpg: %u\n", fs32_to_cpu(sb, usb1->fs_fpg));
208 pr_debug(" csaddr: %u\n", fs32_to_cpu(sb, usb1->fs_csaddr));
209 pr_debug(" cssize: %u\n", fs32_to_cpu(sb, usb1->fs_cssize));
210 pr_debug(" cgsize: %u\n", fs32_to_cpu(sb, usb1->fs_cgsize));
211 pr_debug(" fstodb: %u\n",
212 fs32_to_cpu(sb, usb1->fs_fsbtodb));
213 pr_debug(" nrpos: %u\n", fs32_to_cpu(sb, usb3->fs_nrpos));
214 pr_debug(" ndir %u\n",
215 fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir));
216 pr_debug(" nifree %u\n",
217 fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree));
218 pr_debug(" nbfree %u\n",
219 fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree));
220 pr_debug(" nffree %u\n",
221 fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree));
222 }
223 pr_debug("\n");
224 }
225
226 /*
227 * Print contents of ufs_cylinder_group, useful for debugging
228 */
ufs_print_cylinder_stuff(struct super_block * sb,struct ufs_cylinder_group * cg)229 static void ufs_print_cylinder_stuff(struct super_block *sb,
230 struct ufs_cylinder_group *cg)
231 {
232 pr_debug("\nufs_print_cylinder_stuff\n");
233 pr_debug("size of ucg: %zu\n", sizeof(struct ufs_cylinder_group));
234 pr_debug(" magic: %x\n", fs32_to_cpu(sb, cg->cg_magic));
235 pr_debug(" time: %u\n", fs32_to_cpu(sb, cg->cg_time));
236 pr_debug(" cgx: %u\n", fs32_to_cpu(sb, cg->cg_cgx));
237 pr_debug(" ncyl: %u\n", fs16_to_cpu(sb, cg->cg_ncyl));
238 pr_debug(" niblk: %u\n", fs16_to_cpu(sb, cg->cg_niblk));
239 pr_debug(" ndblk: %u\n", fs32_to_cpu(sb, cg->cg_ndblk));
240 pr_debug(" cs_ndir: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_ndir));
241 pr_debug(" cs_nbfree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nbfree));
242 pr_debug(" cs_nifree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nifree));
243 pr_debug(" cs_nffree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nffree));
244 pr_debug(" rotor: %u\n", fs32_to_cpu(sb, cg->cg_rotor));
245 pr_debug(" frotor: %u\n", fs32_to_cpu(sb, cg->cg_frotor));
246 pr_debug(" irotor: %u\n", fs32_to_cpu(sb, cg->cg_irotor));
247 pr_debug(" frsum: %u, %u, %u, %u, %u, %u, %u, %u\n",
248 fs32_to_cpu(sb, cg->cg_frsum[0]), fs32_to_cpu(sb, cg->cg_frsum[1]),
249 fs32_to_cpu(sb, cg->cg_frsum[2]), fs32_to_cpu(sb, cg->cg_frsum[3]),
250 fs32_to_cpu(sb, cg->cg_frsum[4]), fs32_to_cpu(sb, cg->cg_frsum[5]),
251 fs32_to_cpu(sb, cg->cg_frsum[6]), fs32_to_cpu(sb, cg->cg_frsum[7]));
252 pr_debug(" btotoff: %u\n", fs32_to_cpu(sb, cg->cg_btotoff));
253 pr_debug(" boff: %u\n", fs32_to_cpu(sb, cg->cg_boff));
254 pr_debug(" iuseoff: %u\n", fs32_to_cpu(sb, cg->cg_iusedoff));
255 pr_debug(" freeoff: %u\n", fs32_to_cpu(sb, cg->cg_freeoff));
256 pr_debug(" nextfreeoff: %u\n", fs32_to_cpu(sb, cg->cg_nextfreeoff));
257 pr_debug(" clustersumoff %u\n",
258 fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clustersumoff));
259 pr_debug(" clusteroff %u\n",
260 fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clusteroff));
261 pr_debug(" nclusterblks %u\n",
262 fs32_to_cpu(sb, cg->cg_u.cg_44.cg_nclusterblks));
263 pr_debug("\n");
264 }
265 #else
266 # define ufs_print_super_stuff(sb, usb1, usb2, usb3) /**/
267 # define ufs_print_cylinder_stuff(sb, cg) /**/
268 #endif /* CONFIG_UFS_DEBUG */
269
270 static const struct super_operations ufs_super_ops;
271
ufs_error(struct super_block * sb,const char * function,const char * fmt,...)272 void ufs_error (struct super_block * sb, const char * function,
273 const char * fmt, ...)
274 {
275 struct ufs_sb_private_info * uspi;
276 struct ufs_super_block_first * usb1;
277 struct va_format vaf;
278 va_list args;
279
280 uspi = UFS_SB(sb)->s_uspi;
281 usb1 = ubh_get_usb_first(uspi);
282
283 if (!sb_rdonly(sb)) {
284 usb1->fs_clean = UFS_FSBAD;
285 ubh_mark_buffer_dirty(USPI_UBH(uspi));
286 ufs_mark_sb_dirty(sb);
287 sb->s_flags |= SB_RDONLY;
288 }
289 va_start(args, fmt);
290 vaf.fmt = fmt;
291 vaf.va = &args;
292 switch (UFS_SB(sb)->s_on_err) {
293 case UFS_MOUNT_ONERROR_PANIC:
294 panic("panic (device %s): %s: %pV\n",
295 sb->s_id, function, &vaf);
296
297 case UFS_MOUNT_ONERROR_LOCK:
298 case UFS_MOUNT_ONERROR_UMOUNT:
299 case UFS_MOUNT_ONERROR_REPAIR:
300 pr_crit("error (device %s): %s: %pV\n",
301 sb->s_id, function, &vaf);
302 }
303 va_end(args);
304 }
305
ufs_panic(struct super_block * sb,const char * function,const char * fmt,...)306 void ufs_panic (struct super_block * sb, const char * function,
307 const char * fmt, ...)
308 {
309 struct ufs_sb_private_info * uspi;
310 struct ufs_super_block_first * usb1;
311 struct va_format vaf;
312 va_list args;
313
314 uspi = UFS_SB(sb)->s_uspi;
315 usb1 = ubh_get_usb_first(uspi);
316
317 if (!sb_rdonly(sb)) {
318 usb1->fs_clean = UFS_FSBAD;
319 ubh_mark_buffer_dirty(USPI_UBH(uspi));
320 ufs_mark_sb_dirty(sb);
321 }
322 va_start(args, fmt);
323 vaf.fmt = fmt;
324 vaf.va = &args;
325 sb->s_flags |= SB_RDONLY;
326 pr_crit("panic (device %s): %s: %pV\n",
327 sb->s_id, function, &vaf);
328 va_end(args);
329 }
330
ufs_warning(struct super_block * sb,const char * function,const char * fmt,...)331 void ufs_warning (struct super_block * sb, const char * function,
332 const char * fmt, ...)
333 {
334 struct va_format vaf;
335 va_list args;
336
337 va_start(args, fmt);
338 vaf.fmt = fmt;
339 vaf.va = &args;
340 pr_warn("(device %s): %s: %pV\n",
341 sb->s_id, function, &vaf);
342 va_end(args);
343 }
344
345 enum { Opt_type, Opt_onerror };
346
347 static const struct constant_table ufs_param_ufstype[] = {
348 {"old", UFS_MOUNT_UFSTYPE_OLD},
349 {"sunx86", UFS_MOUNT_UFSTYPE_SUNx86},
350 {"sun", UFS_MOUNT_UFSTYPE_SUN},
351 {"sunos", UFS_MOUNT_UFSTYPE_SUNOS},
352 {"44bsd", UFS_MOUNT_UFSTYPE_44BSD},
353 {"ufs2", UFS_MOUNT_UFSTYPE_UFS2},
354 {"5xbsd", UFS_MOUNT_UFSTYPE_UFS2},
355 {"hp", UFS_MOUNT_UFSTYPE_HP},
356 {"nextstep-cd", UFS_MOUNT_UFSTYPE_NEXTSTEP_CD},
357 {"nextstep", UFS_MOUNT_UFSTYPE_NEXTSTEP},
358 {"openstep", UFS_MOUNT_UFSTYPE_OPENSTEP},
359 {}
360 };
361
362 static const struct constant_table ufs_param_onerror[] = {
363 {"panic", UFS_MOUNT_ONERROR_PANIC},
364 {"lock", UFS_MOUNT_ONERROR_LOCK},
365 {"umount", UFS_MOUNT_ONERROR_UMOUNT},
366 {"repair", UFS_MOUNT_ONERROR_REPAIR},
367 {}
368 };
369
370 static const struct fs_parameter_spec ufs_param_spec[] = {
371 fsparam_enum ("ufstype", Opt_type, ufs_param_ufstype),
372 fsparam_enum ("onerror", Opt_onerror, ufs_param_onerror),
373 {}
374 };
375
376 struct ufs_fs_context {
377 unsigned int flavour, on_err;
378 };
379
ufs_parse_param(struct fs_context * fc,struct fs_parameter * param)380 static int ufs_parse_param(struct fs_context *fc, struct fs_parameter *param)
381 {
382 struct ufs_fs_context *ctx = fc->fs_private;
383 struct fs_parse_result result;
384 int opt;
385
386 UFSD("ENTER\n");
387
388 opt = fs_parse(fc, ufs_param_spec, param, &result);
389 if (opt < 0)
390 return opt;
391
392 switch (opt) {
393 case Opt_type:
394 if (ctx->flavour == result.uint_32) /* no-op */
395 return 0;
396 if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
397 pr_err("ufstype can't be changed during remount\n");
398 return -EINVAL;
399 }
400 if (ctx->flavour) {
401 pr_err("conflicting ufstype options\n");
402 return -EINVAL;
403 }
404 ctx->flavour = result.uint_32;
405 break;
406 case Opt_onerror:
407 ctx->on_err = result.uint_32;
408 break;
409 default:
410 return -EINVAL;
411 }
412 return 0;
413 }
414
415 /*
416 * Different types of UFS hold fs_cstotal in different
417 * places, and use different data structure for it.
418 * To make things simpler we just copy fs_cstotal to ufs_sb_private_info
419 */
ufs_setup_cstotal(struct super_block * sb)420 static void ufs_setup_cstotal(struct super_block *sb)
421 {
422 struct ufs_sb_info *sbi = UFS_SB(sb);
423 struct ufs_sb_private_info *uspi = sbi->s_uspi;
424 struct ufs_super_block_first *usb1;
425 struct ufs_super_block_second *usb2;
426 struct ufs_super_block_third *usb3;
427 unsigned mtype = sbi->s_flavour;
428
429 UFSD("ENTER, mtype=%u\n", mtype);
430 usb1 = ubh_get_usb_first(uspi);
431 usb2 = ubh_get_usb_second(uspi);
432 usb3 = ubh_get_usb_third(uspi);
433
434 if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&
435 (usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) ||
436 mtype == UFS_MOUNT_UFSTYPE_UFS2) {
437 /*we have statistic in different place, then usual*/
438 uspi->cs_total.cs_ndir = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir);
439 uspi->cs_total.cs_nbfree = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_nbfree);
440 uspi->cs_total.cs_nifree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nifree);
441 uspi->cs_total.cs_nffree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nffree);
442 } else {
443 uspi->cs_total.cs_ndir = fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir);
444 uspi->cs_total.cs_nbfree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree);
445 uspi->cs_total.cs_nifree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree);
446 uspi->cs_total.cs_nffree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree);
447 }
448 UFSD("EXIT\n");
449 }
450
451 /*
452 * Read on-disk structures associated with cylinder groups
453 */
ufs_read_cylinder_structures(struct super_block * sb)454 static int ufs_read_cylinder_structures(struct super_block *sb)
455 {
456 struct ufs_sb_info *sbi = UFS_SB(sb);
457 struct ufs_sb_private_info *uspi = sbi->s_uspi;
458 unsigned char * base, * space;
459 unsigned size, blks, i;
460
461 UFSD("ENTER\n");
462
463 /*
464 * Read cs structures from (usually) first data block
465 * on the device.
466 */
467 size = uspi->s_cssize;
468 blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
469 base = space = kmalloc(size, GFP_NOFS);
470 if (!base)
471 goto failed;
472 sbi->s_csp = (struct ufs_csum *)space;
473 for (i = 0; i < blks; i++) {
474 struct buffer_head *bh = sb_bread(sb, uspi->s_csaddr + i);
475 if (!bh)
476 goto failed;
477 memcpy(space, bh->b_data, uspi->s_fsize);
478 space += uspi->s_fsize;
479 brelse (bh);
480 }
481
482 /*
483 * Read cylinder group (we read only first fragment from block
484 * at this time) and prepare internal data structures for cg caching.
485 */
486 sbi->s_ucg = kmalloc_objs(struct buffer_head *, uspi->s_ncg, GFP_NOFS);
487 if (!sbi->s_ucg)
488 goto failed;
489 for (i = 0; i < uspi->s_ncg; i++)
490 sbi->s_ucg[i] = NULL;
491 for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
492 sbi->s_ucpi[i] = NULL;
493 sbi->s_cgno[i] = UFS_CGNO_EMPTY;
494 }
495 for (i = 0; i < uspi->s_ncg; i++) {
496 UFSD("read cg %u\n", i);
497 if (!(sbi->s_ucg[i] = sb_bread(sb, ufs_cgcmin(i))))
498 goto failed;
499 if (!ufs_cg_chkmagic (sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data))
500 goto failed;
501
502 ufs_print_cylinder_stuff(sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data);
503 }
504 for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
505 if (!(sbi->s_ucpi[i] = kmalloc_obj(struct ufs_cg_private_info, GFP_NOFS)))
506 goto failed;
507 sbi->s_cgno[i] = UFS_CGNO_EMPTY;
508 }
509 sbi->s_cg_loaded = 0;
510 UFSD("EXIT\n");
511 return 1;
512
513 failed:
514 kfree (base);
515 if (sbi->s_ucg) {
516 for (i = 0; i < uspi->s_ncg; i++)
517 if (sbi->s_ucg[i])
518 brelse (sbi->s_ucg[i]);
519 kfree (sbi->s_ucg);
520 for (i = 0; i < UFS_MAX_GROUP_LOADED; i++)
521 kfree (sbi->s_ucpi[i]);
522 }
523 UFSD("EXIT (FAILED)\n");
524 return 0;
525 }
526
527 /*
528 * Sync our internal copy of fs_cstotal with disk
529 */
ufs_put_cstotal(struct super_block * sb)530 static void ufs_put_cstotal(struct super_block *sb)
531 {
532 unsigned mtype = UFS_SB(sb)->s_flavour;
533 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
534 struct ufs_super_block_first *usb1;
535 struct ufs_super_block_second *usb2;
536 struct ufs_super_block_third *usb3;
537
538 UFSD("ENTER\n");
539 usb1 = ubh_get_usb_first(uspi);
540 usb2 = ubh_get_usb_second(uspi);
541 usb3 = ubh_get_usb_third(uspi);
542
543 if (mtype == UFS_MOUNT_UFSTYPE_UFS2) {
544 /*we have statistic in different place, then usual*/
545 usb2->fs_un.fs_u2.cs_ndir =
546 cpu_to_fs64(sb, uspi->cs_total.cs_ndir);
547 usb2->fs_un.fs_u2.cs_nbfree =
548 cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);
549 usb3->fs_un1.fs_u2.cs_nifree =
550 cpu_to_fs64(sb, uspi->cs_total.cs_nifree);
551 usb3->fs_un1.fs_u2.cs_nffree =
552 cpu_to_fs64(sb, uspi->cs_total.cs_nffree);
553 goto out;
554 }
555
556 if (mtype == UFS_MOUNT_UFSTYPE_44BSD &&
557 (usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) {
558 /* store stats in both old and new places */
559 usb2->fs_un.fs_u2.cs_ndir =
560 cpu_to_fs64(sb, uspi->cs_total.cs_ndir);
561 usb2->fs_un.fs_u2.cs_nbfree =
562 cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);
563 usb3->fs_un1.fs_u2.cs_nifree =
564 cpu_to_fs64(sb, uspi->cs_total.cs_nifree);
565 usb3->fs_un1.fs_u2.cs_nffree =
566 cpu_to_fs64(sb, uspi->cs_total.cs_nffree);
567 }
568 usb1->fs_cstotal.cs_ndir = cpu_to_fs32(sb, uspi->cs_total.cs_ndir);
569 usb1->fs_cstotal.cs_nbfree = cpu_to_fs32(sb, uspi->cs_total.cs_nbfree);
570 usb1->fs_cstotal.cs_nifree = cpu_to_fs32(sb, uspi->cs_total.cs_nifree);
571 usb1->fs_cstotal.cs_nffree = cpu_to_fs32(sb, uspi->cs_total.cs_nffree);
572 out:
573 ubh_mark_buffer_dirty(USPI_UBH(uspi));
574 ufs_print_super_stuff(sb, usb1, usb2, usb3);
575 UFSD("EXIT\n");
576 }
577
578 /**
579 * ufs_put_super_internal() - put on-disk intrenal structures
580 * @sb: pointer to super_block structure
581 * Put on-disk structures associated with cylinder groups
582 * and write them back to disk, also update cs_total on disk
583 */
ufs_put_super_internal(struct super_block * sb)584 static void ufs_put_super_internal(struct super_block *sb)
585 {
586 struct ufs_sb_info *sbi = UFS_SB(sb);
587 struct ufs_sb_private_info *uspi = sbi->s_uspi;
588 unsigned char * base, * space;
589 unsigned blks, size, i;
590
591
592 UFSD("ENTER\n");
593
594 ufs_put_cstotal(sb);
595 size = uspi->s_cssize;
596 blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
597 base = space = (char*) sbi->s_csp;
598 for (i = 0; i < blks; i++, space += uspi->s_fsize) {
599 struct buffer_head *bh = sb_bread(sb, uspi->s_csaddr + i);
600
601 if (unlikely(!bh)) { // better than an oops...
602 ufs_panic(sb, __func__,
603 "can't write part of cylinder group summary");
604 continue;
605 }
606 memcpy(bh->b_data, space, uspi->s_fsize);
607 mark_buffer_dirty(bh);
608 brelse(bh);
609 }
610 for (i = 0; i < sbi->s_cg_loaded; i++) {
611 ufs_put_cylinder (sb, i);
612 kfree (sbi->s_ucpi[i]);
613 }
614 for (; i < UFS_MAX_GROUP_LOADED; i++)
615 kfree (sbi->s_ucpi[i]);
616 for (i = 0; i < uspi->s_ncg; i++)
617 brelse (sbi->s_ucg[i]);
618 kfree (sbi->s_ucg);
619 kfree (base);
620
621 UFSD("EXIT\n");
622 }
623
ufs_sync_fs(struct super_block * sb,int wait)624 static int ufs_sync_fs(struct super_block *sb, int wait)
625 {
626 struct ufs_sb_private_info * uspi;
627 struct ufs_super_block_first * usb1;
628 struct ufs_super_block_third * usb3;
629 unsigned flags;
630
631 mutex_lock(&UFS_SB(sb)->s_lock);
632
633 UFSD("ENTER\n");
634
635 flags = UFS_SB(sb)->s_flags;
636 uspi = UFS_SB(sb)->s_uspi;
637 usb1 = ubh_get_usb_first(uspi);
638 usb3 = ubh_get_usb_third(uspi);
639
640 usb1->fs_time = ufs_get_seconds(sb);
641 if ((flags & UFS_ST_MASK) == UFS_ST_SUN ||
642 (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
643 (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
644 ufs_set_fs_state(sb, usb1, usb3,
645 UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
646 ufs_put_cstotal(sb);
647
648 UFSD("EXIT\n");
649 mutex_unlock(&UFS_SB(sb)->s_lock);
650
651 return 0;
652 }
653
delayed_sync_fs(struct work_struct * work)654 static void delayed_sync_fs(struct work_struct *work)
655 {
656 struct ufs_sb_info *sbi;
657
658 sbi = container_of(work, struct ufs_sb_info, sync_work.work);
659
660 spin_lock(&sbi->work_lock);
661 sbi->work_queued = 0;
662 spin_unlock(&sbi->work_lock);
663
664 ufs_sync_fs(sbi->sb, 1);
665 }
666
ufs_mark_sb_dirty(struct super_block * sb)667 void ufs_mark_sb_dirty(struct super_block *sb)
668 {
669 struct ufs_sb_info *sbi = UFS_SB(sb);
670 unsigned long delay;
671
672 spin_lock(&sbi->work_lock);
673 if (!sbi->work_queued) {
674 delay = msecs_to_jiffies(dirty_writeback_interval * 10);
675 queue_delayed_work(system_long_wq, &sbi->sync_work, delay);
676 sbi->work_queued = 1;
677 }
678 spin_unlock(&sbi->work_lock);
679 }
680
ufs_put_super(struct super_block * sb)681 static void ufs_put_super(struct super_block *sb)
682 {
683 struct ufs_sb_info * sbi = UFS_SB(sb);
684
685 UFSD("ENTER\n");
686
687 if (!sb_rdonly(sb))
688 ufs_put_super_internal(sb);
689 cancel_delayed_work_sync(&sbi->sync_work);
690
691 ubh_brelse_uspi (sbi->s_uspi);
692 kfree (sbi->s_uspi);
693 kfree (sbi);
694 sb->s_fs_info = NULL;
695 UFSD("EXIT\n");
696 return;
697 }
698
ufs_max_bytes(struct super_block * sb)699 static u64 ufs_max_bytes(struct super_block *sb)
700 {
701 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
702 int bits = uspi->s_apbshift;
703 u64 res;
704
705 if (bits > 21)
706 res = ~0ULL;
707 else
708 res = UFS_NDADDR + (1LL << bits) + (1LL << (2*bits)) +
709 (1LL << (3*bits));
710
711 if (res >= (MAX_LFS_FILESIZE >> uspi->s_bshift))
712 return MAX_LFS_FILESIZE;
713 return res << uspi->s_bshift;
714 }
715
ufs_fill_super(struct super_block * sb,struct fs_context * fc)716 static int ufs_fill_super(struct super_block *sb, struct fs_context *fc)
717 {
718 struct ufs_fs_context *ctx = fc->fs_private;
719 int silent = fc->sb_flags & SB_SILENT;
720 struct ufs_sb_info * sbi;
721 struct ufs_sb_private_info * uspi;
722 struct ufs_super_block_first * usb1;
723 struct ufs_super_block_second * usb2;
724 struct ufs_super_block_third * usb3;
725 struct ufs_buffer_head * ubh;
726 struct inode *inode;
727 unsigned block_size, super_block_size;
728 unsigned flags;
729 unsigned super_block_offset;
730 unsigned maxsymlen;
731 int ret = -EINVAL;
732
733 uspi = NULL;
734 ubh = NULL;
735 flags = 0;
736
737 UFSD("ENTER\n");
738
739 #ifndef CONFIG_UFS_FS_WRITE
740 if (!sb_rdonly(sb)) {
741 pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
742 return -EROFS;
743 }
744 #endif
745
746 sbi = kzalloc_obj(struct ufs_sb_info);
747 if (!sbi)
748 goto failed_nomem;
749 sb->s_fs_info = sbi;
750 sbi->sb = sb;
751
752 UFSD("flag %u\n", (int)(sb_rdonly(sb)));
753
754 mutex_init(&sbi->s_lock);
755 spin_lock_init(&sbi->work_lock);
756 INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs);
757
758 sbi->s_flavour = ctx->flavour;
759 sbi->s_on_err = ctx->on_err;
760
761 if (!sbi->s_flavour) {
762 if (!silent)
763 pr_err("You didn't specify the type of your ufs filesystem\n\n"
764 "mount -t ufs -o ufstype="
765 "sun|sunx86|44bsd|ufs2|5xbsd|old|hp|nextstep|nextstep-cd|openstep ...\n\n"
766 ">>>WARNING<<< Wrong ufstype may corrupt your filesystem, "
767 "default is ufstype=old\n");
768 sbi->s_flavour = UFS_MOUNT_UFSTYPE_OLD;
769 }
770
771 uspi = kzalloc_obj(struct ufs_sb_private_info);
772 sbi->s_uspi = uspi;
773 if (!uspi)
774 goto failed;
775 uspi->s_dirblksize = UFS_SECTOR_SIZE;
776 super_block_offset=UFS_SBLOCK;
777
778 sb->s_maxbytes = MAX_LFS_FILESIZE;
779
780 sb->s_time_gran = NSEC_PER_SEC;
781 sb->s_time_min = S32_MIN;
782 sb->s_time_max = S32_MAX;
783
784 switch (sbi->s_flavour) {
785 case UFS_MOUNT_UFSTYPE_44BSD:
786 UFSD("ufstype=44bsd\n");
787 uspi->s_fsize = block_size = 512;
788 uspi->s_fmask = ~(512 - 1);
789 uspi->s_fshift = 9;
790 uspi->s_sbsize = super_block_size = 1536;
791 uspi->s_sbbase = 0;
792 flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
793 break;
794 case UFS_MOUNT_UFSTYPE_UFS2:
795 UFSD("ufstype=ufs2\n");
796 super_block_offset=SBLOCK_UFS2;
797 uspi->s_fsize = block_size = 512;
798 uspi->s_fmask = ~(512 - 1);
799 uspi->s_fshift = 9;
800 uspi->s_sbsize = super_block_size = 1536;
801 uspi->s_sbbase = 0;
802 sb->s_time_gran = 1;
803 sb->s_time_min = S64_MIN;
804 sb->s_time_max = S64_MAX;
805 flags |= UFS_TYPE_UFS2 | UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
806 break;
807
808 case UFS_MOUNT_UFSTYPE_SUN:
809 UFSD("ufstype=sun\n");
810 uspi->s_fsize = block_size = 1024;
811 uspi->s_fmask = ~(1024 - 1);
812 uspi->s_fshift = 10;
813 uspi->s_sbsize = super_block_size = 2048;
814 uspi->s_sbbase = 0;
815 uspi->s_maxsymlinklen = 0; /* Not supported on disk */
816 flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUN | UFS_CG_SUN;
817 break;
818
819 case UFS_MOUNT_UFSTYPE_SUNOS:
820 UFSD("ufstype=sunos\n");
821 uspi->s_fsize = block_size = 1024;
822 uspi->s_fmask = ~(1024 - 1);
823 uspi->s_fshift = 10;
824 uspi->s_sbsize = 2048;
825 super_block_size = 2048;
826 uspi->s_sbbase = 0;
827 uspi->s_maxsymlinklen = 0; /* Not supported on disk */
828 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_SUNOS | UFS_CG_SUN;
829 break;
830
831 case UFS_MOUNT_UFSTYPE_SUNx86:
832 UFSD("ufstype=sunx86\n");
833 uspi->s_fsize = block_size = 1024;
834 uspi->s_fmask = ~(1024 - 1);
835 uspi->s_fshift = 10;
836 uspi->s_sbsize = super_block_size = 2048;
837 uspi->s_sbbase = 0;
838 uspi->s_maxsymlinklen = 0; /* Not supported on disk */
839 flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUNx86 | UFS_CG_SUN;
840 break;
841
842 case UFS_MOUNT_UFSTYPE_OLD:
843 UFSD("ufstype=old\n");
844 uspi->s_fsize = block_size = 1024;
845 uspi->s_fmask = ~(1024 - 1);
846 uspi->s_fshift = 10;
847 uspi->s_sbsize = super_block_size = 2048;
848 uspi->s_sbbase = 0;
849 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
850 if (!sb_rdonly(sb)) {
851 if (!silent)
852 pr_info("ufstype=old is supported read-only\n");
853 sb->s_flags |= SB_RDONLY;
854 }
855 break;
856
857 case UFS_MOUNT_UFSTYPE_NEXTSTEP:
858 UFSD("ufstype=nextstep\n");
859 uspi->s_fsize = block_size = 1024;
860 uspi->s_fmask = ~(1024 - 1);
861 uspi->s_fshift = 10;
862 uspi->s_sbsize = super_block_size = 2048;
863 uspi->s_sbbase = 0;
864 uspi->s_dirblksize = 1024;
865 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
866 if (!sb_rdonly(sb)) {
867 if (!silent)
868 pr_info("ufstype=nextstep is supported read-only\n");
869 sb->s_flags |= SB_RDONLY;
870 }
871 break;
872
873 case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD:
874 UFSD("ufstype=nextstep-cd\n");
875 uspi->s_fsize = block_size = 2048;
876 uspi->s_fmask = ~(2048 - 1);
877 uspi->s_fshift = 11;
878 uspi->s_sbsize = super_block_size = 2048;
879 uspi->s_sbbase = 0;
880 uspi->s_dirblksize = 1024;
881 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
882 if (!sb_rdonly(sb)) {
883 if (!silent)
884 pr_info("ufstype=nextstep-cd is supported read-only\n");
885 sb->s_flags |= SB_RDONLY;
886 }
887 break;
888
889 case UFS_MOUNT_UFSTYPE_OPENSTEP:
890 UFSD("ufstype=openstep\n");
891 uspi->s_fsize = block_size = 1024;
892 uspi->s_fmask = ~(1024 - 1);
893 uspi->s_fshift = 10;
894 uspi->s_sbsize = super_block_size = 2048;
895 uspi->s_sbbase = 0;
896 uspi->s_dirblksize = 1024;
897 flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
898 if (!sb_rdonly(sb)) {
899 if (!silent)
900 pr_info("ufstype=openstep is supported read-only\n");
901 sb->s_flags |= SB_RDONLY;
902 }
903 break;
904
905 case UFS_MOUNT_UFSTYPE_HP:
906 UFSD("ufstype=hp\n");
907 uspi->s_fsize = block_size = 1024;
908 uspi->s_fmask = ~(1024 - 1);
909 uspi->s_fshift = 10;
910 uspi->s_sbsize = super_block_size = 2048;
911 uspi->s_sbbase = 0;
912 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
913 if (!sb_rdonly(sb)) {
914 if (!silent)
915 pr_info("ufstype=hp is supported read-only\n");
916 sb->s_flags |= SB_RDONLY;
917 }
918 break;
919 default:
920 if (!silent)
921 pr_err("unknown ufstype\n");
922 goto failed;
923 }
924
925 again:
926 if (!sb_set_blocksize(sb, block_size)) {
927 pr_err("failed to set blocksize\n");
928 goto failed;
929 }
930
931 /*
932 * read ufs super block from device
933 */
934
935 ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size);
936
937 if (!ubh)
938 goto failed;
939
940 usb1 = ubh_get_usb_first(uspi);
941 usb2 = ubh_get_usb_second(uspi);
942 usb3 = ubh_get_usb_third(uspi);
943
944 /* Sort out mod used on SunOS 4.1.3 for fs_state */
945 uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);
946 if (((flags & UFS_ST_MASK) == UFS_ST_SUNOS) &&
947 (uspi->s_postblformat != UFS_42POSTBLFMT)) {
948 flags &= ~UFS_ST_MASK;
949 flags |= UFS_ST_SUN;
950 }
951
952 if ((flags & UFS_ST_MASK) == UFS_ST_44BSD &&
953 uspi->s_postblformat == UFS_42POSTBLFMT) {
954 if (!silent)
955 pr_err("this is not a 44bsd filesystem");
956 goto failed;
957 }
958
959 /*
960 * Check ufs magic number
961 */
962 sbi->s_bytesex = BYTESEX_LE;
963 switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
964 case UFS_MAGIC:
965 case UFS_MAGIC_BW:
966 case UFS2_MAGIC:
967 case UFS_MAGIC_LFN:
968 case UFS_MAGIC_FEA:
969 case UFS_MAGIC_4GB:
970 goto magic_found;
971 }
972 sbi->s_bytesex = BYTESEX_BE;
973 switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
974 case UFS_MAGIC:
975 case UFS_MAGIC_BW:
976 case UFS2_MAGIC:
977 case UFS_MAGIC_LFN:
978 case UFS_MAGIC_FEA:
979 case UFS_MAGIC_4GB:
980 goto magic_found;
981 }
982
983 if ((sbi->s_flavour == UFS_MOUNT_UFSTYPE_NEXTSTEP
984 || sbi->s_flavour == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD
985 || sbi->s_flavour == UFS_MOUNT_UFSTYPE_OPENSTEP)
986 && uspi->s_sbbase < 256) {
987 ubh_brelse_uspi(uspi);
988 ubh = NULL;
989 uspi->s_sbbase += 8;
990 goto again;
991 }
992 if (!silent)
993 pr_err("%s(): bad magic number\n", __func__);
994 goto failed;
995
996 magic_found:
997 /*
998 * Check block and fragment sizes
999 */
1000 uspi->s_bsize = fs32_to_cpu(sb, usb1->fs_bsize);
1001 uspi->s_fsize = fs32_to_cpu(sb, usb1->fs_fsize);
1002 uspi->s_sbsize = fs32_to_cpu(sb, usb1->fs_sbsize);
1003 uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
1004 uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
1005
1006 if (!is_power_of_2(uspi->s_fsize)) {
1007 pr_err("%s(): fragment size %u is not a power of 2\n",
1008 __func__, uspi->s_fsize);
1009 goto failed;
1010 }
1011 if (uspi->s_fsize < 512) {
1012 pr_err("%s(): fragment size %u is too small\n",
1013 __func__, uspi->s_fsize);
1014 goto failed;
1015 }
1016 if (uspi->s_fsize > 4096) {
1017 pr_err("%s(): fragment size %u is too large\n",
1018 __func__, uspi->s_fsize);
1019 goto failed;
1020 }
1021 if (!is_power_of_2(uspi->s_bsize)) {
1022 pr_err("%s(): block size %u is not a power of 2\n",
1023 __func__, uspi->s_bsize);
1024 goto failed;
1025 }
1026 if (uspi->s_bsize < 4096) {
1027 pr_err("%s(): block size %u is too small\n",
1028 __func__, uspi->s_bsize);
1029 goto failed;
1030 }
1031 if (uspi->s_bsize / uspi->s_fsize > 8) {
1032 pr_err("%s(): too many fragments per block (%u)\n",
1033 __func__, uspi->s_bsize / uspi->s_fsize);
1034 goto failed;
1035 }
1036 if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) {
1037 ubh_brelse_uspi(uspi);
1038 ubh = NULL;
1039 block_size = uspi->s_fsize;
1040 super_block_size = uspi->s_sbsize;
1041 UFSD("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size);
1042 goto again;
1043 }
1044
1045 sbi->s_flags = flags;/*after that line some functions use s_flags*/
1046 ufs_print_super_stuff(sb, usb1, usb2, usb3);
1047
1048 /*
1049 * Check, if file system was correctly unmounted.
1050 * If not, make it read only.
1051 */
1052 if (((flags & UFS_ST_MASK) == UFS_ST_44BSD) ||
1053 ((flags & UFS_ST_MASK) == UFS_ST_OLD) ||
1054 (((flags & UFS_ST_MASK) == UFS_ST_SUN ||
1055 (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
1056 (flags & UFS_ST_MASK) == UFS_ST_SUNx86) &&
1057 (ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time))))) {
1058 switch(usb1->fs_clean) {
1059 case UFS_FSCLEAN:
1060 UFSD("fs is clean\n");
1061 break;
1062 case UFS_FSSTABLE:
1063 UFSD("fs is stable\n");
1064 break;
1065 case UFS_FSLOG:
1066 UFSD("fs is logging fs\n");
1067 break;
1068 case UFS_FSOSF1:
1069 UFSD("fs is DEC OSF/1\n");
1070 break;
1071 case UFS_FSACTIVE:
1072 pr_err("%s(): fs is active\n", __func__);
1073 sb->s_flags |= SB_RDONLY;
1074 break;
1075 case UFS_FSBAD:
1076 pr_err("%s(): fs is bad\n", __func__);
1077 sb->s_flags |= SB_RDONLY;
1078 break;
1079 default:
1080 pr_err("%s(): can't grok fs_clean 0x%x\n",
1081 __func__, usb1->fs_clean);
1082 sb->s_flags |= SB_RDONLY;
1083 break;
1084 }
1085 } else {
1086 pr_err("%s(): fs needs fsck\n", __func__);
1087 sb->s_flags |= SB_RDONLY;
1088 }
1089
1090 /*
1091 * Read ufs_super_block into internal data structures
1092 */
1093 sb->s_op = &ufs_super_ops;
1094 sb->s_export_op = &ufs_export_ops;
1095
1096 sb->s_magic = fs32_to_cpu(sb, usb3->fs_magic);
1097
1098 uspi->s_sblkno = fs32_to_cpu(sb, usb1->fs_sblkno);
1099 uspi->s_cblkno = fs32_to_cpu(sb, usb1->fs_cblkno);
1100 uspi->s_iblkno = fs32_to_cpu(sb, usb1->fs_iblkno);
1101 uspi->s_dblkno = fs32_to_cpu(sb, usb1->fs_dblkno);
1102 uspi->s_cgoffset = fs32_to_cpu(sb, usb1->fs_cgoffset);
1103 uspi->s_cgmask = fs32_to_cpu(sb, usb1->fs_cgmask);
1104
1105 if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
1106 uspi->s_size = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size);
1107 uspi->s_dsize = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);
1108 } else {
1109 uspi->s_size = fs32_to_cpu(sb, usb1->fs_size);
1110 uspi->s_dsize = fs32_to_cpu(sb, usb1->fs_dsize);
1111 }
1112
1113 uspi->s_ncg = fs32_to_cpu(sb, usb1->fs_ncg);
1114 /* s_bsize already set */
1115 /* s_fsize already set */
1116 uspi->s_fpb = fs32_to_cpu(sb, usb1->fs_frag);
1117 uspi->s_minfree = fs32_to_cpu(sb, usb1->fs_minfree);
1118 uspi->s_bmask = fs32_to_cpu(sb, usb1->fs_bmask);
1119 uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
1120 uspi->s_bshift = fs32_to_cpu(sb, usb1->fs_bshift);
1121 uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
1122 UFSD("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi->s_bshift,
1123 uspi->s_fshift);
1124 uspi->s_fpbshift = fs32_to_cpu(sb, usb1->fs_fragshift);
1125 uspi->s_fsbtodb = fs32_to_cpu(sb, usb1->fs_fsbtodb);
1126 /* s_sbsize already set */
1127 uspi->s_csmask = fs32_to_cpu(sb, usb1->fs_csmask);
1128 uspi->s_csshift = fs32_to_cpu(sb, usb1->fs_csshift);
1129 uspi->s_nindir = fs32_to_cpu(sb, usb1->fs_nindir);
1130 uspi->s_inopb = fs32_to_cpu(sb, usb1->fs_inopb);
1131 uspi->s_nspf = fs32_to_cpu(sb, usb1->fs_nspf);
1132 uspi->s_npsect = ufs_get_fs_npsect(sb, usb1, usb3);
1133 uspi->s_interleave = fs32_to_cpu(sb, usb1->fs_interleave);
1134 uspi->s_trackskew = fs32_to_cpu(sb, usb1->fs_trackskew);
1135
1136 if (uspi->fs_magic == UFS2_MAGIC)
1137 uspi->s_csaddr = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_csaddr);
1138 else
1139 uspi->s_csaddr = fs32_to_cpu(sb, usb1->fs_csaddr);
1140
1141 uspi->s_cssize = fs32_to_cpu(sb, usb1->fs_cssize);
1142 uspi->s_cgsize = fs32_to_cpu(sb, usb1->fs_cgsize);
1143 uspi->s_ntrak = fs32_to_cpu(sb, usb1->fs_ntrak);
1144 uspi->s_nsect = fs32_to_cpu(sb, usb1->fs_nsect);
1145 uspi->s_spc = fs32_to_cpu(sb, usb1->fs_spc);
1146 uspi->s_ipg = fs32_to_cpu(sb, usb1->fs_ipg);
1147 uspi->s_fpg = fs32_to_cpu(sb, usb1->fs_fpg);
1148 uspi->s_cpc = fs32_to_cpu(sb, usb2->fs_un.fs_u1.fs_cpc);
1149 uspi->s_contigsumsize = fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_contigsumsize);
1150 uspi->s_qbmask = ufs_get_fs_qbmask(sb, usb3);
1151 uspi->s_qfmask = ufs_get_fs_qfmask(sb, usb3);
1152 uspi->s_nrpos = fs32_to_cpu(sb, usb3->fs_nrpos);
1153 uspi->s_postbloff = fs32_to_cpu(sb, usb3->fs_postbloff);
1154 uspi->s_rotbloff = fs32_to_cpu(sb, usb3->fs_rotbloff);
1155
1156 uspi->s_root_blocks = mul_u64_u32_div(uspi->s_dsize,
1157 uspi->s_minfree, 100);
1158 if (uspi->s_minfree <= 5) {
1159 uspi->s_time_to_space = ~0ULL;
1160 uspi->s_space_to_time = 0;
1161 usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTSPACE);
1162 } else {
1163 uspi->s_time_to_space = (uspi->s_root_blocks / 2) + 1;
1164 uspi->s_space_to_time = mul_u64_u32_div(uspi->s_dsize,
1165 uspi->s_minfree - 2, 100) - 1;
1166 }
1167
1168 /*
1169 * Compute another frequently used values
1170 */
1171 uspi->s_fpbmask = uspi->s_fpb - 1;
1172 if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
1173 uspi->s_apbshift = uspi->s_bshift - 3;
1174 else
1175 uspi->s_apbshift = uspi->s_bshift - 2;
1176
1177 uspi->s_apb = 1 << uspi->s_apbshift;
1178 uspi->s_apbmask = uspi->s_apb - 1;
1179 uspi->s_nspfshift = uspi->s_fshift - UFS_SECTOR_BITS;
1180 uspi->s_nspb = uspi->s_nspf << uspi->s_fpbshift;
1181 uspi->s_inopf = uspi->s_inopb >> uspi->s_fpbshift;
1182 uspi->s_bpf = uspi->s_fsize << 3;
1183 uspi->s_bpfshift = uspi->s_fshift + 3;
1184 uspi->s_bpfmask = uspi->s_bpf - 1;
1185 if (sbi->s_flavour == UFS_MOUNT_UFSTYPE_44BSD ||
1186 sbi->s_flavour == UFS_MOUNT_UFSTYPE_UFS2)
1187 uspi->s_maxsymlinklen =
1188 fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen);
1189
1190 if (uspi->fs_magic == UFS2_MAGIC)
1191 maxsymlen = 2 * 4 * (UFS_NDADDR + UFS_NINDIR);
1192 else
1193 maxsymlen = 4 * (UFS_NDADDR + UFS_NINDIR);
1194 if (uspi->s_maxsymlinklen > maxsymlen) {
1195 ufs_warning(sb, __func__, "ufs_read_super: excessive maximum "
1196 "fast symlink size (%u)\n", uspi->s_maxsymlinklen);
1197 uspi->s_maxsymlinklen = maxsymlen;
1198 }
1199 sb->s_maxbytes = ufs_max_bytes(sb);
1200 sb->s_max_links = UFS_LINK_MAX;
1201
1202 inode = ufs_iget(sb, UFS_ROOTINO);
1203 if (IS_ERR(inode)) {
1204 ret = PTR_ERR(inode);
1205 goto failed;
1206 }
1207 sb->s_root = d_make_root(inode);
1208 if (!sb->s_root) {
1209 ret = -ENOMEM;
1210 goto failed;
1211 }
1212
1213 ufs_setup_cstotal(sb);
1214 /*
1215 * Read cylinder group structures
1216 */
1217 if (!sb_rdonly(sb))
1218 if (!ufs_read_cylinder_structures(sb))
1219 goto failed;
1220
1221 UFSD("EXIT\n");
1222 return 0;
1223
1224 failed:
1225 if (ubh)
1226 ubh_brelse_uspi (uspi);
1227 kfree (uspi);
1228 kfree(sbi);
1229 sb->s_fs_info = NULL;
1230 UFSD("EXIT (FAILED)\n");
1231 return ret;
1232
1233 failed_nomem:
1234 UFSD("EXIT (NOMEM)\n");
1235 return -ENOMEM;
1236 }
1237
ufs_reconfigure(struct fs_context * fc)1238 static int ufs_reconfigure(struct fs_context *fc)
1239 {
1240 struct ufs_sb_private_info * uspi;
1241 struct ufs_super_block_first * usb1;
1242 struct ufs_super_block_third * usb3;
1243 struct ufs_fs_context *ctx = fc->fs_private;
1244 struct super_block *sb = fc->root->d_sb;
1245 unsigned int ufstype;
1246 unsigned int flags;
1247
1248 sync_filesystem(sb);
1249 mutex_lock(&UFS_SB(sb)->s_lock);
1250 uspi = UFS_SB(sb)->s_uspi;
1251 flags = UFS_SB(sb)->s_flags;
1252 usb1 = ubh_get_usb_first(uspi);
1253 usb3 = ubh_get_usb_third(uspi);
1254
1255 ufstype = UFS_SB(sb)->s_flavour;
1256
1257 if ((bool)(fc->sb_flags & SB_RDONLY) == sb_rdonly(sb)) {
1258 UFS_SB(sb)->s_on_err = ctx->on_err;
1259 mutex_unlock(&UFS_SB(sb)->s_lock);
1260 return 0;
1261 }
1262
1263 /*
1264 * fs was mouted as rw, remounting ro
1265 */
1266 if (fc->sb_flags & SB_RDONLY) {
1267 ufs_put_super_internal(sb);
1268 usb1->fs_time = ufs_get_seconds(sb);
1269 if ((flags & UFS_ST_MASK) == UFS_ST_SUN
1270 || (flags & UFS_ST_MASK) == UFS_ST_SUNOS
1271 || (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
1272 ufs_set_fs_state(sb, usb1, usb3,
1273 UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
1274 ubh_mark_buffer_dirty (USPI_UBH(uspi));
1275 sb->s_flags |= SB_RDONLY;
1276 } else {
1277 /*
1278 * fs was mounted as ro, remounting rw
1279 */
1280 #ifndef CONFIG_UFS_FS_WRITE
1281 pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
1282 mutex_unlock(&UFS_SB(sb)->s_lock);
1283 return -EINVAL;
1284 #else
1285 if (ufstype != UFS_MOUNT_UFSTYPE_SUN &&
1286 ufstype != UFS_MOUNT_UFSTYPE_SUNOS &&
1287 ufstype != UFS_MOUNT_UFSTYPE_44BSD &&
1288 ufstype != UFS_MOUNT_UFSTYPE_SUNx86 &&
1289 ufstype != UFS_MOUNT_UFSTYPE_UFS2) {
1290 pr_err("this ufstype is read-only supported\n");
1291 mutex_unlock(&UFS_SB(sb)->s_lock);
1292 return -EINVAL;
1293 }
1294 if (!ufs_read_cylinder_structures(sb)) {
1295 pr_err("failed during remounting\n");
1296 mutex_unlock(&UFS_SB(sb)->s_lock);
1297 return -EPERM;
1298 }
1299 sb->s_flags &= ~SB_RDONLY;
1300 #endif
1301 }
1302 UFS_SB(sb)->s_on_err = ctx->on_err;
1303 mutex_unlock(&UFS_SB(sb)->s_lock);
1304 return 0;
1305 }
1306
ufs_show_options(struct seq_file * seq,struct dentry * root)1307 static int ufs_show_options(struct seq_file *seq, struct dentry *root)
1308 {
1309 struct ufs_sb_info *sbi = UFS_SB(root->d_sb);
1310 unsigned mval = sbi->s_flavour;
1311 const struct constant_table *tp;
1312
1313 tp = ufs_param_ufstype;
1314 while (tp->value && tp->value != mval)
1315 ++tp;
1316 seq_printf(seq, ",ufstype=%s", tp->name);
1317
1318 tp = ufs_param_onerror;
1319 mval = sbi->s_on_err;
1320 while (tp->value && tp->value != mval)
1321 ++tp;
1322 seq_printf(seq, ",onerror=%s", tp->name);
1323
1324 return 0;
1325 }
1326
ufs_statfs(struct dentry * dentry,struct kstatfs * buf)1327 static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf)
1328 {
1329 struct super_block *sb = dentry->d_sb;
1330 struct ufs_sb_private_info *uspi= UFS_SB(sb)->s_uspi;
1331 unsigned flags = UFS_SB(sb)->s_flags;
1332 u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
1333
1334 mutex_lock(&UFS_SB(sb)->s_lock);
1335
1336 if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
1337 buf->f_type = UFS2_MAGIC;
1338 else
1339 buf->f_type = UFS_MAGIC;
1340
1341 buf->f_blocks = uspi->s_dsize;
1342 buf->f_bfree = ufs_freefrags(uspi);
1343 buf->f_ffree = uspi->cs_total.cs_nifree;
1344 buf->f_bsize = sb->s_blocksize;
1345 buf->f_bavail = (buf->f_bfree > uspi->s_root_blocks)
1346 ? (buf->f_bfree - uspi->s_root_blocks) : 0;
1347 buf->f_files = uspi->s_ncg * uspi->s_ipg;
1348 buf->f_namelen = UFS_MAXNAMLEN;
1349 buf->f_fsid = u64_to_fsid(id);
1350
1351 mutex_unlock(&UFS_SB(sb)->s_lock);
1352
1353 return 0;
1354 }
1355
1356 static struct kmem_cache * ufs_inode_cachep;
1357
ufs_alloc_inode(struct super_block * sb)1358 static struct inode *ufs_alloc_inode(struct super_block *sb)
1359 {
1360 struct ufs_inode_info *ei;
1361
1362 ei = alloc_inode_sb(sb, ufs_inode_cachep, GFP_NOFS);
1363 if (!ei)
1364 return NULL;
1365
1366 inode_set_iversion(&ei->vfs_inode, 1);
1367 seqlock_init(&ei->meta_lock);
1368 mutex_init(&ei->truncate_mutex);
1369 return &ei->vfs_inode;
1370 }
1371
ufs_free_in_core_inode(struct inode * inode)1372 static void ufs_free_in_core_inode(struct inode *inode)
1373 {
1374 kmem_cache_free(ufs_inode_cachep, UFS_I(inode));
1375 }
1376
init_once(void * foo)1377 static void init_once(void *foo)
1378 {
1379 struct ufs_inode_info *ei = (struct ufs_inode_info *) foo;
1380
1381 inode_init_once(&ei->vfs_inode);
1382 }
1383
init_inodecache(void)1384 static int __init init_inodecache(void)
1385 {
1386 ufs_inode_cachep = kmem_cache_create_usercopy("ufs_inode_cache",
1387 sizeof(struct ufs_inode_info), 0,
1388 (SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT),
1389 offsetof(struct ufs_inode_info, i_u1.i_symlink),
1390 sizeof_field(struct ufs_inode_info,
1391 i_u1.i_symlink),
1392 init_once);
1393 if (ufs_inode_cachep == NULL)
1394 return -ENOMEM;
1395 return 0;
1396 }
1397
destroy_inodecache(void)1398 static void destroy_inodecache(void)
1399 {
1400 /*
1401 * Make sure all delayed rcu free inodes are flushed before we
1402 * destroy cache.
1403 */
1404 rcu_barrier();
1405 kmem_cache_destroy(ufs_inode_cachep);
1406 }
1407
1408 static const struct super_operations ufs_super_ops = {
1409 .alloc_inode = ufs_alloc_inode,
1410 .free_inode = ufs_free_in_core_inode,
1411 .write_inode = ufs_write_inode,
1412 .evict_inode = ufs_evict_inode,
1413 .put_super = ufs_put_super,
1414 .sync_fs = ufs_sync_fs,
1415 .statfs = ufs_statfs,
1416 .show_options = ufs_show_options,
1417 };
1418
ufs_get_tree(struct fs_context * fc)1419 static int ufs_get_tree(struct fs_context *fc)
1420 {
1421 return get_tree_bdev(fc, ufs_fill_super);
1422 }
1423
ufs_free_fc(struct fs_context * fc)1424 static void ufs_free_fc(struct fs_context *fc)
1425 {
1426 kfree(fc->fs_private);
1427 }
1428
1429 static const struct fs_context_operations ufs_context_ops = {
1430 .parse_param = ufs_parse_param,
1431 .get_tree = ufs_get_tree,
1432 .reconfigure = ufs_reconfigure,
1433 .free = ufs_free_fc,
1434 };
1435
ufs_init_fs_context(struct fs_context * fc)1436 static int ufs_init_fs_context(struct fs_context *fc)
1437 {
1438 struct ufs_fs_context *ctx;
1439
1440 ctx = kzalloc_obj(*ctx);
1441 if (!ctx)
1442 return -ENOMEM;
1443
1444 if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
1445 struct super_block *sb = fc->root->d_sb;
1446 struct ufs_sb_info *sbi = UFS_SB(sb);
1447
1448 ctx->flavour = sbi->s_flavour;
1449 ctx->on_err = sbi->s_on_err;
1450 } else {
1451 ctx->flavour = 0;
1452 ctx->on_err = UFS_MOUNT_ONERROR_LOCK;
1453 }
1454
1455 fc->fs_private = ctx;
1456 fc->ops = &ufs_context_ops;
1457
1458 return 0;
1459 }
1460
1461 static struct file_system_type ufs_fs_type = {
1462 .owner = THIS_MODULE,
1463 .name = "ufs",
1464 .kill_sb = kill_block_super,
1465 .init_fs_context = ufs_init_fs_context,
1466 .parameters = ufs_param_spec,
1467 .fs_flags = FS_REQUIRES_DEV,
1468 };
1469 MODULE_ALIAS_FS("ufs");
1470
init_ufs_fs(void)1471 static int __init init_ufs_fs(void)
1472 {
1473 int err = init_inodecache();
1474 if (err)
1475 goto out1;
1476 err = register_filesystem(&ufs_fs_type);
1477 if (err)
1478 goto out;
1479 return 0;
1480 out:
1481 destroy_inodecache();
1482 out1:
1483 return err;
1484 }
1485
exit_ufs_fs(void)1486 static void __exit exit_ufs_fs(void)
1487 {
1488 unregister_filesystem(&ufs_fs_type);
1489 destroy_inodecache();
1490 }
1491
1492 module_init(init_ufs_fs)
1493 module_exit(exit_ufs_fs)
1494 MODULE_DESCRIPTION("UFS Filesystem");
1495 MODULE_LICENSE("GPL");
1496