0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034
0035
0036
0037
0038
0039
0040
0041
0042
0043
0044
0045
0046
0047
0048
0049
0050
0051
0052
0053
0054
0055
0056
0057
0058
0059
0060
0061
0062
0063
0064
0065
0066
0067
0068
0069 #include <linux/exportfs.h>
0070 #include <linux/module.h>
0071 #include <linux/bitops.h>
0072
0073 #include <linux/stdarg.h>
0074
0075 #include <linux/uaccess.h>
0076
0077 #include <linux/errno.h>
0078 #include <linux/fs.h>
0079 #include <linux/slab.h>
0080 #include <linux/time.h>
0081 #include <linux/stat.h>
0082 #include <linux/string.h>
0083 #include <linux/blkdev.h>
0084 #include <linux/backing-dev.h>
0085 #include <linux/init.h>
0086 #include <linux/parser.h>
0087 #include <linux/buffer_head.h>
0088 #include <linux/vfs.h>
0089 #include <linux/log2.h>
0090 #include <linux/mount.h>
0091 #include <linux/seq_file.h>
0092 #include <linux/iversion.h>
0093
0094 #include "ufs_fs.h"
0095 #include "ufs.h"
0096 #include "swab.h"
0097 #include "util.h"
0098
0099 static struct inode *ufs_nfs_get_inode(struct super_block *sb, u64 ino, u32 generation)
0100 {
0101 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
0102 struct inode *inode;
0103
0104 if (ino < UFS_ROOTINO || ino > (u64)uspi->s_ncg * uspi->s_ipg)
0105 return ERR_PTR(-ESTALE);
0106
0107 inode = ufs_iget(sb, ino);
0108 if (IS_ERR(inode))
0109 return ERR_CAST(inode);
0110 if (generation && inode->i_generation != generation) {
0111 iput(inode);
0112 return ERR_PTR(-ESTALE);
0113 }
0114 return inode;
0115 }
0116
0117 static struct dentry *ufs_fh_to_dentry(struct super_block *sb, struct fid *fid,
0118 int fh_len, int fh_type)
0119 {
0120 return generic_fh_to_dentry(sb, fid, fh_len, fh_type, ufs_nfs_get_inode);
0121 }
0122
0123 static struct dentry *ufs_fh_to_parent(struct super_block *sb, struct fid *fid,
0124 int fh_len, int fh_type)
0125 {
0126 return generic_fh_to_parent(sb, fid, fh_len, fh_type, ufs_nfs_get_inode);
0127 }
0128
0129 static struct dentry *ufs_get_parent(struct dentry *child)
0130 {
0131 ino_t ino;
0132
0133 ino = ufs_inode_by_name(d_inode(child), &dotdot_name);
0134 if (!ino)
0135 return ERR_PTR(-ENOENT);
0136 return d_obtain_alias(ufs_iget(child->d_sb, ino));
0137 }
0138
0139 static const struct export_operations ufs_export_ops = {
0140 .fh_to_dentry = ufs_fh_to_dentry,
0141 .fh_to_parent = ufs_fh_to_parent,
0142 .get_parent = ufs_get_parent,
0143 };
0144
0145 #ifdef CONFIG_UFS_DEBUG
0146
0147
0148
0149 static void ufs_print_super_stuff(struct super_block *sb,
0150 struct ufs_super_block_first *usb1,
0151 struct ufs_super_block_second *usb2,
0152 struct ufs_super_block_third *usb3)
0153 {
0154 u32 magic = fs32_to_cpu(sb, usb3->fs_magic);
0155
0156 pr_debug("ufs_print_super_stuff\n");
0157 pr_debug(" magic: 0x%x\n", magic);
0158 if (fs32_to_cpu(sb, usb3->fs_magic) == UFS2_MAGIC) {
0159 pr_debug(" fs_size: %llu\n", (unsigned long long)
0160 fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size));
0161 pr_debug(" fs_dsize: %llu\n", (unsigned long long)
0162 fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize));
0163 pr_debug(" bsize: %u\n",
0164 fs32_to_cpu(sb, usb1->fs_bsize));
0165 pr_debug(" fsize: %u\n",
0166 fs32_to_cpu(sb, usb1->fs_fsize));
0167 pr_debug(" fs_volname: %s\n", usb2->fs_un.fs_u2.fs_volname);
0168 pr_debug(" fs_sblockloc: %llu\n", (unsigned long long)
0169 fs64_to_cpu(sb, usb2->fs_un.fs_u2.fs_sblockloc));
0170 pr_debug(" cs_ndir(No of dirs): %llu\n", (unsigned long long)
0171 fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir));
0172 pr_debug(" cs_nbfree(No of free blocks): %llu\n",
0173 (unsigned long long)
0174 fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_nbfree));
0175 pr_info(" cs_nifree(Num of free inodes): %llu\n",
0176 (unsigned long long)
0177 fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nifree));
0178 pr_info(" cs_nffree(Num of free frags): %llu\n",
0179 (unsigned long long)
0180 fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nffree));
0181 pr_info(" fs_maxsymlinklen: %u\n",
0182 fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen));
0183 } else {
0184 pr_debug(" sblkno: %u\n", fs32_to_cpu(sb, usb1->fs_sblkno));
0185 pr_debug(" cblkno: %u\n", fs32_to_cpu(sb, usb1->fs_cblkno));
0186 pr_debug(" iblkno: %u\n", fs32_to_cpu(sb, usb1->fs_iblkno));
0187 pr_debug(" dblkno: %u\n", fs32_to_cpu(sb, usb1->fs_dblkno));
0188 pr_debug(" cgoffset: %u\n",
0189 fs32_to_cpu(sb, usb1->fs_cgoffset));
0190 pr_debug(" ~cgmask: 0x%x\n",
0191 ~fs32_to_cpu(sb, usb1->fs_cgmask));
0192 pr_debug(" size: %u\n", fs32_to_cpu(sb, usb1->fs_size));
0193 pr_debug(" dsize: %u\n", fs32_to_cpu(sb, usb1->fs_dsize));
0194 pr_debug(" ncg: %u\n", fs32_to_cpu(sb, usb1->fs_ncg));
0195 pr_debug(" bsize: %u\n", fs32_to_cpu(sb, usb1->fs_bsize));
0196 pr_debug(" fsize: %u\n", fs32_to_cpu(sb, usb1->fs_fsize));
0197 pr_debug(" frag: %u\n", fs32_to_cpu(sb, usb1->fs_frag));
0198 pr_debug(" fragshift: %u\n",
0199 fs32_to_cpu(sb, usb1->fs_fragshift));
0200 pr_debug(" ~fmask: %u\n", ~fs32_to_cpu(sb, usb1->fs_fmask));
0201 pr_debug(" fshift: %u\n", fs32_to_cpu(sb, usb1->fs_fshift));
0202 pr_debug(" sbsize: %u\n", fs32_to_cpu(sb, usb1->fs_sbsize));
0203 pr_debug(" spc: %u\n", fs32_to_cpu(sb, usb1->fs_spc));
0204 pr_debug(" cpg: %u\n", fs32_to_cpu(sb, usb1->fs_cpg));
0205 pr_debug(" ipg: %u\n", fs32_to_cpu(sb, usb1->fs_ipg));
0206 pr_debug(" fpg: %u\n", fs32_to_cpu(sb, usb1->fs_fpg));
0207 pr_debug(" csaddr: %u\n", fs32_to_cpu(sb, usb1->fs_csaddr));
0208 pr_debug(" cssize: %u\n", fs32_to_cpu(sb, usb1->fs_cssize));
0209 pr_debug(" cgsize: %u\n", fs32_to_cpu(sb, usb1->fs_cgsize));
0210 pr_debug(" fstodb: %u\n",
0211 fs32_to_cpu(sb, usb1->fs_fsbtodb));
0212 pr_debug(" nrpos: %u\n", fs32_to_cpu(sb, usb3->fs_nrpos));
0213 pr_debug(" ndir %u\n",
0214 fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir));
0215 pr_debug(" nifree %u\n",
0216 fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree));
0217 pr_debug(" nbfree %u\n",
0218 fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree));
0219 pr_debug(" nffree %u\n",
0220 fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree));
0221 }
0222 pr_debug("\n");
0223 }
0224
0225
0226
0227
0228 static void ufs_print_cylinder_stuff(struct super_block *sb,
0229 struct ufs_cylinder_group *cg)
0230 {
0231 pr_debug("\nufs_print_cylinder_stuff\n");
0232 pr_debug("size of ucg: %zu\n", sizeof(struct ufs_cylinder_group));
0233 pr_debug(" magic: %x\n", fs32_to_cpu(sb, cg->cg_magic));
0234 pr_debug(" time: %u\n", fs32_to_cpu(sb, cg->cg_time));
0235 pr_debug(" cgx: %u\n", fs32_to_cpu(sb, cg->cg_cgx));
0236 pr_debug(" ncyl: %u\n", fs16_to_cpu(sb, cg->cg_ncyl));
0237 pr_debug(" niblk: %u\n", fs16_to_cpu(sb, cg->cg_niblk));
0238 pr_debug(" ndblk: %u\n", fs32_to_cpu(sb, cg->cg_ndblk));
0239 pr_debug(" cs_ndir: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_ndir));
0240 pr_debug(" cs_nbfree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nbfree));
0241 pr_debug(" cs_nifree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nifree));
0242 pr_debug(" cs_nffree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nffree));
0243 pr_debug(" rotor: %u\n", fs32_to_cpu(sb, cg->cg_rotor));
0244 pr_debug(" frotor: %u\n", fs32_to_cpu(sb, cg->cg_frotor));
0245 pr_debug(" irotor: %u\n", fs32_to_cpu(sb, cg->cg_irotor));
0246 pr_debug(" frsum: %u, %u, %u, %u, %u, %u, %u, %u\n",
0247 fs32_to_cpu(sb, cg->cg_frsum[0]), fs32_to_cpu(sb, cg->cg_frsum[1]),
0248 fs32_to_cpu(sb, cg->cg_frsum[2]), fs32_to_cpu(sb, cg->cg_frsum[3]),
0249 fs32_to_cpu(sb, cg->cg_frsum[4]), fs32_to_cpu(sb, cg->cg_frsum[5]),
0250 fs32_to_cpu(sb, cg->cg_frsum[6]), fs32_to_cpu(sb, cg->cg_frsum[7]));
0251 pr_debug(" btotoff: %u\n", fs32_to_cpu(sb, cg->cg_btotoff));
0252 pr_debug(" boff: %u\n", fs32_to_cpu(sb, cg->cg_boff));
0253 pr_debug(" iuseoff: %u\n", fs32_to_cpu(sb, cg->cg_iusedoff));
0254 pr_debug(" freeoff: %u\n", fs32_to_cpu(sb, cg->cg_freeoff));
0255 pr_debug(" nextfreeoff: %u\n", fs32_to_cpu(sb, cg->cg_nextfreeoff));
0256 pr_debug(" clustersumoff %u\n",
0257 fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clustersumoff));
0258 pr_debug(" clusteroff %u\n",
0259 fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clusteroff));
0260 pr_debug(" nclusterblks %u\n",
0261 fs32_to_cpu(sb, cg->cg_u.cg_44.cg_nclusterblks));
0262 pr_debug("\n");
0263 }
0264 #else
0265 # define ufs_print_super_stuff(sb, usb1, usb2, usb3)
0266 # define ufs_print_cylinder_stuff(sb, cg)
0267 #endif
0268
0269 static const struct super_operations ufs_super_ops;
0270
0271 void ufs_error (struct super_block * sb, const char * function,
0272 const char * fmt, ...)
0273 {
0274 struct ufs_sb_private_info * uspi;
0275 struct ufs_super_block_first * usb1;
0276 struct va_format vaf;
0277 va_list args;
0278
0279 uspi = UFS_SB(sb)->s_uspi;
0280 usb1 = ubh_get_usb_first(uspi);
0281
0282 if (!sb_rdonly(sb)) {
0283 usb1->fs_clean = UFS_FSBAD;
0284 ubh_mark_buffer_dirty(USPI_UBH(uspi));
0285 ufs_mark_sb_dirty(sb);
0286 sb->s_flags |= SB_RDONLY;
0287 }
0288 va_start(args, fmt);
0289 vaf.fmt = fmt;
0290 vaf.va = &args;
0291 switch (UFS_SB(sb)->s_mount_opt & UFS_MOUNT_ONERROR) {
0292 case UFS_MOUNT_ONERROR_PANIC:
0293 panic("panic (device %s): %s: %pV\n",
0294 sb->s_id, function, &vaf);
0295
0296 case UFS_MOUNT_ONERROR_LOCK:
0297 case UFS_MOUNT_ONERROR_UMOUNT:
0298 case UFS_MOUNT_ONERROR_REPAIR:
0299 pr_crit("error (device %s): %s: %pV\n",
0300 sb->s_id, function, &vaf);
0301 }
0302 va_end(args);
0303 }
0304
0305 void ufs_panic (struct super_block * sb, const char * function,
0306 const char * fmt, ...)
0307 {
0308 struct ufs_sb_private_info * uspi;
0309 struct ufs_super_block_first * usb1;
0310 struct va_format vaf;
0311 va_list args;
0312
0313 uspi = UFS_SB(sb)->s_uspi;
0314 usb1 = ubh_get_usb_first(uspi);
0315
0316 if (!sb_rdonly(sb)) {
0317 usb1->fs_clean = UFS_FSBAD;
0318 ubh_mark_buffer_dirty(USPI_UBH(uspi));
0319 ufs_mark_sb_dirty(sb);
0320 }
0321 va_start(args, fmt);
0322 vaf.fmt = fmt;
0323 vaf.va = &args;
0324 sb->s_flags |= SB_RDONLY;
0325 pr_crit("panic (device %s): %s: %pV\n",
0326 sb->s_id, function, &vaf);
0327 va_end(args);
0328 }
0329
0330 void ufs_warning (struct super_block * sb, const char * function,
0331 const char * fmt, ...)
0332 {
0333 struct va_format vaf;
0334 va_list args;
0335
0336 va_start(args, fmt);
0337 vaf.fmt = fmt;
0338 vaf.va = &args;
0339 pr_warn("(device %s): %s: %pV\n",
0340 sb->s_id, function, &vaf);
0341 va_end(args);
0342 }
0343
0344 enum {
0345 Opt_type_old = UFS_MOUNT_UFSTYPE_OLD,
0346 Opt_type_sunx86 = UFS_MOUNT_UFSTYPE_SUNx86,
0347 Opt_type_sun = UFS_MOUNT_UFSTYPE_SUN,
0348 Opt_type_sunos = UFS_MOUNT_UFSTYPE_SUNOS,
0349 Opt_type_44bsd = UFS_MOUNT_UFSTYPE_44BSD,
0350 Opt_type_ufs2 = UFS_MOUNT_UFSTYPE_UFS2,
0351 Opt_type_hp = UFS_MOUNT_UFSTYPE_HP,
0352 Opt_type_nextstepcd = UFS_MOUNT_UFSTYPE_NEXTSTEP_CD,
0353 Opt_type_nextstep = UFS_MOUNT_UFSTYPE_NEXTSTEP,
0354 Opt_type_openstep = UFS_MOUNT_UFSTYPE_OPENSTEP,
0355 Opt_onerror_panic = UFS_MOUNT_ONERROR_PANIC,
0356 Opt_onerror_lock = UFS_MOUNT_ONERROR_LOCK,
0357 Opt_onerror_umount = UFS_MOUNT_ONERROR_UMOUNT,
0358 Opt_onerror_repair = UFS_MOUNT_ONERROR_REPAIR,
0359 Opt_err
0360 };
0361
0362 static const match_table_t tokens = {
0363 {Opt_type_old, "ufstype=old"},
0364 {Opt_type_sunx86, "ufstype=sunx86"},
0365 {Opt_type_sun, "ufstype=sun"},
0366 {Opt_type_sunos, "ufstype=sunos"},
0367 {Opt_type_44bsd, "ufstype=44bsd"},
0368 {Opt_type_ufs2, "ufstype=ufs2"},
0369 {Opt_type_ufs2, "ufstype=5xbsd"},
0370 {Opt_type_hp, "ufstype=hp"},
0371 {Opt_type_nextstepcd, "ufstype=nextstep-cd"},
0372 {Opt_type_nextstep, "ufstype=nextstep"},
0373 {Opt_type_openstep, "ufstype=openstep"},
0374
0375 {Opt_onerror_panic, "onerror=panic"},
0376 {Opt_onerror_lock, "onerror=lock"},
0377 {Opt_onerror_umount, "onerror=umount"},
0378 {Opt_onerror_repair, "onerror=repair"},
0379 {Opt_err, NULL}
0380 };
0381
0382 static int ufs_parse_options (char * options, unsigned * mount_options)
0383 {
0384 char * p;
0385
0386 UFSD("ENTER\n");
0387
0388 if (!options)
0389 return 1;
0390
0391 while ((p = strsep(&options, ",")) != NULL) {
0392 substring_t args[MAX_OPT_ARGS];
0393 int token;
0394 if (!*p)
0395 continue;
0396
0397 token = match_token(p, tokens, args);
0398 switch (token) {
0399 case Opt_type_old:
0400 ufs_clear_opt (*mount_options, UFSTYPE);
0401 ufs_set_opt (*mount_options, UFSTYPE_OLD);
0402 break;
0403 case Opt_type_sunx86:
0404 ufs_clear_opt (*mount_options, UFSTYPE);
0405 ufs_set_opt (*mount_options, UFSTYPE_SUNx86);
0406 break;
0407 case Opt_type_sun:
0408 ufs_clear_opt (*mount_options, UFSTYPE);
0409 ufs_set_opt (*mount_options, UFSTYPE_SUN);
0410 break;
0411 case Opt_type_sunos:
0412 ufs_clear_opt(*mount_options, UFSTYPE);
0413 ufs_set_opt(*mount_options, UFSTYPE_SUNOS);
0414 break;
0415 case Opt_type_44bsd:
0416 ufs_clear_opt (*mount_options, UFSTYPE);
0417 ufs_set_opt (*mount_options, UFSTYPE_44BSD);
0418 break;
0419 case Opt_type_ufs2:
0420 ufs_clear_opt(*mount_options, UFSTYPE);
0421 ufs_set_opt(*mount_options, UFSTYPE_UFS2);
0422 break;
0423 case Opt_type_hp:
0424 ufs_clear_opt (*mount_options, UFSTYPE);
0425 ufs_set_opt (*mount_options, UFSTYPE_HP);
0426 break;
0427 case Opt_type_nextstepcd:
0428 ufs_clear_opt (*mount_options, UFSTYPE);
0429 ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP_CD);
0430 break;
0431 case Opt_type_nextstep:
0432 ufs_clear_opt (*mount_options, UFSTYPE);
0433 ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP);
0434 break;
0435 case Opt_type_openstep:
0436 ufs_clear_opt (*mount_options, UFSTYPE);
0437 ufs_set_opt (*mount_options, UFSTYPE_OPENSTEP);
0438 break;
0439 case Opt_onerror_panic:
0440 ufs_clear_opt (*mount_options, ONERROR);
0441 ufs_set_opt (*mount_options, ONERROR_PANIC);
0442 break;
0443 case Opt_onerror_lock:
0444 ufs_clear_opt (*mount_options, ONERROR);
0445 ufs_set_opt (*mount_options, ONERROR_LOCK);
0446 break;
0447 case Opt_onerror_umount:
0448 ufs_clear_opt (*mount_options, ONERROR);
0449 ufs_set_opt (*mount_options, ONERROR_UMOUNT);
0450 break;
0451 case Opt_onerror_repair:
0452 pr_err("Unable to do repair on error, will lock lock instead\n");
0453 ufs_clear_opt (*mount_options, ONERROR);
0454 ufs_set_opt (*mount_options, ONERROR_REPAIR);
0455 break;
0456 default:
0457 pr_err("Invalid option: \"%s\" or missing value\n", p);
0458 return 0;
0459 }
0460 }
0461 return 1;
0462 }
0463
0464
0465
0466
0467
0468
0469 static void ufs_setup_cstotal(struct super_block *sb)
0470 {
0471 struct ufs_sb_info *sbi = UFS_SB(sb);
0472 struct ufs_sb_private_info *uspi = sbi->s_uspi;
0473 struct ufs_super_block_first *usb1;
0474 struct ufs_super_block_second *usb2;
0475 struct ufs_super_block_third *usb3;
0476 unsigned mtype = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE;
0477
0478 UFSD("ENTER, mtype=%u\n", mtype);
0479 usb1 = ubh_get_usb_first(uspi);
0480 usb2 = ubh_get_usb_second(uspi);
0481 usb3 = ubh_get_usb_third(uspi);
0482
0483 if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&
0484 (usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) ||
0485 mtype == UFS_MOUNT_UFSTYPE_UFS2) {
0486
0487 uspi->cs_total.cs_ndir = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir);
0488 uspi->cs_total.cs_nbfree = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_nbfree);
0489 uspi->cs_total.cs_nifree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nifree);
0490 uspi->cs_total.cs_nffree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nffree);
0491 } else {
0492 uspi->cs_total.cs_ndir = fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir);
0493 uspi->cs_total.cs_nbfree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree);
0494 uspi->cs_total.cs_nifree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree);
0495 uspi->cs_total.cs_nffree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree);
0496 }
0497 UFSD("EXIT\n");
0498 }
0499
0500
0501
0502
0503 static int ufs_read_cylinder_structures(struct super_block *sb)
0504 {
0505 struct ufs_sb_info *sbi = UFS_SB(sb);
0506 struct ufs_sb_private_info *uspi = sbi->s_uspi;
0507 struct ufs_buffer_head * ubh;
0508 unsigned char * base, * space;
0509 unsigned size, blks, i;
0510
0511 UFSD("ENTER\n");
0512
0513
0514
0515
0516
0517 size = uspi->s_cssize;
0518 blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
0519 base = space = kmalloc(size, GFP_NOFS);
0520 if (!base)
0521 goto failed;
0522 sbi->s_csp = (struct ufs_csum *)space;
0523 for (i = 0; i < blks; i += uspi->s_fpb) {
0524 size = uspi->s_bsize;
0525 if (i + uspi->s_fpb > blks)
0526 size = (blks - i) * uspi->s_fsize;
0527
0528 ubh = ubh_bread(sb, uspi->s_csaddr + i, size);
0529
0530 if (!ubh)
0531 goto failed;
0532
0533 ubh_ubhcpymem (space, ubh, size);
0534
0535 space += size;
0536 ubh_brelse (ubh);
0537 ubh = NULL;
0538 }
0539
0540
0541
0542
0543
0544 sbi->s_ucg = kmalloc_array(uspi->s_ncg, sizeof(struct buffer_head *),
0545 GFP_NOFS);
0546 if (!sbi->s_ucg)
0547 goto failed;
0548 for (i = 0; i < uspi->s_ncg; i++)
0549 sbi->s_ucg[i] = NULL;
0550 for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
0551 sbi->s_ucpi[i] = NULL;
0552 sbi->s_cgno[i] = UFS_CGNO_EMPTY;
0553 }
0554 for (i = 0; i < uspi->s_ncg; i++) {
0555 UFSD("read cg %u\n", i);
0556 if (!(sbi->s_ucg[i] = sb_bread(sb, ufs_cgcmin(i))))
0557 goto failed;
0558 if (!ufs_cg_chkmagic (sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data))
0559 goto failed;
0560
0561 ufs_print_cylinder_stuff(sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data);
0562 }
0563 for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
0564 if (!(sbi->s_ucpi[i] = kmalloc (sizeof(struct ufs_cg_private_info), GFP_NOFS)))
0565 goto failed;
0566 sbi->s_cgno[i] = UFS_CGNO_EMPTY;
0567 }
0568 sbi->s_cg_loaded = 0;
0569 UFSD("EXIT\n");
0570 return 1;
0571
0572 failed:
0573 kfree (base);
0574 if (sbi->s_ucg) {
0575 for (i = 0; i < uspi->s_ncg; i++)
0576 if (sbi->s_ucg[i])
0577 brelse (sbi->s_ucg[i]);
0578 kfree (sbi->s_ucg);
0579 for (i = 0; i < UFS_MAX_GROUP_LOADED; i++)
0580 kfree (sbi->s_ucpi[i]);
0581 }
0582 UFSD("EXIT (FAILED)\n");
0583 return 0;
0584 }
0585
0586
0587
0588
0589 static void ufs_put_cstotal(struct super_block *sb)
0590 {
0591 unsigned mtype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE;
0592 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
0593 struct ufs_super_block_first *usb1;
0594 struct ufs_super_block_second *usb2;
0595 struct ufs_super_block_third *usb3;
0596
0597 UFSD("ENTER\n");
0598 usb1 = ubh_get_usb_first(uspi);
0599 usb2 = ubh_get_usb_second(uspi);
0600 usb3 = ubh_get_usb_third(uspi);
0601
0602 if (mtype == UFS_MOUNT_UFSTYPE_UFS2) {
0603
0604 usb2->fs_un.fs_u2.cs_ndir =
0605 cpu_to_fs64(sb, uspi->cs_total.cs_ndir);
0606 usb2->fs_un.fs_u2.cs_nbfree =
0607 cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);
0608 usb3->fs_un1.fs_u2.cs_nifree =
0609 cpu_to_fs64(sb, uspi->cs_total.cs_nifree);
0610 usb3->fs_un1.fs_u2.cs_nffree =
0611 cpu_to_fs64(sb, uspi->cs_total.cs_nffree);
0612 goto out;
0613 }
0614
0615 if (mtype == UFS_MOUNT_UFSTYPE_44BSD &&
0616 (usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) {
0617
0618 usb2->fs_un.fs_u2.cs_ndir =
0619 cpu_to_fs64(sb, uspi->cs_total.cs_ndir);
0620 usb2->fs_un.fs_u2.cs_nbfree =
0621 cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);
0622 usb3->fs_un1.fs_u2.cs_nifree =
0623 cpu_to_fs64(sb, uspi->cs_total.cs_nifree);
0624 usb3->fs_un1.fs_u2.cs_nffree =
0625 cpu_to_fs64(sb, uspi->cs_total.cs_nffree);
0626 }
0627 usb1->fs_cstotal.cs_ndir = cpu_to_fs32(sb, uspi->cs_total.cs_ndir);
0628 usb1->fs_cstotal.cs_nbfree = cpu_to_fs32(sb, uspi->cs_total.cs_nbfree);
0629 usb1->fs_cstotal.cs_nifree = cpu_to_fs32(sb, uspi->cs_total.cs_nifree);
0630 usb1->fs_cstotal.cs_nffree = cpu_to_fs32(sb, uspi->cs_total.cs_nffree);
0631 out:
0632 ubh_mark_buffer_dirty(USPI_UBH(uspi));
0633 ufs_print_super_stuff(sb, usb1, usb2, usb3);
0634 UFSD("EXIT\n");
0635 }
0636
0637
0638
0639
0640
0641
0642
0643 static void ufs_put_super_internal(struct super_block *sb)
0644 {
0645 struct ufs_sb_info *sbi = UFS_SB(sb);
0646 struct ufs_sb_private_info *uspi = sbi->s_uspi;
0647 struct ufs_buffer_head * ubh;
0648 unsigned char * base, * space;
0649 unsigned blks, size, i;
0650
0651
0652 UFSD("ENTER\n");
0653
0654 ufs_put_cstotal(sb);
0655 size = uspi->s_cssize;
0656 blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
0657 base = space = (char*) sbi->s_csp;
0658 for (i = 0; i < blks; i += uspi->s_fpb) {
0659 size = uspi->s_bsize;
0660 if (i + uspi->s_fpb > blks)
0661 size = (blks - i) * uspi->s_fsize;
0662
0663 ubh = ubh_bread(sb, uspi->s_csaddr + i, size);
0664
0665 ubh_memcpyubh (ubh, space, size);
0666 space += size;
0667 ubh_mark_buffer_uptodate (ubh, 1);
0668 ubh_mark_buffer_dirty (ubh);
0669 ubh_brelse (ubh);
0670 }
0671 for (i = 0; i < sbi->s_cg_loaded; i++) {
0672 ufs_put_cylinder (sb, i);
0673 kfree (sbi->s_ucpi[i]);
0674 }
0675 for (; i < UFS_MAX_GROUP_LOADED; i++)
0676 kfree (sbi->s_ucpi[i]);
0677 for (i = 0; i < uspi->s_ncg; i++)
0678 brelse (sbi->s_ucg[i]);
0679 kfree (sbi->s_ucg);
0680 kfree (base);
0681
0682 UFSD("EXIT\n");
0683 }
0684
0685 static int ufs_sync_fs(struct super_block *sb, int wait)
0686 {
0687 struct ufs_sb_private_info * uspi;
0688 struct ufs_super_block_first * usb1;
0689 struct ufs_super_block_third * usb3;
0690 unsigned flags;
0691
0692 mutex_lock(&UFS_SB(sb)->s_lock);
0693
0694 UFSD("ENTER\n");
0695
0696 flags = UFS_SB(sb)->s_flags;
0697 uspi = UFS_SB(sb)->s_uspi;
0698 usb1 = ubh_get_usb_first(uspi);
0699 usb3 = ubh_get_usb_third(uspi);
0700
0701 usb1->fs_time = ufs_get_seconds(sb);
0702 if ((flags & UFS_ST_MASK) == UFS_ST_SUN ||
0703 (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
0704 (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
0705 ufs_set_fs_state(sb, usb1, usb3,
0706 UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
0707 ufs_put_cstotal(sb);
0708
0709 UFSD("EXIT\n");
0710 mutex_unlock(&UFS_SB(sb)->s_lock);
0711
0712 return 0;
0713 }
0714
0715 static void delayed_sync_fs(struct work_struct *work)
0716 {
0717 struct ufs_sb_info *sbi;
0718
0719 sbi = container_of(work, struct ufs_sb_info, sync_work.work);
0720
0721 spin_lock(&sbi->work_lock);
0722 sbi->work_queued = 0;
0723 spin_unlock(&sbi->work_lock);
0724
0725 ufs_sync_fs(sbi->sb, 1);
0726 }
0727
0728 void ufs_mark_sb_dirty(struct super_block *sb)
0729 {
0730 struct ufs_sb_info *sbi = UFS_SB(sb);
0731 unsigned long delay;
0732
0733 spin_lock(&sbi->work_lock);
0734 if (!sbi->work_queued) {
0735 delay = msecs_to_jiffies(dirty_writeback_interval * 10);
0736 queue_delayed_work(system_long_wq, &sbi->sync_work, delay);
0737 sbi->work_queued = 1;
0738 }
0739 spin_unlock(&sbi->work_lock);
0740 }
0741
0742 static void ufs_put_super(struct super_block *sb)
0743 {
0744 struct ufs_sb_info * sbi = UFS_SB(sb);
0745
0746 UFSD("ENTER\n");
0747
0748 if (!sb_rdonly(sb))
0749 ufs_put_super_internal(sb);
0750 cancel_delayed_work_sync(&sbi->sync_work);
0751
0752 ubh_brelse_uspi (sbi->s_uspi);
0753 kfree (sbi->s_uspi);
0754 kfree (sbi);
0755 sb->s_fs_info = NULL;
0756 UFSD("EXIT\n");
0757 return;
0758 }
0759
0760 static u64 ufs_max_bytes(struct super_block *sb)
0761 {
0762 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
0763 int bits = uspi->s_apbshift;
0764 u64 res;
0765
0766 if (bits > 21)
0767 res = ~0ULL;
0768 else
0769 res = UFS_NDADDR + (1LL << bits) + (1LL << (2*bits)) +
0770 (1LL << (3*bits));
0771
0772 if (res >= (MAX_LFS_FILESIZE >> uspi->s_bshift))
0773 return MAX_LFS_FILESIZE;
0774 return res << uspi->s_bshift;
0775 }
0776
0777 static int ufs_fill_super(struct super_block *sb, void *data, int silent)
0778 {
0779 struct ufs_sb_info * sbi;
0780 struct ufs_sb_private_info * uspi;
0781 struct ufs_super_block_first * usb1;
0782 struct ufs_super_block_second * usb2;
0783 struct ufs_super_block_third * usb3;
0784 struct ufs_buffer_head * ubh;
0785 struct inode *inode;
0786 unsigned block_size, super_block_size;
0787 unsigned flags;
0788 unsigned super_block_offset;
0789 unsigned maxsymlen;
0790 int ret = -EINVAL;
0791
0792 uspi = NULL;
0793 ubh = NULL;
0794 flags = 0;
0795
0796 UFSD("ENTER\n");
0797
0798 #ifndef CONFIG_UFS_FS_WRITE
0799 if (!sb_rdonly(sb)) {
0800 pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
0801 return -EROFS;
0802 }
0803 #endif
0804
0805 sbi = kzalloc(sizeof(struct ufs_sb_info), GFP_KERNEL);
0806 if (!sbi)
0807 goto failed_nomem;
0808 sb->s_fs_info = sbi;
0809 sbi->sb = sb;
0810
0811 UFSD("flag %u\n", (int)(sb_rdonly(sb)));
0812
0813 mutex_init(&sbi->s_lock);
0814 spin_lock_init(&sbi->work_lock);
0815 INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs);
0816
0817
0818
0819
0820 sbi->s_mount_opt = 0;
0821 ufs_set_opt (sbi->s_mount_opt, ONERROR_LOCK);
0822 if (!ufs_parse_options ((char *) data, &sbi->s_mount_opt)) {
0823 pr_err("wrong mount options\n");
0824 goto failed;
0825 }
0826 if (!(sbi->s_mount_opt & UFS_MOUNT_UFSTYPE)) {
0827 if (!silent)
0828 pr_err("You didn't specify the type of your ufs filesystem\n\n"
0829 "mount -t ufs -o ufstype="
0830 "sun|sunx86|44bsd|ufs2|5xbsd|old|hp|nextstep|nextstep-cd|openstep ...\n\n"
0831 ">>>WARNING<<< Wrong ufstype may corrupt your filesystem, "
0832 "default is ufstype=old\n");
0833 ufs_set_opt (sbi->s_mount_opt, UFSTYPE_OLD);
0834 }
0835
0836 uspi = kzalloc(sizeof(struct ufs_sb_private_info), GFP_KERNEL);
0837 sbi->s_uspi = uspi;
0838 if (!uspi)
0839 goto failed;
0840 uspi->s_dirblksize = UFS_SECTOR_SIZE;
0841 super_block_offset=UFS_SBLOCK;
0842
0843 sb->s_maxbytes = MAX_LFS_FILESIZE;
0844
0845 sb->s_time_gran = NSEC_PER_SEC;
0846 sb->s_time_min = S32_MIN;
0847 sb->s_time_max = S32_MAX;
0848
0849 switch (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) {
0850 case UFS_MOUNT_UFSTYPE_44BSD:
0851 UFSD("ufstype=44bsd\n");
0852 uspi->s_fsize = block_size = 512;
0853 uspi->s_fmask = ~(512 - 1);
0854 uspi->s_fshift = 9;
0855 uspi->s_sbsize = super_block_size = 1536;
0856 uspi->s_sbbase = 0;
0857 flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
0858 break;
0859 case UFS_MOUNT_UFSTYPE_UFS2:
0860 UFSD("ufstype=ufs2\n");
0861 super_block_offset=SBLOCK_UFS2;
0862 uspi->s_fsize = block_size = 512;
0863 uspi->s_fmask = ~(512 - 1);
0864 uspi->s_fshift = 9;
0865 uspi->s_sbsize = super_block_size = 1536;
0866 uspi->s_sbbase = 0;
0867 sb->s_time_gran = 1;
0868 sb->s_time_min = S64_MIN;
0869 sb->s_time_max = S64_MAX;
0870 flags |= UFS_TYPE_UFS2 | UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
0871 break;
0872
0873 case UFS_MOUNT_UFSTYPE_SUN:
0874 UFSD("ufstype=sun\n");
0875 uspi->s_fsize = block_size = 1024;
0876 uspi->s_fmask = ~(1024 - 1);
0877 uspi->s_fshift = 10;
0878 uspi->s_sbsize = super_block_size = 2048;
0879 uspi->s_sbbase = 0;
0880 uspi->s_maxsymlinklen = 0;
0881 flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUN | UFS_CG_SUN;
0882 break;
0883
0884 case UFS_MOUNT_UFSTYPE_SUNOS:
0885 UFSD("ufstype=sunos\n");
0886 uspi->s_fsize = block_size = 1024;
0887 uspi->s_fmask = ~(1024 - 1);
0888 uspi->s_fshift = 10;
0889 uspi->s_sbsize = 2048;
0890 super_block_size = 2048;
0891 uspi->s_sbbase = 0;
0892 uspi->s_maxsymlinklen = 0;
0893 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_SUNOS | UFS_CG_SUN;
0894 break;
0895
0896 case UFS_MOUNT_UFSTYPE_SUNx86:
0897 UFSD("ufstype=sunx86\n");
0898 uspi->s_fsize = block_size = 1024;
0899 uspi->s_fmask = ~(1024 - 1);
0900 uspi->s_fshift = 10;
0901 uspi->s_sbsize = super_block_size = 2048;
0902 uspi->s_sbbase = 0;
0903 uspi->s_maxsymlinklen = 0;
0904 flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUNx86 | UFS_CG_SUN;
0905 break;
0906
0907 case UFS_MOUNT_UFSTYPE_OLD:
0908 UFSD("ufstype=old\n");
0909 uspi->s_fsize = block_size = 1024;
0910 uspi->s_fmask = ~(1024 - 1);
0911 uspi->s_fshift = 10;
0912 uspi->s_sbsize = super_block_size = 2048;
0913 uspi->s_sbbase = 0;
0914 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
0915 if (!sb_rdonly(sb)) {
0916 if (!silent)
0917 pr_info("ufstype=old is supported read-only\n");
0918 sb->s_flags |= SB_RDONLY;
0919 }
0920 break;
0921
0922 case UFS_MOUNT_UFSTYPE_NEXTSTEP:
0923 UFSD("ufstype=nextstep\n");
0924 uspi->s_fsize = block_size = 1024;
0925 uspi->s_fmask = ~(1024 - 1);
0926 uspi->s_fshift = 10;
0927 uspi->s_sbsize = super_block_size = 2048;
0928 uspi->s_sbbase = 0;
0929 uspi->s_dirblksize = 1024;
0930 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
0931 if (!sb_rdonly(sb)) {
0932 if (!silent)
0933 pr_info("ufstype=nextstep is supported read-only\n");
0934 sb->s_flags |= SB_RDONLY;
0935 }
0936 break;
0937
0938 case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD:
0939 UFSD("ufstype=nextstep-cd\n");
0940 uspi->s_fsize = block_size = 2048;
0941 uspi->s_fmask = ~(2048 - 1);
0942 uspi->s_fshift = 11;
0943 uspi->s_sbsize = super_block_size = 2048;
0944 uspi->s_sbbase = 0;
0945 uspi->s_dirblksize = 1024;
0946 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
0947 if (!sb_rdonly(sb)) {
0948 if (!silent)
0949 pr_info("ufstype=nextstep-cd is supported read-only\n");
0950 sb->s_flags |= SB_RDONLY;
0951 }
0952 break;
0953
0954 case UFS_MOUNT_UFSTYPE_OPENSTEP:
0955 UFSD("ufstype=openstep\n");
0956 uspi->s_fsize = block_size = 1024;
0957 uspi->s_fmask = ~(1024 - 1);
0958 uspi->s_fshift = 10;
0959 uspi->s_sbsize = super_block_size = 2048;
0960 uspi->s_sbbase = 0;
0961 uspi->s_dirblksize = 1024;
0962 flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
0963 if (!sb_rdonly(sb)) {
0964 if (!silent)
0965 pr_info("ufstype=openstep is supported read-only\n");
0966 sb->s_flags |= SB_RDONLY;
0967 }
0968 break;
0969
0970 case UFS_MOUNT_UFSTYPE_HP:
0971 UFSD("ufstype=hp\n");
0972 uspi->s_fsize = block_size = 1024;
0973 uspi->s_fmask = ~(1024 - 1);
0974 uspi->s_fshift = 10;
0975 uspi->s_sbsize = super_block_size = 2048;
0976 uspi->s_sbbase = 0;
0977 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
0978 if (!sb_rdonly(sb)) {
0979 if (!silent)
0980 pr_info("ufstype=hp is supported read-only\n");
0981 sb->s_flags |= SB_RDONLY;
0982 }
0983 break;
0984 default:
0985 if (!silent)
0986 pr_err("unknown ufstype\n");
0987 goto failed;
0988 }
0989
0990 again:
0991 if (!sb_set_blocksize(sb, block_size)) {
0992 pr_err("failed to set blocksize\n");
0993 goto failed;
0994 }
0995
0996
0997
0998
0999
1000 ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size);
1001
1002 if (!ubh)
1003 goto failed;
1004
1005 usb1 = ubh_get_usb_first(uspi);
1006 usb2 = ubh_get_usb_second(uspi);
1007 usb3 = ubh_get_usb_third(uspi);
1008
1009
1010 uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);
1011 if (((flags & UFS_ST_MASK) == UFS_ST_SUNOS) &&
1012 (uspi->s_postblformat != UFS_42POSTBLFMT)) {
1013 flags &= ~UFS_ST_MASK;
1014 flags |= UFS_ST_SUN;
1015 }
1016
1017 if ((flags & UFS_ST_MASK) == UFS_ST_44BSD &&
1018 uspi->s_postblformat == UFS_42POSTBLFMT) {
1019 if (!silent)
1020 pr_err("this is not a 44bsd filesystem");
1021 goto failed;
1022 }
1023
1024
1025
1026
1027 sbi->s_bytesex = BYTESEX_LE;
1028 switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
1029 case UFS_MAGIC:
1030 case UFS_MAGIC_BW:
1031 case UFS2_MAGIC:
1032 case UFS_MAGIC_LFN:
1033 case UFS_MAGIC_FEA:
1034 case UFS_MAGIC_4GB:
1035 goto magic_found;
1036 }
1037 sbi->s_bytesex = BYTESEX_BE;
1038 switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
1039 case UFS_MAGIC:
1040 case UFS_MAGIC_BW:
1041 case UFS2_MAGIC:
1042 case UFS_MAGIC_LFN:
1043 case UFS_MAGIC_FEA:
1044 case UFS_MAGIC_4GB:
1045 goto magic_found;
1046 }
1047
1048 if ((((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP)
1049 || ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD)
1050 || ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_OPENSTEP))
1051 && uspi->s_sbbase < 256) {
1052 ubh_brelse_uspi(uspi);
1053 ubh = NULL;
1054 uspi->s_sbbase += 8;
1055 goto again;
1056 }
1057 if (!silent)
1058 pr_err("%s(): bad magic number\n", __func__);
1059 goto failed;
1060
1061 magic_found:
1062
1063
1064
1065 uspi->s_bsize = fs32_to_cpu(sb, usb1->fs_bsize);
1066 uspi->s_fsize = fs32_to_cpu(sb, usb1->fs_fsize);
1067 uspi->s_sbsize = fs32_to_cpu(sb, usb1->fs_sbsize);
1068 uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
1069 uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
1070
1071 if (!is_power_of_2(uspi->s_fsize)) {
1072 pr_err("%s(): fragment size %u is not a power of 2\n",
1073 __func__, uspi->s_fsize);
1074 goto failed;
1075 }
1076 if (uspi->s_fsize < 512) {
1077 pr_err("%s(): fragment size %u is too small\n",
1078 __func__, uspi->s_fsize);
1079 goto failed;
1080 }
1081 if (uspi->s_fsize > 4096) {
1082 pr_err("%s(): fragment size %u is too large\n",
1083 __func__, uspi->s_fsize);
1084 goto failed;
1085 }
1086 if (!is_power_of_2(uspi->s_bsize)) {
1087 pr_err("%s(): block size %u is not a power of 2\n",
1088 __func__, uspi->s_bsize);
1089 goto failed;
1090 }
1091 if (uspi->s_bsize < 4096) {
1092 pr_err("%s(): block size %u is too small\n",
1093 __func__, uspi->s_bsize);
1094 goto failed;
1095 }
1096 if (uspi->s_bsize / uspi->s_fsize > 8) {
1097 pr_err("%s(): too many fragments per block (%u)\n",
1098 __func__, uspi->s_bsize / uspi->s_fsize);
1099 goto failed;
1100 }
1101 if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) {
1102 ubh_brelse_uspi(uspi);
1103 ubh = NULL;
1104 block_size = uspi->s_fsize;
1105 super_block_size = uspi->s_sbsize;
1106 UFSD("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size);
1107 goto again;
1108 }
1109
1110 sbi->s_flags = flags;
1111 ufs_print_super_stuff(sb, usb1, usb2, usb3);
1112
1113
1114
1115
1116
1117 if (((flags & UFS_ST_MASK) == UFS_ST_44BSD) ||
1118 ((flags & UFS_ST_MASK) == UFS_ST_OLD) ||
1119 (((flags & UFS_ST_MASK) == UFS_ST_SUN ||
1120 (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
1121 (flags & UFS_ST_MASK) == UFS_ST_SUNx86) &&
1122 (ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time))))) {
1123 switch(usb1->fs_clean) {
1124 case UFS_FSCLEAN:
1125 UFSD("fs is clean\n");
1126 break;
1127 case UFS_FSSTABLE:
1128 UFSD("fs is stable\n");
1129 break;
1130 case UFS_FSLOG:
1131 UFSD("fs is logging fs\n");
1132 break;
1133 case UFS_FSOSF1:
1134 UFSD("fs is DEC OSF/1\n");
1135 break;
1136 case UFS_FSACTIVE:
1137 pr_err("%s(): fs is active\n", __func__);
1138 sb->s_flags |= SB_RDONLY;
1139 break;
1140 case UFS_FSBAD:
1141 pr_err("%s(): fs is bad\n", __func__);
1142 sb->s_flags |= SB_RDONLY;
1143 break;
1144 default:
1145 pr_err("%s(): can't grok fs_clean 0x%x\n",
1146 __func__, usb1->fs_clean);
1147 sb->s_flags |= SB_RDONLY;
1148 break;
1149 }
1150 } else {
1151 pr_err("%s(): fs needs fsck\n", __func__);
1152 sb->s_flags |= SB_RDONLY;
1153 }
1154
1155
1156
1157
1158 sb->s_op = &ufs_super_ops;
1159 sb->s_export_op = &ufs_export_ops;
1160
1161 sb->s_magic = fs32_to_cpu(sb, usb3->fs_magic);
1162
1163 uspi->s_sblkno = fs32_to_cpu(sb, usb1->fs_sblkno);
1164 uspi->s_cblkno = fs32_to_cpu(sb, usb1->fs_cblkno);
1165 uspi->s_iblkno = fs32_to_cpu(sb, usb1->fs_iblkno);
1166 uspi->s_dblkno = fs32_to_cpu(sb, usb1->fs_dblkno);
1167 uspi->s_cgoffset = fs32_to_cpu(sb, usb1->fs_cgoffset);
1168 uspi->s_cgmask = fs32_to_cpu(sb, usb1->fs_cgmask);
1169
1170 if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
1171 uspi->s_size = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size);
1172 uspi->s_dsize = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);
1173 } else {
1174 uspi->s_size = fs32_to_cpu(sb, usb1->fs_size);
1175 uspi->s_dsize = fs32_to_cpu(sb, usb1->fs_dsize);
1176 }
1177
1178 uspi->s_ncg = fs32_to_cpu(sb, usb1->fs_ncg);
1179
1180
1181 uspi->s_fpb = fs32_to_cpu(sb, usb1->fs_frag);
1182 uspi->s_minfree = fs32_to_cpu(sb, usb1->fs_minfree);
1183 uspi->s_bmask = fs32_to_cpu(sb, usb1->fs_bmask);
1184 uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
1185 uspi->s_bshift = fs32_to_cpu(sb, usb1->fs_bshift);
1186 uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
1187 UFSD("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi->s_bshift,
1188 uspi->s_fshift);
1189 uspi->s_fpbshift = fs32_to_cpu(sb, usb1->fs_fragshift);
1190 uspi->s_fsbtodb = fs32_to_cpu(sb, usb1->fs_fsbtodb);
1191
1192 uspi->s_csmask = fs32_to_cpu(sb, usb1->fs_csmask);
1193 uspi->s_csshift = fs32_to_cpu(sb, usb1->fs_csshift);
1194 uspi->s_nindir = fs32_to_cpu(sb, usb1->fs_nindir);
1195 uspi->s_inopb = fs32_to_cpu(sb, usb1->fs_inopb);
1196 uspi->s_nspf = fs32_to_cpu(sb, usb1->fs_nspf);
1197 uspi->s_npsect = ufs_get_fs_npsect(sb, usb1, usb3);
1198 uspi->s_interleave = fs32_to_cpu(sb, usb1->fs_interleave);
1199 uspi->s_trackskew = fs32_to_cpu(sb, usb1->fs_trackskew);
1200
1201 if (uspi->fs_magic == UFS2_MAGIC)
1202 uspi->s_csaddr = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_csaddr);
1203 else
1204 uspi->s_csaddr = fs32_to_cpu(sb, usb1->fs_csaddr);
1205
1206 uspi->s_cssize = fs32_to_cpu(sb, usb1->fs_cssize);
1207 uspi->s_cgsize = fs32_to_cpu(sb, usb1->fs_cgsize);
1208 uspi->s_ntrak = fs32_to_cpu(sb, usb1->fs_ntrak);
1209 uspi->s_nsect = fs32_to_cpu(sb, usb1->fs_nsect);
1210 uspi->s_spc = fs32_to_cpu(sb, usb1->fs_spc);
1211 uspi->s_ipg = fs32_to_cpu(sb, usb1->fs_ipg);
1212 uspi->s_fpg = fs32_to_cpu(sb, usb1->fs_fpg);
1213 uspi->s_cpc = fs32_to_cpu(sb, usb2->fs_un.fs_u1.fs_cpc);
1214 uspi->s_contigsumsize = fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_contigsumsize);
1215 uspi->s_qbmask = ufs_get_fs_qbmask(sb, usb3);
1216 uspi->s_qfmask = ufs_get_fs_qfmask(sb, usb3);
1217 uspi->s_nrpos = fs32_to_cpu(sb, usb3->fs_nrpos);
1218 uspi->s_postbloff = fs32_to_cpu(sb, usb3->fs_postbloff);
1219 uspi->s_rotbloff = fs32_to_cpu(sb, usb3->fs_rotbloff);
1220
1221 uspi->s_root_blocks = mul_u64_u32_div(uspi->s_dsize,
1222 uspi->s_minfree, 100);
1223 if (uspi->s_minfree <= 5) {
1224 uspi->s_time_to_space = ~0ULL;
1225 uspi->s_space_to_time = 0;
1226 usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTSPACE);
1227 } else {
1228 uspi->s_time_to_space = (uspi->s_root_blocks / 2) + 1;
1229 uspi->s_space_to_time = mul_u64_u32_div(uspi->s_dsize,
1230 uspi->s_minfree - 2, 100) - 1;
1231 }
1232
1233
1234
1235
1236 uspi->s_fpbmask = uspi->s_fpb - 1;
1237 if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
1238 uspi->s_apbshift = uspi->s_bshift - 3;
1239 else
1240 uspi->s_apbshift = uspi->s_bshift - 2;
1241
1242 uspi->s_2apbshift = uspi->s_apbshift * 2;
1243 uspi->s_3apbshift = uspi->s_apbshift * 3;
1244 uspi->s_apb = 1 << uspi->s_apbshift;
1245 uspi->s_2apb = 1 << uspi->s_2apbshift;
1246 uspi->s_3apb = 1 << uspi->s_3apbshift;
1247 uspi->s_apbmask = uspi->s_apb - 1;
1248 uspi->s_nspfshift = uspi->s_fshift - UFS_SECTOR_BITS;
1249 uspi->s_nspb = uspi->s_nspf << uspi->s_fpbshift;
1250 uspi->s_inopf = uspi->s_inopb >> uspi->s_fpbshift;
1251 uspi->s_bpf = uspi->s_fsize << 3;
1252 uspi->s_bpfshift = uspi->s_fshift + 3;
1253 uspi->s_bpfmask = uspi->s_bpf - 1;
1254 if ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_44BSD ||
1255 (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_UFS2)
1256 uspi->s_maxsymlinklen =
1257 fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen);
1258
1259 if (uspi->fs_magic == UFS2_MAGIC)
1260 maxsymlen = 2 * 4 * (UFS_NDADDR + UFS_NINDIR);
1261 else
1262 maxsymlen = 4 * (UFS_NDADDR + UFS_NINDIR);
1263 if (uspi->s_maxsymlinklen > maxsymlen) {
1264 ufs_warning(sb, __func__, "ufs_read_super: excessive maximum "
1265 "fast symlink size (%u)\n", uspi->s_maxsymlinklen);
1266 uspi->s_maxsymlinklen = maxsymlen;
1267 }
1268 sb->s_maxbytes = ufs_max_bytes(sb);
1269 sb->s_max_links = UFS_LINK_MAX;
1270
1271 inode = ufs_iget(sb, UFS_ROOTINO);
1272 if (IS_ERR(inode)) {
1273 ret = PTR_ERR(inode);
1274 goto failed;
1275 }
1276 sb->s_root = d_make_root(inode);
1277 if (!sb->s_root) {
1278 ret = -ENOMEM;
1279 goto failed;
1280 }
1281
1282 ufs_setup_cstotal(sb);
1283
1284
1285
1286 if (!sb_rdonly(sb))
1287 if (!ufs_read_cylinder_structures(sb))
1288 goto failed;
1289
1290 UFSD("EXIT\n");
1291 return 0;
1292
1293 failed:
1294 if (ubh)
1295 ubh_brelse_uspi (uspi);
1296 kfree (uspi);
1297 kfree(sbi);
1298 sb->s_fs_info = NULL;
1299 UFSD("EXIT (FAILED)\n");
1300 return ret;
1301
1302 failed_nomem:
1303 UFSD("EXIT (NOMEM)\n");
1304 return -ENOMEM;
1305 }
1306
1307 static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
1308 {
1309 struct ufs_sb_private_info * uspi;
1310 struct ufs_super_block_first * usb1;
1311 struct ufs_super_block_third * usb3;
1312 unsigned new_mount_opt, ufstype;
1313 unsigned flags;
1314
1315 sync_filesystem(sb);
1316 mutex_lock(&UFS_SB(sb)->s_lock);
1317 uspi = UFS_SB(sb)->s_uspi;
1318 flags = UFS_SB(sb)->s_flags;
1319 usb1 = ubh_get_usb_first(uspi);
1320 usb3 = ubh_get_usb_third(uspi);
1321
1322
1323
1324
1325
1326 ufstype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE;
1327 new_mount_opt = 0;
1328 ufs_set_opt (new_mount_opt, ONERROR_LOCK);
1329 if (!ufs_parse_options (data, &new_mount_opt)) {
1330 mutex_unlock(&UFS_SB(sb)->s_lock);
1331 return -EINVAL;
1332 }
1333 if (!(new_mount_opt & UFS_MOUNT_UFSTYPE)) {
1334 new_mount_opt |= ufstype;
1335 } else if ((new_mount_opt & UFS_MOUNT_UFSTYPE) != ufstype) {
1336 pr_err("ufstype can't be changed during remount\n");
1337 mutex_unlock(&UFS_SB(sb)->s_lock);
1338 return -EINVAL;
1339 }
1340
1341 if ((bool)(*mount_flags & SB_RDONLY) == sb_rdonly(sb)) {
1342 UFS_SB(sb)->s_mount_opt = new_mount_opt;
1343 mutex_unlock(&UFS_SB(sb)->s_lock);
1344 return 0;
1345 }
1346
1347
1348
1349
1350 if (*mount_flags & SB_RDONLY) {
1351 ufs_put_super_internal(sb);
1352 usb1->fs_time = ufs_get_seconds(sb);
1353 if ((flags & UFS_ST_MASK) == UFS_ST_SUN
1354 || (flags & UFS_ST_MASK) == UFS_ST_SUNOS
1355 || (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
1356 ufs_set_fs_state(sb, usb1, usb3,
1357 UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
1358 ubh_mark_buffer_dirty (USPI_UBH(uspi));
1359 sb->s_flags |= SB_RDONLY;
1360 } else {
1361
1362
1363
1364 #ifndef CONFIG_UFS_FS_WRITE
1365 pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
1366 mutex_unlock(&UFS_SB(sb)->s_lock);
1367 return -EINVAL;
1368 #else
1369 if (ufstype != UFS_MOUNT_UFSTYPE_SUN &&
1370 ufstype != UFS_MOUNT_UFSTYPE_SUNOS &&
1371 ufstype != UFS_MOUNT_UFSTYPE_44BSD &&
1372 ufstype != UFS_MOUNT_UFSTYPE_SUNx86 &&
1373 ufstype != UFS_MOUNT_UFSTYPE_UFS2) {
1374 pr_err("this ufstype is read-only supported\n");
1375 mutex_unlock(&UFS_SB(sb)->s_lock);
1376 return -EINVAL;
1377 }
1378 if (!ufs_read_cylinder_structures(sb)) {
1379 pr_err("failed during remounting\n");
1380 mutex_unlock(&UFS_SB(sb)->s_lock);
1381 return -EPERM;
1382 }
1383 sb->s_flags &= ~SB_RDONLY;
1384 #endif
1385 }
1386 UFS_SB(sb)->s_mount_opt = new_mount_opt;
1387 mutex_unlock(&UFS_SB(sb)->s_lock);
1388 return 0;
1389 }
1390
1391 static int ufs_show_options(struct seq_file *seq, struct dentry *root)
1392 {
1393 struct ufs_sb_info *sbi = UFS_SB(root->d_sb);
1394 unsigned mval = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE;
1395 const struct match_token *tp = tokens;
1396
1397 while (tp->token != Opt_onerror_panic && tp->token != mval)
1398 ++tp;
1399 BUG_ON(tp->token == Opt_onerror_panic);
1400 seq_printf(seq, ",%s", tp->pattern);
1401
1402 mval = sbi->s_mount_opt & UFS_MOUNT_ONERROR;
1403 while (tp->token != Opt_err && tp->token != mval)
1404 ++tp;
1405 BUG_ON(tp->token == Opt_err);
1406 seq_printf(seq, ",%s", tp->pattern);
1407
1408 return 0;
1409 }
1410
1411 static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf)
1412 {
1413 struct super_block *sb = dentry->d_sb;
1414 struct ufs_sb_private_info *uspi= UFS_SB(sb)->s_uspi;
1415 unsigned flags = UFS_SB(sb)->s_flags;
1416 u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
1417
1418 mutex_lock(&UFS_SB(sb)->s_lock);
1419
1420 if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
1421 buf->f_type = UFS2_MAGIC;
1422 else
1423 buf->f_type = UFS_MAGIC;
1424
1425 buf->f_blocks = uspi->s_dsize;
1426 buf->f_bfree = ufs_freefrags(uspi);
1427 buf->f_ffree = uspi->cs_total.cs_nifree;
1428 buf->f_bsize = sb->s_blocksize;
1429 buf->f_bavail = (buf->f_bfree > uspi->s_root_blocks)
1430 ? (buf->f_bfree - uspi->s_root_blocks) : 0;
1431 buf->f_files = uspi->s_ncg * uspi->s_ipg;
1432 buf->f_namelen = UFS_MAXNAMLEN;
1433 buf->f_fsid = u64_to_fsid(id);
1434
1435 mutex_unlock(&UFS_SB(sb)->s_lock);
1436
1437 return 0;
1438 }
1439
1440 static struct kmem_cache * ufs_inode_cachep;
1441
1442 static struct inode *ufs_alloc_inode(struct super_block *sb)
1443 {
1444 struct ufs_inode_info *ei;
1445
1446 ei = alloc_inode_sb(sb, ufs_inode_cachep, GFP_NOFS);
1447 if (!ei)
1448 return NULL;
1449
1450 inode_set_iversion(&ei->vfs_inode, 1);
1451 seqlock_init(&ei->meta_lock);
1452 mutex_init(&ei->truncate_mutex);
1453 return &ei->vfs_inode;
1454 }
1455
1456 static void ufs_free_in_core_inode(struct inode *inode)
1457 {
1458 kmem_cache_free(ufs_inode_cachep, UFS_I(inode));
1459 }
1460
1461 static void init_once(void *foo)
1462 {
1463 struct ufs_inode_info *ei = (struct ufs_inode_info *) foo;
1464
1465 inode_init_once(&ei->vfs_inode);
1466 }
1467
1468 static int __init init_inodecache(void)
1469 {
1470 ufs_inode_cachep = kmem_cache_create_usercopy("ufs_inode_cache",
1471 sizeof(struct ufs_inode_info), 0,
1472 (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
1473 SLAB_ACCOUNT),
1474 offsetof(struct ufs_inode_info, i_u1.i_symlink),
1475 sizeof_field(struct ufs_inode_info,
1476 i_u1.i_symlink),
1477 init_once);
1478 if (ufs_inode_cachep == NULL)
1479 return -ENOMEM;
1480 return 0;
1481 }
1482
1483 static void destroy_inodecache(void)
1484 {
1485
1486
1487
1488
1489 rcu_barrier();
1490 kmem_cache_destroy(ufs_inode_cachep);
1491 }
1492
1493 static const struct super_operations ufs_super_ops = {
1494 .alloc_inode = ufs_alloc_inode,
1495 .free_inode = ufs_free_in_core_inode,
1496 .write_inode = ufs_write_inode,
1497 .evict_inode = ufs_evict_inode,
1498 .put_super = ufs_put_super,
1499 .sync_fs = ufs_sync_fs,
1500 .statfs = ufs_statfs,
1501 .remount_fs = ufs_remount,
1502 .show_options = ufs_show_options,
1503 };
1504
1505 static struct dentry *ufs_mount(struct file_system_type *fs_type,
1506 int flags, const char *dev_name, void *data)
1507 {
1508 return mount_bdev(fs_type, flags, dev_name, data, ufs_fill_super);
1509 }
1510
1511 static struct file_system_type ufs_fs_type = {
1512 .owner = THIS_MODULE,
1513 .name = "ufs",
1514 .mount = ufs_mount,
1515 .kill_sb = kill_block_super,
1516 .fs_flags = FS_REQUIRES_DEV,
1517 };
1518 MODULE_ALIAS_FS("ufs");
1519
1520 static int __init init_ufs_fs(void)
1521 {
1522 int err = init_inodecache();
1523 if (err)
1524 goto out1;
1525 err = register_filesystem(&ufs_fs_type);
1526 if (err)
1527 goto out;
1528 return 0;
1529 out:
1530 destroy_inodecache();
1531 out1:
1532 return err;
1533 }
1534
1535 static void __exit exit_ufs_fs(void)
1536 {
1537 unregister_filesystem(&ufs_fs_type);
1538 destroy_inodecache();
1539 }
1540
1541 module_init(init_ufs_fs)
1542 module_exit(exit_ufs_fs)
1543 MODULE_LICENSE("GPL");