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