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_array(uspi->s_ncg, sizeof(struct buffer_head *),
487 GFP_NOFS);
488 if (!sbi->s_ucg)
489 goto failed;
490 for (i = 0; i < uspi->s_ncg; i++)
491 sbi->s_ucg[i] = NULL;
492 for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
493 sbi->s_ucpi[i] = NULL;
494 sbi->s_cgno[i] = UFS_CGNO_EMPTY;
495 }
496 for (i = 0; i < uspi->s_ncg; i++) {
497 UFSD("read cg %u\n", i);
498 if (!(sbi->s_ucg[i] = sb_bread(sb, ufs_cgcmin(i))))
499 goto failed;
500 if (!ufs_cg_chkmagic (sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data))
501 goto failed;
502
503 ufs_print_cylinder_stuff(sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data);
504 }
505 for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
506 if (!(sbi->s_ucpi[i] = kmalloc (sizeof(struct ufs_cg_private_info), GFP_NOFS)))
507 goto failed;
508 sbi->s_cgno[i] = UFS_CGNO_EMPTY;
509 }
510 sbi->s_cg_loaded = 0;
511 UFSD("EXIT\n");
512 return 1;
513
514 failed:
515 kfree (base);
516 if (sbi->s_ucg) {
517 for (i = 0; i < uspi->s_ncg; i++)
518 if (sbi->s_ucg[i])
519 brelse (sbi->s_ucg[i]);
520 kfree (sbi->s_ucg);
521 for (i = 0; i < UFS_MAX_GROUP_LOADED; i++)
522 kfree (sbi->s_ucpi[i]);
523 }
524 UFSD("EXIT (FAILED)\n");
525 return 0;
526 }
527
528 /*
529 * Sync our internal copy of fs_cstotal with disk
530 */
ufs_put_cstotal(struct super_block * sb)531 static void ufs_put_cstotal(struct super_block *sb)
532 {
533 unsigned mtype = UFS_SB(sb)->s_flavour;
534 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
535 struct ufs_super_block_first *usb1;
536 struct ufs_super_block_second *usb2;
537 struct ufs_super_block_third *usb3;
538
539 UFSD("ENTER\n");
540 usb1 = ubh_get_usb_first(uspi);
541 usb2 = ubh_get_usb_second(uspi);
542 usb3 = ubh_get_usb_third(uspi);
543
544 if (mtype == UFS_MOUNT_UFSTYPE_UFS2) {
545 /*we have statistic in different place, then usual*/
546 usb2->fs_un.fs_u2.cs_ndir =
547 cpu_to_fs64(sb, uspi->cs_total.cs_ndir);
548 usb2->fs_un.fs_u2.cs_nbfree =
549 cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);
550 usb3->fs_un1.fs_u2.cs_nifree =
551 cpu_to_fs64(sb, uspi->cs_total.cs_nifree);
552 usb3->fs_un1.fs_u2.cs_nffree =
553 cpu_to_fs64(sb, uspi->cs_total.cs_nffree);
554 goto out;
555 }
556
557 if (mtype == UFS_MOUNT_UFSTYPE_44BSD &&
558 (usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) {
559 /* store stats in both old and new places */
560 usb2->fs_un.fs_u2.cs_ndir =
561 cpu_to_fs64(sb, uspi->cs_total.cs_ndir);
562 usb2->fs_un.fs_u2.cs_nbfree =
563 cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);
564 usb3->fs_un1.fs_u2.cs_nifree =
565 cpu_to_fs64(sb, uspi->cs_total.cs_nifree);
566 usb3->fs_un1.fs_u2.cs_nffree =
567 cpu_to_fs64(sb, uspi->cs_total.cs_nffree);
568 }
569 usb1->fs_cstotal.cs_ndir = cpu_to_fs32(sb, uspi->cs_total.cs_ndir);
570 usb1->fs_cstotal.cs_nbfree = cpu_to_fs32(sb, uspi->cs_total.cs_nbfree);
571 usb1->fs_cstotal.cs_nifree = cpu_to_fs32(sb, uspi->cs_total.cs_nifree);
572 usb1->fs_cstotal.cs_nffree = cpu_to_fs32(sb, uspi->cs_total.cs_nffree);
573 out:
574 ubh_mark_buffer_dirty(USPI_UBH(uspi));
575 ufs_print_super_stuff(sb, usb1, usb2, usb3);
576 UFSD("EXIT\n");
577 }
578
579 /**
580 * ufs_put_super_internal() - put on-disk intrenal structures
581 * @sb: pointer to super_block structure
582 * Put on-disk structures associated with cylinder groups
583 * and write them back to disk, also update cs_total on disk
584 */
ufs_put_super_internal(struct super_block * sb)585 static void ufs_put_super_internal(struct super_block *sb)
586 {
587 struct ufs_sb_info *sbi = UFS_SB(sb);
588 struct ufs_sb_private_info *uspi = sbi->s_uspi;
589 unsigned char * base, * space;
590 unsigned blks, size, i;
591
592
593 UFSD("ENTER\n");
594
595 ufs_put_cstotal(sb);
596 size = uspi->s_cssize;
597 blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
598 base = space = (char*) sbi->s_csp;
599 for (i = 0; i < blks; i++, space += uspi->s_fsize) {
600 struct buffer_head *bh = sb_bread(sb, uspi->s_csaddr + i);
601
602 if (unlikely(!bh)) { // better than an oops...
603 ufs_panic(sb, __func__,
604 "can't write part of cylinder group summary");
605 continue;
606 }
607 memcpy(bh->b_data, space, uspi->s_fsize);
608 mark_buffer_dirty(bh);
609 brelse(bh);
610 }
611 for (i = 0; i < sbi->s_cg_loaded; i++) {
612 ufs_put_cylinder (sb, i);
613 kfree (sbi->s_ucpi[i]);
614 }
615 for (; i < UFS_MAX_GROUP_LOADED; i++)
616 kfree (sbi->s_ucpi[i]);
617 for (i = 0; i < uspi->s_ncg; i++)
618 brelse (sbi->s_ucg[i]);
619 kfree (sbi->s_ucg);
620 kfree (base);
621
622 UFSD("EXIT\n");
623 }
624
ufs_sync_fs(struct super_block * sb,int wait)625 static int ufs_sync_fs(struct super_block *sb, int wait)
626 {
627 struct ufs_sb_private_info * uspi;
628 struct ufs_super_block_first * usb1;
629 struct ufs_super_block_third * usb3;
630 unsigned flags;
631
632 mutex_lock(&UFS_SB(sb)->s_lock);
633
634 UFSD("ENTER\n");
635
636 flags = UFS_SB(sb)->s_flags;
637 uspi = UFS_SB(sb)->s_uspi;
638 usb1 = ubh_get_usb_first(uspi);
639 usb3 = ubh_get_usb_third(uspi);
640
641 usb1->fs_time = ufs_get_seconds(sb);
642 if ((flags & UFS_ST_MASK) == UFS_ST_SUN ||
643 (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
644 (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
645 ufs_set_fs_state(sb, usb1, usb3,
646 UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
647 ufs_put_cstotal(sb);
648
649 UFSD("EXIT\n");
650 mutex_unlock(&UFS_SB(sb)->s_lock);
651
652 return 0;
653 }
654
delayed_sync_fs(struct work_struct * work)655 static void delayed_sync_fs(struct work_struct *work)
656 {
657 struct ufs_sb_info *sbi;
658
659 sbi = container_of(work, struct ufs_sb_info, sync_work.work);
660
661 spin_lock(&sbi->work_lock);
662 sbi->work_queued = 0;
663 spin_unlock(&sbi->work_lock);
664
665 ufs_sync_fs(sbi->sb, 1);
666 }
667
ufs_mark_sb_dirty(struct super_block * sb)668 void ufs_mark_sb_dirty(struct super_block *sb)
669 {
670 struct ufs_sb_info *sbi = UFS_SB(sb);
671 unsigned long delay;
672
673 spin_lock(&sbi->work_lock);
674 if (!sbi->work_queued) {
675 delay = msecs_to_jiffies(dirty_writeback_interval * 10);
676 queue_delayed_work(system_long_wq, &sbi->sync_work, delay);
677 sbi->work_queued = 1;
678 }
679 spin_unlock(&sbi->work_lock);
680 }
681
ufs_put_super(struct super_block * sb)682 static void ufs_put_super(struct super_block *sb)
683 {
684 struct ufs_sb_info * sbi = UFS_SB(sb);
685
686 UFSD("ENTER\n");
687
688 if (!sb_rdonly(sb))
689 ufs_put_super_internal(sb);
690 cancel_delayed_work_sync(&sbi->sync_work);
691
692 ubh_brelse_uspi (sbi->s_uspi);
693 kfree (sbi->s_uspi);
694 kfree (sbi);
695 sb->s_fs_info = NULL;
696 UFSD("EXIT\n");
697 return;
698 }
699
ufs_max_bytes(struct super_block * sb)700 static u64 ufs_max_bytes(struct super_block *sb)
701 {
702 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
703 int bits = uspi->s_apbshift;
704 u64 res;
705
706 if (bits > 21)
707 res = ~0ULL;
708 else
709 res = UFS_NDADDR + (1LL << bits) + (1LL << (2*bits)) +
710 (1LL << (3*bits));
711
712 if (res >= (MAX_LFS_FILESIZE >> uspi->s_bshift))
713 return MAX_LFS_FILESIZE;
714 return res << uspi->s_bshift;
715 }
716
ufs_fill_super(struct super_block * sb,struct fs_context * fc)717 static int ufs_fill_super(struct super_block *sb, struct fs_context *fc)
718 {
719 struct ufs_fs_context *ctx = fc->fs_private;
720 int silent = fc->sb_flags & SB_SILENT;
721 struct ufs_sb_info * sbi;
722 struct ufs_sb_private_info * uspi;
723 struct ufs_super_block_first * usb1;
724 struct ufs_super_block_second * usb2;
725 struct ufs_super_block_third * usb3;
726 struct ufs_buffer_head * ubh;
727 struct inode *inode;
728 unsigned block_size, super_block_size;
729 unsigned flags;
730 unsigned super_block_offset;
731 unsigned maxsymlen;
732 int ret = -EINVAL;
733
734 uspi = NULL;
735 ubh = NULL;
736 flags = 0;
737
738 UFSD("ENTER\n");
739
740 #ifndef CONFIG_UFS_FS_WRITE
741 if (!sb_rdonly(sb)) {
742 pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
743 return -EROFS;
744 }
745 #endif
746
747 sbi = kzalloc(sizeof(struct ufs_sb_info), GFP_KERNEL);
748 if (!sbi)
749 goto failed_nomem;
750 sb->s_fs_info = sbi;
751 sbi->sb = sb;
752
753 UFSD("flag %u\n", (int)(sb_rdonly(sb)));
754
755 mutex_init(&sbi->s_lock);
756 spin_lock_init(&sbi->work_lock);
757 INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs);
758
759 sbi->s_flavour = ctx->flavour;
760 sbi->s_on_err = ctx->on_err;
761
762 if (!sbi->s_flavour) {
763 if (!silent)
764 pr_err("You didn't specify the type of your ufs filesystem\n\n"
765 "mount -t ufs -o ufstype="
766 "sun|sunx86|44bsd|ufs2|5xbsd|old|hp|nextstep|nextstep-cd|openstep ...\n\n"
767 ">>>WARNING<<< Wrong ufstype may corrupt your filesystem, "
768 "default is ufstype=old\n");
769 sbi->s_flavour = UFS_MOUNT_UFSTYPE_OLD;
770 }
771
772 uspi = kzalloc(sizeof(struct ufs_sb_private_info), GFP_KERNEL);
773 sbi->s_uspi = uspi;
774 if (!uspi)
775 goto failed;
776 uspi->s_dirblksize = UFS_SECTOR_SIZE;
777 super_block_offset=UFS_SBLOCK;
778
779 sb->s_maxbytes = MAX_LFS_FILESIZE;
780
781 sb->s_time_gran = NSEC_PER_SEC;
782 sb->s_time_min = S32_MIN;
783 sb->s_time_max = S32_MAX;
784
785 switch (sbi->s_flavour) {
786 case UFS_MOUNT_UFSTYPE_44BSD:
787 UFSD("ufstype=44bsd\n");
788 uspi->s_fsize = block_size = 512;
789 uspi->s_fmask = ~(512 - 1);
790 uspi->s_fshift = 9;
791 uspi->s_sbsize = super_block_size = 1536;
792 uspi->s_sbbase = 0;
793 flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
794 break;
795 case UFS_MOUNT_UFSTYPE_UFS2:
796 UFSD("ufstype=ufs2\n");
797 super_block_offset=SBLOCK_UFS2;
798 uspi->s_fsize = block_size = 512;
799 uspi->s_fmask = ~(512 - 1);
800 uspi->s_fshift = 9;
801 uspi->s_sbsize = super_block_size = 1536;
802 uspi->s_sbbase = 0;
803 sb->s_time_gran = 1;
804 sb->s_time_min = S64_MIN;
805 sb->s_time_max = S64_MAX;
806 flags |= UFS_TYPE_UFS2 | UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
807 break;
808
809 case UFS_MOUNT_UFSTYPE_SUN:
810 UFSD("ufstype=sun\n");
811 uspi->s_fsize = block_size = 1024;
812 uspi->s_fmask = ~(1024 - 1);
813 uspi->s_fshift = 10;
814 uspi->s_sbsize = super_block_size = 2048;
815 uspi->s_sbbase = 0;
816 uspi->s_maxsymlinklen = 0; /* Not supported on disk */
817 flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUN | UFS_CG_SUN;
818 break;
819
820 case UFS_MOUNT_UFSTYPE_SUNOS:
821 UFSD("ufstype=sunos\n");
822 uspi->s_fsize = block_size = 1024;
823 uspi->s_fmask = ~(1024 - 1);
824 uspi->s_fshift = 10;
825 uspi->s_sbsize = 2048;
826 super_block_size = 2048;
827 uspi->s_sbbase = 0;
828 uspi->s_maxsymlinklen = 0; /* Not supported on disk */
829 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_SUNOS | UFS_CG_SUN;
830 break;
831
832 case UFS_MOUNT_UFSTYPE_SUNx86:
833 UFSD("ufstype=sunx86\n");
834 uspi->s_fsize = block_size = 1024;
835 uspi->s_fmask = ~(1024 - 1);
836 uspi->s_fshift = 10;
837 uspi->s_sbsize = super_block_size = 2048;
838 uspi->s_sbbase = 0;
839 uspi->s_maxsymlinklen = 0; /* Not supported on disk */
840 flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUNx86 | UFS_CG_SUN;
841 break;
842
843 case UFS_MOUNT_UFSTYPE_OLD:
844 UFSD("ufstype=old\n");
845 uspi->s_fsize = block_size = 1024;
846 uspi->s_fmask = ~(1024 - 1);
847 uspi->s_fshift = 10;
848 uspi->s_sbsize = super_block_size = 2048;
849 uspi->s_sbbase = 0;
850 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
851 if (!sb_rdonly(sb)) {
852 if (!silent)
853 pr_info("ufstype=old is supported read-only\n");
854 sb->s_flags |= SB_RDONLY;
855 }
856 break;
857
858 case UFS_MOUNT_UFSTYPE_NEXTSTEP:
859 UFSD("ufstype=nextstep\n");
860 uspi->s_fsize = block_size = 1024;
861 uspi->s_fmask = ~(1024 - 1);
862 uspi->s_fshift = 10;
863 uspi->s_sbsize = super_block_size = 2048;
864 uspi->s_sbbase = 0;
865 uspi->s_dirblksize = 1024;
866 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
867 if (!sb_rdonly(sb)) {
868 if (!silent)
869 pr_info("ufstype=nextstep is supported read-only\n");
870 sb->s_flags |= SB_RDONLY;
871 }
872 break;
873
874 case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD:
875 UFSD("ufstype=nextstep-cd\n");
876 uspi->s_fsize = block_size = 2048;
877 uspi->s_fmask = ~(2048 - 1);
878 uspi->s_fshift = 11;
879 uspi->s_sbsize = super_block_size = 2048;
880 uspi->s_sbbase = 0;
881 uspi->s_dirblksize = 1024;
882 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
883 if (!sb_rdonly(sb)) {
884 if (!silent)
885 pr_info("ufstype=nextstep-cd is supported read-only\n");
886 sb->s_flags |= SB_RDONLY;
887 }
888 break;
889
890 case UFS_MOUNT_UFSTYPE_OPENSTEP:
891 UFSD("ufstype=openstep\n");
892 uspi->s_fsize = block_size = 1024;
893 uspi->s_fmask = ~(1024 - 1);
894 uspi->s_fshift = 10;
895 uspi->s_sbsize = super_block_size = 2048;
896 uspi->s_sbbase = 0;
897 uspi->s_dirblksize = 1024;
898 flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
899 if (!sb_rdonly(sb)) {
900 if (!silent)
901 pr_info("ufstype=openstep is supported read-only\n");
902 sb->s_flags |= SB_RDONLY;
903 }
904 break;
905
906 case UFS_MOUNT_UFSTYPE_HP:
907 UFSD("ufstype=hp\n");
908 uspi->s_fsize = block_size = 1024;
909 uspi->s_fmask = ~(1024 - 1);
910 uspi->s_fshift = 10;
911 uspi->s_sbsize = super_block_size = 2048;
912 uspi->s_sbbase = 0;
913 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
914 if (!sb_rdonly(sb)) {
915 if (!silent)
916 pr_info("ufstype=hp is supported read-only\n");
917 sb->s_flags |= SB_RDONLY;
918 }
919 break;
920 default:
921 if (!silent)
922 pr_err("unknown ufstype\n");
923 goto failed;
924 }
925
926 again:
927 if (!sb_set_blocksize(sb, block_size)) {
928 pr_err("failed to set blocksize\n");
929 goto failed;
930 }
931
932 /*
933 * read ufs super block from device
934 */
935
936 ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size);
937
938 if (!ubh)
939 goto failed;
940
941 usb1 = ubh_get_usb_first(uspi);
942 usb2 = ubh_get_usb_second(uspi);
943 usb3 = ubh_get_usb_third(uspi);
944
945 /* Sort out mod used on SunOS 4.1.3 for fs_state */
946 uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);
947 if (((flags & UFS_ST_MASK) == UFS_ST_SUNOS) &&
948 (uspi->s_postblformat != UFS_42POSTBLFMT)) {
949 flags &= ~UFS_ST_MASK;
950 flags |= UFS_ST_SUN;
951 }
952
953 if ((flags & UFS_ST_MASK) == UFS_ST_44BSD &&
954 uspi->s_postblformat == UFS_42POSTBLFMT) {
955 if (!silent)
956 pr_err("this is not a 44bsd filesystem");
957 goto failed;
958 }
959
960 /*
961 * Check ufs magic number
962 */
963 sbi->s_bytesex = BYTESEX_LE;
964 switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
965 case UFS_MAGIC:
966 case UFS_MAGIC_BW:
967 case UFS2_MAGIC:
968 case UFS_MAGIC_LFN:
969 case UFS_MAGIC_FEA:
970 case UFS_MAGIC_4GB:
971 goto magic_found;
972 }
973 sbi->s_bytesex = BYTESEX_BE;
974 switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
975 case UFS_MAGIC:
976 case UFS_MAGIC_BW:
977 case UFS2_MAGIC:
978 case UFS_MAGIC_LFN:
979 case UFS_MAGIC_FEA:
980 case UFS_MAGIC_4GB:
981 goto magic_found;
982 }
983
984 if ((sbi->s_flavour == UFS_MOUNT_UFSTYPE_NEXTSTEP
985 || sbi->s_flavour == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD
986 || sbi->s_flavour == UFS_MOUNT_UFSTYPE_OPENSTEP)
987 && uspi->s_sbbase < 256) {
988 ubh_brelse_uspi(uspi);
989 ubh = NULL;
990 uspi->s_sbbase += 8;
991 goto again;
992 }
993 if (!silent)
994 pr_err("%s(): bad magic number\n", __func__);
995 goto failed;
996
997 magic_found:
998 /*
999 * Check block and fragment sizes
1000 */
1001 uspi->s_bsize = fs32_to_cpu(sb, usb1->fs_bsize);
1002 uspi->s_fsize = fs32_to_cpu(sb, usb1->fs_fsize);
1003 uspi->s_sbsize = fs32_to_cpu(sb, usb1->fs_sbsize);
1004 uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
1005 uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
1006
1007 if (!is_power_of_2(uspi->s_fsize)) {
1008 pr_err("%s(): fragment size %u is not a power of 2\n",
1009 __func__, uspi->s_fsize);
1010 goto failed;
1011 }
1012 if (uspi->s_fsize < 512) {
1013 pr_err("%s(): fragment size %u is too small\n",
1014 __func__, uspi->s_fsize);
1015 goto failed;
1016 }
1017 if (uspi->s_fsize > 4096) {
1018 pr_err("%s(): fragment size %u is too large\n",
1019 __func__, uspi->s_fsize);
1020 goto failed;
1021 }
1022 if (!is_power_of_2(uspi->s_bsize)) {
1023 pr_err("%s(): block size %u is not a power of 2\n",
1024 __func__, uspi->s_bsize);
1025 goto failed;
1026 }
1027 if (uspi->s_bsize < 4096) {
1028 pr_err("%s(): block size %u is too small\n",
1029 __func__, uspi->s_bsize);
1030 goto failed;
1031 }
1032 if (uspi->s_bsize / uspi->s_fsize > 8) {
1033 pr_err("%s(): too many fragments per block (%u)\n",
1034 __func__, uspi->s_bsize / uspi->s_fsize);
1035 goto failed;
1036 }
1037 if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) {
1038 ubh_brelse_uspi(uspi);
1039 ubh = NULL;
1040 block_size = uspi->s_fsize;
1041 super_block_size = uspi->s_sbsize;
1042 UFSD("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size);
1043 goto again;
1044 }
1045
1046 sbi->s_flags = flags;/*after that line some functions use s_flags*/
1047 ufs_print_super_stuff(sb, usb1, usb2, usb3);
1048
1049 /*
1050 * Check, if file system was correctly unmounted.
1051 * If not, make it read only.
1052 */
1053 if (((flags & UFS_ST_MASK) == UFS_ST_44BSD) ||
1054 ((flags & UFS_ST_MASK) == UFS_ST_OLD) ||
1055 (((flags & UFS_ST_MASK) == UFS_ST_SUN ||
1056 (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
1057 (flags & UFS_ST_MASK) == UFS_ST_SUNx86) &&
1058 (ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time))))) {
1059 switch(usb1->fs_clean) {
1060 case UFS_FSCLEAN:
1061 UFSD("fs is clean\n");
1062 break;
1063 case UFS_FSSTABLE:
1064 UFSD("fs is stable\n");
1065 break;
1066 case UFS_FSLOG:
1067 UFSD("fs is logging fs\n");
1068 break;
1069 case UFS_FSOSF1:
1070 UFSD("fs is DEC OSF/1\n");
1071 break;
1072 case UFS_FSACTIVE:
1073 pr_err("%s(): fs is active\n", __func__);
1074 sb->s_flags |= SB_RDONLY;
1075 break;
1076 case UFS_FSBAD:
1077 pr_err("%s(): fs is bad\n", __func__);
1078 sb->s_flags |= SB_RDONLY;
1079 break;
1080 default:
1081 pr_err("%s(): can't grok fs_clean 0x%x\n",
1082 __func__, usb1->fs_clean);
1083 sb->s_flags |= SB_RDONLY;
1084 break;
1085 }
1086 } else {
1087 pr_err("%s(): fs needs fsck\n", __func__);
1088 sb->s_flags |= SB_RDONLY;
1089 }
1090
1091 /*
1092 * Read ufs_super_block into internal data structures
1093 */
1094 sb->s_op = &ufs_super_ops;
1095 sb->s_export_op = &ufs_export_ops;
1096
1097 sb->s_magic = fs32_to_cpu(sb, usb3->fs_magic);
1098
1099 uspi->s_sblkno = fs32_to_cpu(sb, usb1->fs_sblkno);
1100 uspi->s_cblkno = fs32_to_cpu(sb, usb1->fs_cblkno);
1101 uspi->s_iblkno = fs32_to_cpu(sb, usb1->fs_iblkno);
1102 uspi->s_dblkno = fs32_to_cpu(sb, usb1->fs_dblkno);
1103 uspi->s_cgoffset = fs32_to_cpu(sb, usb1->fs_cgoffset);
1104 uspi->s_cgmask = fs32_to_cpu(sb, usb1->fs_cgmask);
1105
1106 if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
1107 uspi->s_size = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size);
1108 uspi->s_dsize = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);
1109 } else {
1110 uspi->s_size = fs32_to_cpu(sb, usb1->fs_size);
1111 uspi->s_dsize = fs32_to_cpu(sb, usb1->fs_dsize);
1112 }
1113
1114 uspi->s_ncg = fs32_to_cpu(sb, usb1->fs_ncg);
1115 /* s_bsize already set */
1116 /* s_fsize already set */
1117 uspi->s_fpb = fs32_to_cpu(sb, usb1->fs_frag);
1118 uspi->s_minfree = fs32_to_cpu(sb, usb1->fs_minfree);
1119 uspi->s_bmask = fs32_to_cpu(sb, usb1->fs_bmask);
1120 uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
1121 uspi->s_bshift = fs32_to_cpu(sb, usb1->fs_bshift);
1122 uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
1123 UFSD("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi->s_bshift,
1124 uspi->s_fshift);
1125 uspi->s_fpbshift = fs32_to_cpu(sb, usb1->fs_fragshift);
1126 uspi->s_fsbtodb = fs32_to_cpu(sb, usb1->fs_fsbtodb);
1127 /* s_sbsize already set */
1128 uspi->s_csmask = fs32_to_cpu(sb, usb1->fs_csmask);
1129 uspi->s_csshift = fs32_to_cpu(sb, usb1->fs_csshift);
1130 uspi->s_nindir = fs32_to_cpu(sb, usb1->fs_nindir);
1131 uspi->s_inopb = fs32_to_cpu(sb, usb1->fs_inopb);
1132 uspi->s_nspf = fs32_to_cpu(sb, usb1->fs_nspf);
1133 uspi->s_npsect = ufs_get_fs_npsect(sb, usb1, usb3);
1134 uspi->s_interleave = fs32_to_cpu(sb, usb1->fs_interleave);
1135 uspi->s_trackskew = fs32_to_cpu(sb, usb1->fs_trackskew);
1136
1137 if (uspi->fs_magic == UFS2_MAGIC)
1138 uspi->s_csaddr = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_csaddr);
1139 else
1140 uspi->s_csaddr = fs32_to_cpu(sb, usb1->fs_csaddr);
1141
1142 uspi->s_cssize = fs32_to_cpu(sb, usb1->fs_cssize);
1143 uspi->s_cgsize = fs32_to_cpu(sb, usb1->fs_cgsize);
1144 uspi->s_ntrak = fs32_to_cpu(sb, usb1->fs_ntrak);
1145 uspi->s_nsect = fs32_to_cpu(sb, usb1->fs_nsect);
1146 uspi->s_spc = fs32_to_cpu(sb, usb1->fs_spc);
1147 uspi->s_ipg = fs32_to_cpu(sb, usb1->fs_ipg);
1148 uspi->s_fpg = fs32_to_cpu(sb, usb1->fs_fpg);
1149 uspi->s_cpc = fs32_to_cpu(sb, usb2->fs_un.fs_u1.fs_cpc);
1150 uspi->s_contigsumsize = fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_contigsumsize);
1151 uspi->s_qbmask = ufs_get_fs_qbmask(sb, usb3);
1152 uspi->s_qfmask = ufs_get_fs_qfmask(sb, usb3);
1153 uspi->s_nrpos = fs32_to_cpu(sb, usb3->fs_nrpos);
1154 uspi->s_postbloff = fs32_to_cpu(sb, usb3->fs_postbloff);
1155 uspi->s_rotbloff = fs32_to_cpu(sb, usb3->fs_rotbloff);
1156
1157 uspi->s_root_blocks = mul_u64_u32_div(uspi->s_dsize,
1158 uspi->s_minfree, 100);
1159 if (uspi->s_minfree <= 5) {
1160 uspi->s_time_to_space = ~0ULL;
1161 uspi->s_space_to_time = 0;
1162 usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTSPACE);
1163 } else {
1164 uspi->s_time_to_space = (uspi->s_root_blocks / 2) + 1;
1165 uspi->s_space_to_time = mul_u64_u32_div(uspi->s_dsize,
1166 uspi->s_minfree - 2, 100) - 1;
1167 }
1168
1169 /*
1170 * Compute another frequently used values
1171 */
1172 uspi->s_fpbmask = uspi->s_fpb - 1;
1173 if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
1174 uspi->s_apbshift = uspi->s_bshift - 3;
1175 else
1176 uspi->s_apbshift = uspi->s_bshift - 2;
1177
1178 uspi->s_apb = 1 << uspi->s_apbshift;
1179 uspi->s_apbmask = uspi->s_apb - 1;
1180 uspi->s_nspfshift = uspi->s_fshift - UFS_SECTOR_BITS;
1181 uspi->s_nspb = uspi->s_nspf << uspi->s_fpbshift;
1182 uspi->s_inopf = uspi->s_inopb >> uspi->s_fpbshift;
1183 uspi->s_bpf = uspi->s_fsize << 3;
1184 uspi->s_bpfshift = uspi->s_fshift + 3;
1185 uspi->s_bpfmask = uspi->s_bpf - 1;
1186 if (sbi->s_flavour == UFS_MOUNT_UFSTYPE_44BSD ||
1187 sbi->s_flavour == UFS_MOUNT_UFSTYPE_UFS2)
1188 uspi->s_maxsymlinklen =
1189 fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen);
1190
1191 if (uspi->fs_magic == UFS2_MAGIC)
1192 maxsymlen = 2 * 4 * (UFS_NDADDR + UFS_NINDIR);
1193 else
1194 maxsymlen = 4 * (UFS_NDADDR + UFS_NINDIR);
1195 if (uspi->s_maxsymlinklen > maxsymlen) {
1196 ufs_warning(sb, __func__, "ufs_read_super: excessive maximum "
1197 "fast symlink size (%u)\n", uspi->s_maxsymlinklen);
1198 uspi->s_maxsymlinklen = maxsymlen;
1199 }
1200 sb->s_maxbytes = ufs_max_bytes(sb);
1201 sb->s_max_links = UFS_LINK_MAX;
1202
1203 inode = ufs_iget(sb, UFS_ROOTINO);
1204 if (IS_ERR(inode)) {
1205 ret = PTR_ERR(inode);
1206 goto failed;
1207 }
1208 sb->s_root = d_make_root(inode);
1209 if (!sb->s_root) {
1210 ret = -ENOMEM;
1211 goto failed;
1212 }
1213
1214 ufs_setup_cstotal(sb);
1215 /*
1216 * Read cylinder group structures
1217 */
1218 if (!sb_rdonly(sb))
1219 if (!ufs_read_cylinder_structures(sb))
1220 goto failed;
1221
1222 UFSD("EXIT\n");
1223 return 0;
1224
1225 failed:
1226 if (ubh)
1227 ubh_brelse_uspi (uspi);
1228 kfree (uspi);
1229 kfree(sbi);
1230 sb->s_fs_info = NULL;
1231 UFSD("EXIT (FAILED)\n");
1232 return ret;
1233
1234 failed_nomem:
1235 UFSD("EXIT (NOMEM)\n");
1236 return -ENOMEM;
1237 }
1238
ufs_reconfigure(struct fs_context * fc)1239 static int ufs_reconfigure(struct fs_context *fc)
1240 {
1241 struct ufs_sb_private_info * uspi;
1242 struct ufs_super_block_first * usb1;
1243 struct ufs_super_block_third * usb3;
1244 struct ufs_fs_context *ctx = fc->fs_private;
1245 struct super_block *sb = fc->root->d_sb;
1246 unsigned int ufstype;
1247 unsigned int flags;
1248
1249 sync_filesystem(sb);
1250 mutex_lock(&UFS_SB(sb)->s_lock);
1251 uspi = UFS_SB(sb)->s_uspi;
1252 flags = UFS_SB(sb)->s_flags;
1253 usb1 = ubh_get_usb_first(uspi);
1254 usb3 = ubh_get_usb_third(uspi);
1255
1256 ufstype = UFS_SB(sb)->s_flavour;
1257
1258 if ((bool)(fc->sb_flags & SB_RDONLY) == sb_rdonly(sb)) {
1259 UFS_SB(sb)->s_on_err = ctx->on_err;
1260 mutex_unlock(&UFS_SB(sb)->s_lock);
1261 return 0;
1262 }
1263
1264 /*
1265 * fs was mouted as rw, remounting ro
1266 */
1267 if (fc->sb_flags & SB_RDONLY) {
1268 ufs_put_super_internal(sb);
1269 usb1->fs_time = ufs_get_seconds(sb);
1270 if ((flags & UFS_ST_MASK) == UFS_ST_SUN
1271 || (flags & UFS_ST_MASK) == UFS_ST_SUNOS
1272 || (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
1273 ufs_set_fs_state(sb, usb1, usb3,
1274 UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
1275 ubh_mark_buffer_dirty (USPI_UBH(uspi));
1276 sb->s_flags |= SB_RDONLY;
1277 } else {
1278 /*
1279 * fs was mounted as ro, remounting rw
1280 */
1281 #ifndef CONFIG_UFS_FS_WRITE
1282 pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
1283 mutex_unlock(&UFS_SB(sb)->s_lock);
1284 return -EINVAL;
1285 #else
1286 if (ufstype != UFS_MOUNT_UFSTYPE_SUN &&
1287 ufstype != UFS_MOUNT_UFSTYPE_SUNOS &&
1288 ufstype != UFS_MOUNT_UFSTYPE_44BSD &&
1289 ufstype != UFS_MOUNT_UFSTYPE_SUNx86 &&
1290 ufstype != UFS_MOUNT_UFSTYPE_UFS2) {
1291 pr_err("this ufstype is read-only supported\n");
1292 mutex_unlock(&UFS_SB(sb)->s_lock);
1293 return -EINVAL;
1294 }
1295 if (!ufs_read_cylinder_structures(sb)) {
1296 pr_err("failed during remounting\n");
1297 mutex_unlock(&UFS_SB(sb)->s_lock);
1298 return -EPERM;
1299 }
1300 sb->s_flags &= ~SB_RDONLY;
1301 #endif
1302 }
1303 UFS_SB(sb)->s_on_err = ctx->on_err;
1304 mutex_unlock(&UFS_SB(sb)->s_lock);
1305 return 0;
1306 }
1307
ufs_show_options(struct seq_file * seq,struct dentry * root)1308 static int ufs_show_options(struct seq_file *seq, struct dentry *root)
1309 {
1310 struct ufs_sb_info *sbi = UFS_SB(root->d_sb);
1311 unsigned mval = sbi->s_flavour;
1312 const struct constant_table *tp;
1313
1314 tp = ufs_param_ufstype;
1315 while (tp->value && tp->value != mval)
1316 ++tp;
1317 seq_printf(seq, ",ufstype=%s", tp->name);
1318
1319 tp = ufs_param_onerror;
1320 mval = sbi->s_on_err;
1321 while (tp->value && tp->value != mval)
1322 ++tp;
1323 seq_printf(seq, ",onerror=%s", tp->name);
1324
1325 return 0;
1326 }
1327
ufs_statfs(struct dentry * dentry,struct kstatfs * buf)1328 static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf)
1329 {
1330 struct super_block *sb = dentry->d_sb;
1331 struct ufs_sb_private_info *uspi= UFS_SB(sb)->s_uspi;
1332 unsigned flags = UFS_SB(sb)->s_flags;
1333 u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
1334
1335 mutex_lock(&UFS_SB(sb)->s_lock);
1336
1337 if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
1338 buf->f_type = UFS2_MAGIC;
1339 else
1340 buf->f_type = UFS_MAGIC;
1341
1342 buf->f_blocks = uspi->s_dsize;
1343 buf->f_bfree = ufs_freefrags(uspi);
1344 buf->f_ffree = uspi->cs_total.cs_nifree;
1345 buf->f_bsize = sb->s_blocksize;
1346 buf->f_bavail = (buf->f_bfree > uspi->s_root_blocks)
1347 ? (buf->f_bfree - uspi->s_root_blocks) : 0;
1348 buf->f_files = uspi->s_ncg * uspi->s_ipg;
1349 buf->f_namelen = UFS_MAXNAMLEN;
1350 buf->f_fsid = u64_to_fsid(id);
1351
1352 mutex_unlock(&UFS_SB(sb)->s_lock);
1353
1354 return 0;
1355 }
1356
1357 static struct kmem_cache * ufs_inode_cachep;
1358
ufs_alloc_inode(struct super_block * sb)1359 static struct inode *ufs_alloc_inode(struct super_block *sb)
1360 {
1361 struct ufs_inode_info *ei;
1362
1363 ei = alloc_inode_sb(sb, ufs_inode_cachep, GFP_NOFS);
1364 if (!ei)
1365 return NULL;
1366
1367 inode_set_iversion(&ei->vfs_inode, 1);
1368 seqlock_init(&ei->meta_lock);
1369 mutex_init(&ei->truncate_mutex);
1370 return &ei->vfs_inode;
1371 }
1372
ufs_free_in_core_inode(struct inode * inode)1373 static void ufs_free_in_core_inode(struct inode *inode)
1374 {
1375 kmem_cache_free(ufs_inode_cachep, UFS_I(inode));
1376 }
1377
init_once(void * foo)1378 static void init_once(void *foo)
1379 {
1380 struct ufs_inode_info *ei = (struct ufs_inode_info *) foo;
1381
1382 inode_init_once(&ei->vfs_inode);
1383 }
1384
init_inodecache(void)1385 static int __init init_inodecache(void)
1386 {
1387 ufs_inode_cachep = kmem_cache_create_usercopy("ufs_inode_cache",
1388 sizeof(struct ufs_inode_info), 0,
1389 (SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT),
1390 offsetof(struct ufs_inode_info, i_u1.i_symlink),
1391 sizeof_field(struct ufs_inode_info,
1392 i_u1.i_symlink),
1393 init_once);
1394 if (ufs_inode_cachep == NULL)
1395 return -ENOMEM;
1396 return 0;
1397 }
1398
destroy_inodecache(void)1399 static void destroy_inodecache(void)
1400 {
1401 /*
1402 * Make sure all delayed rcu free inodes are flushed before we
1403 * destroy cache.
1404 */
1405 rcu_barrier();
1406 kmem_cache_destroy(ufs_inode_cachep);
1407 }
1408
1409 static const struct super_operations ufs_super_ops = {
1410 .alloc_inode = ufs_alloc_inode,
1411 .free_inode = ufs_free_in_core_inode,
1412 .write_inode = ufs_write_inode,
1413 .evict_inode = ufs_evict_inode,
1414 .put_super = ufs_put_super,
1415 .sync_fs = ufs_sync_fs,
1416 .statfs = ufs_statfs,
1417 .show_options = ufs_show_options,
1418 };
1419
ufs_get_tree(struct fs_context * fc)1420 static int ufs_get_tree(struct fs_context *fc)
1421 {
1422 return get_tree_bdev(fc, ufs_fill_super);
1423 }
1424
ufs_free_fc(struct fs_context * fc)1425 static void ufs_free_fc(struct fs_context *fc)
1426 {
1427 kfree(fc->fs_private);
1428 }
1429
1430 static const struct fs_context_operations ufs_context_ops = {
1431 .parse_param = ufs_parse_param,
1432 .get_tree = ufs_get_tree,
1433 .reconfigure = ufs_reconfigure,
1434 .free = ufs_free_fc,
1435 };
1436
ufs_init_fs_context(struct fs_context * fc)1437 static int ufs_init_fs_context(struct fs_context *fc)
1438 {
1439 struct ufs_fs_context *ctx;
1440
1441 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
1442 if (!ctx)
1443 return -ENOMEM;
1444
1445 if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
1446 struct super_block *sb = fc->root->d_sb;
1447 struct ufs_sb_info *sbi = UFS_SB(sb);
1448
1449 ctx->flavour = sbi->s_flavour;
1450 ctx->on_err = sbi->s_on_err;
1451 } else {
1452 ctx->flavour = 0;
1453 ctx->on_err = UFS_MOUNT_ONERROR_LOCK;
1454 }
1455
1456 fc->fs_private = ctx;
1457 fc->ops = &ufs_context_ops;
1458
1459 return 0;
1460 }
1461
1462 static struct file_system_type ufs_fs_type = {
1463 .owner = THIS_MODULE,
1464 .name = "ufs",
1465 .kill_sb = kill_block_super,
1466 .init_fs_context = ufs_init_fs_context,
1467 .parameters = ufs_param_spec,
1468 .fs_flags = FS_REQUIRES_DEV,
1469 };
1470 MODULE_ALIAS_FS("ufs");
1471
init_ufs_fs(void)1472 static int __init init_ufs_fs(void)
1473 {
1474 int err = init_inodecache();
1475 if (err)
1476 goto out1;
1477 err = register_filesystem(&ufs_fs_type);
1478 if (err)
1479 goto out;
1480 return 0;
1481 out:
1482 destroy_inodecache();
1483 out1:
1484 return err;
1485 }
1486
exit_ufs_fs(void)1487 static void __exit exit_ufs_fs(void)
1488 {
1489 unregister_filesystem(&ufs_fs_type);
1490 destroy_inodecache();
1491 }
1492
1493 module_init(init_ufs_fs)
1494 module_exit(exit_ufs_fs)
1495 MODULE_DESCRIPTION("UFS Filesystem");
1496 MODULE_LICENSE("GPL");
1497