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 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 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 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 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 */ 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 */ 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 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 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 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 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 */ 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 */ 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 */ 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 */ 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 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 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 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 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 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 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 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 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 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 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 1372 static void ufs_free_in_core_inode(struct inode *inode) 1373 { 1374 kmem_cache_free(ufs_inode_cachep, UFS_I(inode)); 1375 } 1376 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 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 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 1419 static int ufs_get_tree(struct fs_context *fc) 1420 { 1421 return get_tree_bdev(fc, ufs_fill_super); 1422 } 1423 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 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 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 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