1545 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * linux/fs/ufs/super.c4 *5 * Copyright (C) 19986 * Daniel Pirkl <daniel.pirkl@email.cz>7 * Charles University, Faculty of Mathematics and Physics8 */9 10/* Derived from11 *12 * linux/fs/ext2/super.c13 *14 * Copyright (C) 1992, 1993, 1994, 199515 * Remy Card (card@masi.ibp.fr)16 * Laboratoire MASI - Institut Blaise Pascal17 * Universite Pierre et Marie Curie (Paris VI)18 *19 * from20 *21 * linux/fs/minix/inode.c22 *23 * Copyright (C) 1991, 1992 Linus Torvalds24 *25 * Big-endian to little-endian byte-swapping/bitmaps by26 * David S. Miller (davem@caip.rutgers.edu), 199527 */28 29/*30 * Inspired by31 *32 * linux/fs/ufs/super.c33 *34 * Copyright (C) 199635 * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)36 * Laboratory for Computer Science Research Computing Facility37 * Rutgers, The State University of New Jersey38 *39 * Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)40 *41 * Kernel module support added on 96/04/26 by42 * Stefan Reinauer <stepan@home.culture.mipt.ru>43 *44 * Module usage counts added on 96/04/29 by45 * Gertjan van Wingerde <gwingerde@gmail.com>46 *47 * Clean swab support on 19970406 by48 * Francois-Rene Rideau <fare@tunes.org>49 *50 * 4.4BSD (FreeBSD) support added on February 1st 1998 by51 * Niels Kristian Bech Jensen <nkbj@image.dk> partially based52 * on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>.53 *54 * NeXTstep support added on February 5th 1998 by55 * Niels Kristian Bech Jensen <nkbj@image.dk>.56 *57 * write support Daniel Pirkl <daniel.pirkl@email.cz> 199858 * 59 * HP/UX hfs filesystem support added by60 * Martin K. Petersen <mkp@mkp.net>, August 199961 *62 * UFS2 (of FreeBSD 5.x) support added by63 * Niraj Kumar <niraj17@iitbombay.org>, Jan 200464 *65 * UFS2 write support added by66 * Evgeniy Dushistov <dushistov@mail.ru>, 200767 */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/parser.h>87#include <linux/buffer_head.h>88#include <linux/vfs.h>89#include <linux/log2.h>90#include <linux/mount.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 99static 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 117static 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 123static 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 129static 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 139static 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_DEBUG147/*148 * Print contents of ufs_super_block, useful for debugging149 */150static 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 debugging228 */229static 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#else266# define ufs_print_super_stuff(sb, usb1, usb2, usb3) /**/267# define ufs_print_cylinder_stuff(sb, cg) /**/268#endif /* CONFIG_UFS_DEBUG */269 270static const struct super_operations ufs_super_ops;271 272void 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_mount_opt & UFS_MOUNT_ONERROR) {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 306void 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 331void 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 345enum {346 Opt_type_old = UFS_MOUNT_UFSTYPE_OLD,347 Opt_type_sunx86 = UFS_MOUNT_UFSTYPE_SUNx86,348 Opt_type_sun = UFS_MOUNT_UFSTYPE_SUN,349 Opt_type_sunos = UFS_MOUNT_UFSTYPE_SUNOS,350 Opt_type_44bsd = UFS_MOUNT_UFSTYPE_44BSD,351 Opt_type_ufs2 = UFS_MOUNT_UFSTYPE_UFS2,352 Opt_type_hp = UFS_MOUNT_UFSTYPE_HP,353 Opt_type_nextstepcd = UFS_MOUNT_UFSTYPE_NEXTSTEP_CD,354 Opt_type_nextstep = UFS_MOUNT_UFSTYPE_NEXTSTEP,355 Opt_type_openstep = UFS_MOUNT_UFSTYPE_OPENSTEP,356 Opt_onerror_panic = UFS_MOUNT_ONERROR_PANIC,357 Opt_onerror_lock = UFS_MOUNT_ONERROR_LOCK,358 Opt_onerror_umount = UFS_MOUNT_ONERROR_UMOUNT,359 Opt_onerror_repair = UFS_MOUNT_ONERROR_REPAIR,360 Opt_err361};362 363static const match_table_t tokens = {364 {Opt_type_old, "ufstype=old"},365 {Opt_type_sunx86, "ufstype=sunx86"},366 {Opt_type_sun, "ufstype=sun"},367 {Opt_type_sunos, "ufstype=sunos"},368 {Opt_type_44bsd, "ufstype=44bsd"},369 {Opt_type_ufs2, "ufstype=ufs2"},370 {Opt_type_ufs2, "ufstype=5xbsd"},371 {Opt_type_hp, "ufstype=hp"},372 {Opt_type_nextstepcd, "ufstype=nextstep-cd"},373 {Opt_type_nextstep, "ufstype=nextstep"},374 {Opt_type_openstep, "ufstype=openstep"},375/*end of possible ufs types */376 {Opt_onerror_panic, "onerror=panic"},377 {Opt_onerror_lock, "onerror=lock"},378 {Opt_onerror_umount, "onerror=umount"},379 {Opt_onerror_repair, "onerror=repair"},380 {Opt_err, NULL}381};382 383static int ufs_parse_options (char * options, unsigned * mount_options)384{385 char * p;386 387 UFSD("ENTER\n");388 389 if (!options)390 return 1;391 392 while ((p = strsep(&options, ",")) != NULL) {393 substring_t args[MAX_OPT_ARGS];394 int token;395 if (!*p)396 continue;397 398 token = match_token(p, tokens, args);399 switch (token) {400 case Opt_type_old:401 ufs_clear_opt (*mount_options, UFSTYPE);402 ufs_set_opt (*mount_options, UFSTYPE_OLD);403 break;404 case Opt_type_sunx86:405 ufs_clear_opt (*mount_options, UFSTYPE);406 ufs_set_opt (*mount_options, UFSTYPE_SUNx86);407 break;408 case Opt_type_sun:409 ufs_clear_opt (*mount_options, UFSTYPE);410 ufs_set_opt (*mount_options, UFSTYPE_SUN);411 break;412 case Opt_type_sunos:413 ufs_clear_opt(*mount_options, UFSTYPE);414 ufs_set_opt(*mount_options, UFSTYPE_SUNOS);415 break;416 case Opt_type_44bsd:417 ufs_clear_opt (*mount_options, UFSTYPE);418 ufs_set_opt (*mount_options, UFSTYPE_44BSD);419 break;420 case Opt_type_ufs2:421 ufs_clear_opt(*mount_options, UFSTYPE);422 ufs_set_opt(*mount_options, UFSTYPE_UFS2);423 break;424 case Opt_type_hp:425 ufs_clear_opt (*mount_options, UFSTYPE);426 ufs_set_opt (*mount_options, UFSTYPE_HP);427 break;428 case Opt_type_nextstepcd:429 ufs_clear_opt (*mount_options, UFSTYPE);430 ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP_CD);431 break;432 case Opt_type_nextstep:433 ufs_clear_opt (*mount_options, UFSTYPE);434 ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP);435 break;436 case Opt_type_openstep:437 ufs_clear_opt (*mount_options, UFSTYPE);438 ufs_set_opt (*mount_options, UFSTYPE_OPENSTEP);439 break;440 case Opt_onerror_panic:441 ufs_clear_opt (*mount_options, ONERROR);442 ufs_set_opt (*mount_options, ONERROR_PANIC);443 break;444 case Opt_onerror_lock:445 ufs_clear_opt (*mount_options, ONERROR);446 ufs_set_opt (*mount_options, ONERROR_LOCK);447 break;448 case Opt_onerror_umount:449 ufs_clear_opt (*mount_options, ONERROR);450 ufs_set_opt (*mount_options, ONERROR_UMOUNT);451 break;452 case Opt_onerror_repair:453 pr_err("Unable to do repair on error, will lock lock instead\n");454 ufs_clear_opt (*mount_options, ONERROR);455 ufs_set_opt (*mount_options, ONERROR_REPAIR);456 break;457 default:458 pr_err("Invalid option: \"%s\" or missing value\n", p);459 return 0;460 }461 }462 return 1;463}464 465/*466 * Different types of UFS hold fs_cstotal in different467 * places, and use different data structure for it.468 * To make things simpler we just copy fs_cstotal to ufs_sb_private_info469 */470static void ufs_setup_cstotal(struct super_block *sb)471{472 struct ufs_sb_info *sbi = UFS_SB(sb);473 struct ufs_sb_private_info *uspi = sbi->s_uspi;474 struct ufs_super_block_first *usb1;475 struct ufs_super_block_second *usb2;476 struct ufs_super_block_third *usb3;477 unsigned mtype = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE;478 479 UFSD("ENTER, mtype=%u\n", mtype);480 usb1 = ubh_get_usb_first(uspi);481 usb2 = ubh_get_usb_second(uspi);482 usb3 = ubh_get_usb_third(uspi);483 484 if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&485 (usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) ||486 mtype == UFS_MOUNT_UFSTYPE_UFS2) {487 /*we have statistic in different place, then usual*/488 uspi->cs_total.cs_ndir = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir);489 uspi->cs_total.cs_nbfree = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_nbfree);490 uspi->cs_total.cs_nifree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nifree);491 uspi->cs_total.cs_nffree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nffree);492 } else {493 uspi->cs_total.cs_ndir = fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir);494 uspi->cs_total.cs_nbfree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree);495 uspi->cs_total.cs_nifree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree);496 uspi->cs_total.cs_nffree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree);497 }498 UFSD("EXIT\n");499}500 501/*502 * Read on-disk structures associated with cylinder groups503 */504static int ufs_read_cylinder_structures(struct super_block *sb)505{506 struct ufs_sb_info *sbi = UFS_SB(sb);507 struct ufs_sb_private_info *uspi = sbi->s_uspi;508 struct ufs_buffer_head * ubh;509 unsigned char * base, * space;510 unsigned size, blks, i;511 512 UFSD("ENTER\n");513 514 /*515 * Read cs structures from (usually) first data block516 * on the device. 517 */518 size = uspi->s_cssize;519 blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;520 base = space = kmalloc(size, GFP_NOFS);521 if (!base)522 goto failed; 523 sbi->s_csp = (struct ufs_csum *)space;524 for (i = 0; i < blks; i += uspi->s_fpb) {525 size = uspi->s_bsize;526 if (i + uspi->s_fpb > blks)527 size = (blks - i) * uspi->s_fsize;528 529 ubh = ubh_bread(sb, uspi->s_csaddr + i, size);530 531 if (!ubh)532 goto failed;533 534 ubh_ubhcpymem (space, ubh, size);535 536 space += size;537 ubh_brelse (ubh);538 ubh = NULL;539 }540 541 /*542 * Read cylinder group (we read only first fragment from block543 * at this time) and prepare internal data structures for cg caching.544 */545 sbi->s_ucg = kmalloc_array(uspi->s_ncg, sizeof(struct buffer_head *),546 GFP_NOFS);547 if (!sbi->s_ucg)548 goto failed;549 for (i = 0; i < uspi->s_ncg; i++) 550 sbi->s_ucg[i] = NULL;551 for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {552 sbi->s_ucpi[i] = NULL;553 sbi->s_cgno[i] = UFS_CGNO_EMPTY;554 }555 for (i = 0; i < uspi->s_ncg; i++) {556 UFSD("read cg %u\n", i);557 if (!(sbi->s_ucg[i] = sb_bread(sb, ufs_cgcmin(i))))558 goto failed;559 if (!ufs_cg_chkmagic (sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data))560 goto failed;561 562 ufs_print_cylinder_stuff(sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data);563 }564 for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {565 if (!(sbi->s_ucpi[i] = kmalloc (sizeof(struct ufs_cg_private_info), GFP_NOFS)))566 goto failed;567 sbi->s_cgno[i] = UFS_CGNO_EMPTY;568 }569 sbi->s_cg_loaded = 0;570 UFSD("EXIT\n");571 return 1;572 573failed:574 kfree (base);575 if (sbi->s_ucg) {576 for (i = 0; i < uspi->s_ncg; i++)577 if (sbi->s_ucg[i])578 brelse (sbi->s_ucg[i]);579 kfree (sbi->s_ucg);580 for (i = 0; i < UFS_MAX_GROUP_LOADED; i++)581 kfree (sbi->s_ucpi[i]);582 }583 UFSD("EXIT (FAILED)\n");584 return 0;585}586 587/*588 * Sync our internal copy of fs_cstotal with disk589 */590static void ufs_put_cstotal(struct super_block *sb)591{592 unsigned mtype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE;593 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;594 struct ufs_super_block_first *usb1;595 struct ufs_super_block_second *usb2;596 struct ufs_super_block_third *usb3;597 598 UFSD("ENTER\n");599 usb1 = ubh_get_usb_first(uspi);600 usb2 = ubh_get_usb_second(uspi);601 usb3 = ubh_get_usb_third(uspi);602 603 if (mtype == UFS_MOUNT_UFSTYPE_UFS2) {604 /*we have statistic in different place, then usual*/605 usb2->fs_un.fs_u2.cs_ndir =606 cpu_to_fs64(sb, uspi->cs_total.cs_ndir);607 usb2->fs_un.fs_u2.cs_nbfree =608 cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);609 usb3->fs_un1.fs_u2.cs_nifree =610 cpu_to_fs64(sb, uspi->cs_total.cs_nifree);611 usb3->fs_un1.fs_u2.cs_nffree =612 cpu_to_fs64(sb, uspi->cs_total.cs_nffree);613 goto out;614 }615 616 if (mtype == UFS_MOUNT_UFSTYPE_44BSD &&617 (usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) {618 /* store stats in both old and new places */619 usb2->fs_un.fs_u2.cs_ndir =620 cpu_to_fs64(sb, uspi->cs_total.cs_ndir);621 usb2->fs_un.fs_u2.cs_nbfree =622 cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);623 usb3->fs_un1.fs_u2.cs_nifree =624 cpu_to_fs64(sb, uspi->cs_total.cs_nifree);625 usb3->fs_un1.fs_u2.cs_nffree =626 cpu_to_fs64(sb, uspi->cs_total.cs_nffree);627 }628 usb1->fs_cstotal.cs_ndir = cpu_to_fs32(sb, uspi->cs_total.cs_ndir);629 usb1->fs_cstotal.cs_nbfree = cpu_to_fs32(sb, uspi->cs_total.cs_nbfree);630 usb1->fs_cstotal.cs_nifree = cpu_to_fs32(sb, uspi->cs_total.cs_nifree);631 usb1->fs_cstotal.cs_nffree = cpu_to_fs32(sb, uspi->cs_total.cs_nffree);632out:633 ubh_mark_buffer_dirty(USPI_UBH(uspi));634 ufs_print_super_stuff(sb, usb1, usb2, usb3);635 UFSD("EXIT\n");636}637 638/**639 * ufs_put_super_internal() - put on-disk intrenal structures640 * @sb: pointer to super_block structure641 * Put on-disk structures associated with cylinder groups642 * and write them back to disk, also update cs_total on disk643 */644static void ufs_put_super_internal(struct super_block *sb)645{646 struct ufs_sb_info *sbi = UFS_SB(sb);647 struct ufs_sb_private_info *uspi = sbi->s_uspi;648 struct ufs_buffer_head * ubh;649 unsigned char * base, * space;650 unsigned blks, size, i;651 652 653 UFSD("ENTER\n");654 655 ufs_put_cstotal(sb);656 size = uspi->s_cssize;657 blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;658 base = space = (char*) sbi->s_csp;659 for (i = 0; i < blks; i += uspi->s_fpb) {660 size = uspi->s_bsize;661 if (i + uspi->s_fpb > blks)662 size = (blks - i) * uspi->s_fsize;663 664 ubh = ubh_bread(sb, uspi->s_csaddr + i, size);665 666 ubh_memcpyubh (ubh, space, size);667 space += size;668 ubh_mark_buffer_uptodate (ubh, 1);669 ubh_mark_buffer_dirty (ubh);670 ubh_brelse (ubh);671 }672 for (i = 0; i < sbi->s_cg_loaded; i++) {673 ufs_put_cylinder (sb, i);674 kfree (sbi->s_ucpi[i]);675 }676 for (; i < UFS_MAX_GROUP_LOADED; i++) 677 kfree (sbi->s_ucpi[i]);678 for (i = 0; i < uspi->s_ncg; i++) 679 brelse (sbi->s_ucg[i]);680 kfree (sbi->s_ucg);681 kfree (base);682 683 UFSD("EXIT\n");684}685 686static int ufs_sync_fs(struct super_block *sb, int wait)687{688 struct ufs_sb_private_info * uspi;689 struct ufs_super_block_first * usb1;690 struct ufs_super_block_third * usb3;691 unsigned flags;692 693 mutex_lock(&UFS_SB(sb)->s_lock);694 695 UFSD("ENTER\n");696 697 flags = UFS_SB(sb)->s_flags;698 uspi = UFS_SB(sb)->s_uspi;699 usb1 = ubh_get_usb_first(uspi);700 usb3 = ubh_get_usb_third(uspi);701 702 usb1->fs_time = ufs_get_seconds(sb);703 if ((flags & UFS_ST_MASK) == UFS_ST_SUN ||704 (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||705 (flags & UFS_ST_MASK) == UFS_ST_SUNx86)706 ufs_set_fs_state(sb, usb1, usb3,707 UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));708 ufs_put_cstotal(sb);709 710 UFSD("EXIT\n");711 mutex_unlock(&UFS_SB(sb)->s_lock);712 713 return 0;714}715 716static void delayed_sync_fs(struct work_struct *work)717{718 struct ufs_sb_info *sbi;719 720 sbi = container_of(work, struct ufs_sb_info, sync_work.work);721 722 spin_lock(&sbi->work_lock);723 sbi->work_queued = 0;724 spin_unlock(&sbi->work_lock);725 726 ufs_sync_fs(sbi->sb, 1);727}728 729void ufs_mark_sb_dirty(struct super_block *sb)730{731 struct ufs_sb_info *sbi = UFS_SB(sb);732 unsigned long delay;733 734 spin_lock(&sbi->work_lock);735 if (!sbi->work_queued) {736 delay = msecs_to_jiffies(dirty_writeback_interval * 10);737 queue_delayed_work(system_long_wq, &sbi->sync_work, delay);738 sbi->work_queued = 1;739 }740 spin_unlock(&sbi->work_lock);741}742 743static void ufs_put_super(struct super_block *sb)744{745 struct ufs_sb_info * sbi = UFS_SB(sb);746 747 UFSD("ENTER\n");748 749 if (!sb_rdonly(sb))750 ufs_put_super_internal(sb);751 cancel_delayed_work_sync(&sbi->sync_work);752 753 ubh_brelse_uspi (sbi->s_uspi);754 kfree (sbi->s_uspi);755 kfree (sbi);756 sb->s_fs_info = NULL;757 UFSD("EXIT\n");758 return;759}760 761static u64 ufs_max_bytes(struct super_block *sb)762{763 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;764 int bits = uspi->s_apbshift;765 u64 res;766 767 if (bits > 21)768 res = ~0ULL;769 else770 res = UFS_NDADDR + (1LL << bits) + (1LL << (2*bits)) +771 (1LL << (3*bits));772 773 if (res >= (MAX_LFS_FILESIZE >> uspi->s_bshift))774 return MAX_LFS_FILESIZE;775 return res << uspi->s_bshift;776}777 778static int ufs_fill_super(struct super_block *sb, void *data, int silent)779{780 struct ufs_sb_info * sbi;781 struct ufs_sb_private_info * uspi;782 struct ufs_super_block_first * usb1;783 struct ufs_super_block_second * usb2;784 struct ufs_super_block_third * usb3;785 struct ufs_buffer_head * ubh; 786 struct inode *inode;787 unsigned block_size, super_block_size;788 unsigned flags;789 unsigned super_block_offset;790 unsigned maxsymlen;791 int ret = -EINVAL;792 793 uspi = NULL;794 ubh = NULL;795 flags = 0;796 797 UFSD("ENTER\n");798 799#ifndef CONFIG_UFS_FS_WRITE800 if (!sb_rdonly(sb)) {801 pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");802 return -EROFS;803 }804#endif805 806 sbi = kzalloc(sizeof(struct ufs_sb_info), GFP_KERNEL);807 if (!sbi)808 goto failed_nomem;809 sb->s_fs_info = sbi;810 sbi->sb = sb;811 812 UFSD("flag %u\n", (int)(sb_rdonly(sb)));813 814 mutex_init(&sbi->s_lock);815 spin_lock_init(&sbi->work_lock);816 INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs);817 /*818 * Set default mount options819 * Parse mount options820 */821 sbi->s_mount_opt = 0;822 ufs_set_opt (sbi->s_mount_opt, ONERROR_LOCK);823 if (!ufs_parse_options ((char *) data, &sbi->s_mount_opt)) {824 pr_err("wrong mount options\n");825 goto failed;826 }827 if (!(sbi->s_mount_opt & UFS_MOUNT_UFSTYPE)) {828 if (!silent)829 pr_err("You didn't specify the type of your ufs filesystem\n\n"830 "mount -t ufs -o ufstype="831 "sun|sunx86|44bsd|ufs2|5xbsd|old|hp|nextstep|nextstep-cd|openstep ...\n\n"832 ">>>WARNING<<< Wrong ufstype may corrupt your filesystem, "833 "default is ufstype=old\n");834 ufs_set_opt (sbi->s_mount_opt, UFSTYPE_OLD);835 }836 837 uspi = kzalloc(sizeof(struct ufs_sb_private_info), GFP_KERNEL);838 sbi->s_uspi = uspi;839 if (!uspi)840 goto failed;841 uspi->s_dirblksize = UFS_SECTOR_SIZE;842 super_block_offset=UFS_SBLOCK;843 844 sb->s_maxbytes = MAX_LFS_FILESIZE;845 846 sb->s_time_gran = NSEC_PER_SEC;847 sb->s_time_min = S32_MIN;848 sb->s_time_max = S32_MAX;849 850 switch (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) {851 case UFS_MOUNT_UFSTYPE_44BSD:852 UFSD("ufstype=44bsd\n");853 uspi->s_fsize = block_size = 512;854 uspi->s_fmask = ~(512 - 1);855 uspi->s_fshift = 9;856 uspi->s_sbsize = super_block_size = 1536;857 uspi->s_sbbase = 0;858 flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;859 break;860 case UFS_MOUNT_UFSTYPE_UFS2:861 UFSD("ufstype=ufs2\n");862 super_block_offset=SBLOCK_UFS2;863 uspi->s_fsize = block_size = 512;864 uspi->s_fmask = ~(512 - 1);865 uspi->s_fshift = 9;866 uspi->s_sbsize = super_block_size = 1536;867 uspi->s_sbbase = 0;868 sb->s_time_gran = 1;869 sb->s_time_min = S64_MIN;870 sb->s_time_max = S64_MAX;871 flags |= UFS_TYPE_UFS2 | UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;872 break;873 874 case UFS_MOUNT_UFSTYPE_SUN:875 UFSD("ufstype=sun\n");876 uspi->s_fsize = block_size = 1024;877 uspi->s_fmask = ~(1024 - 1);878 uspi->s_fshift = 10;879 uspi->s_sbsize = super_block_size = 2048;880 uspi->s_sbbase = 0;881 uspi->s_maxsymlinklen = 0; /* Not supported on disk */882 flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUN | UFS_CG_SUN;883 break;884 885 case UFS_MOUNT_UFSTYPE_SUNOS:886 UFSD("ufstype=sunos\n");887 uspi->s_fsize = block_size = 1024;888 uspi->s_fmask = ~(1024 - 1);889 uspi->s_fshift = 10;890 uspi->s_sbsize = 2048;891 super_block_size = 2048;892 uspi->s_sbbase = 0;893 uspi->s_maxsymlinklen = 0; /* Not supported on disk */894 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_SUNOS | UFS_CG_SUN;895 break;896 897 case UFS_MOUNT_UFSTYPE_SUNx86:898 UFSD("ufstype=sunx86\n");899 uspi->s_fsize = block_size = 1024;900 uspi->s_fmask = ~(1024 - 1);901 uspi->s_fshift = 10;902 uspi->s_sbsize = super_block_size = 2048;903 uspi->s_sbbase = 0;904 uspi->s_maxsymlinklen = 0; /* Not supported on disk */905 flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUNx86 | UFS_CG_SUN;906 break;907 908 case UFS_MOUNT_UFSTYPE_OLD:909 UFSD("ufstype=old\n");910 uspi->s_fsize = block_size = 1024;911 uspi->s_fmask = ~(1024 - 1);912 uspi->s_fshift = 10;913 uspi->s_sbsize = super_block_size = 2048;914 uspi->s_sbbase = 0;915 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;916 if (!sb_rdonly(sb)) {917 if (!silent)918 pr_info("ufstype=old is supported read-only\n");919 sb->s_flags |= SB_RDONLY;920 }921 break;922 923 case UFS_MOUNT_UFSTYPE_NEXTSTEP:924 UFSD("ufstype=nextstep\n");925 uspi->s_fsize = block_size = 1024;926 uspi->s_fmask = ~(1024 - 1);927 uspi->s_fshift = 10;928 uspi->s_sbsize = super_block_size = 2048;929 uspi->s_sbbase = 0;930 uspi->s_dirblksize = 1024;931 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;932 if (!sb_rdonly(sb)) {933 if (!silent)934 pr_info("ufstype=nextstep is supported read-only\n");935 sb->s_flags |= SB_RDONLY;936 }937 break;938 939 case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD:940 UFSD("ufstype=nextstep-cd\n");941 uspi->s_fsize = block_size = 2048;942 uspi->s_fmask = ~(2048 - 1);943 uspi->s_fshift = 11;944 uspi->s_sbsize = super_block_size = 2048;945 uspi->s_sbbase = 0;946 uspi->s_dirblksize = 1024;947 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;948 if (!sb_rdonly(sb)) {949 if (!silent)950 pr_info("ufstype=nextstep-cd is supported read-only\n");951 sb->s_flags |= SB_RDONLY;952 }953 break;954 955 case UFS_MOUNT_UFSTYPE_OPENSTEP:956 UFSD("ufstype=openstep\n");957 uspi->s_fsize = block_size = 1024;958 uspi->s_fmask = ~(1024 - 1);959 uspi->s_fshift = 10;960 uspi->s_sbsize = super_block_size = 2048;961 uspi->s_sbbase = 0;962 uspi->s_dirblksize = 1024;963 flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;964 if (!sb_rdonly(sb)) {965 if (!silent)966 pr_info("ufstype=openstep is supported read-only\n");967 sb->s_flags |= SB_RDONLY;968 }969 break;970 971 case UFS_MOUNT_UFSTYPE_HP:972 UFSD("ufstype=hp\n");973 uspi->s_fsize = block_size = 1024;974 uspi->s_fmask = ~(1024 - 1);975 uspi->s_fshift = 10;976 uspi->s_sbsize = super_block_size = 2048;977 uspi->s_sbbase = 0;978 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;979 if (!sb_rdonly(sb)) {980 if (!silent)981 pr_info("ufstype=hp is supported read-only\n");982 sb->s_flags |= SB_RDONLY;983 }984 break;985 default:986 if (!silent)987 pr_err("unknown ufstype\n");988 goto failed;989 }990 991again: 992 if (!sb_set_blocksize(sb, block_size)) {993 pr_err("failed to set blocksize\n");994 goto failed;995 }996 997 /*998 * read ufs super block from device999 */1000 1001 ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size);1002 1003 if (!ubh) 1004 goto failed;1005 1006 usb1 = ubh_get_usb_first(uspi);1007 usb2 = ubh_get_usb_second(uspi);1008 usb3 = ubh_get_usb_third(uspi);1009 1010 /* Sort out mod used on SunOS 4.1.3 for fs_state */1011 uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);1012 if (((flags & UFS_ST_MASK) == UFS_ST_SUNOS) &&1013 (uspi->s_postblformat != UFS_42POSTBLFMT)) {1014 flags &= ~UFS_ST_MASK;1015 flags |= UFS_ST_SUN;1016 }1017 1018 if ((flags & UFS_ST_MASK) == UFS_ST_44BSD &&1019 uspi->s_postblformat == UFS_42POSTBLFMT) {1020 if (!silent)1021 pr_err("this is not a 44bsd filesystem");1022 goto failed;1023 }1024 1025 /*1026 * Check ufs magic number1027 */1028 sbi->s_bytesex = BYTESEX_LE;1029 switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {1030 case UFS_MAGIC:1031 case UFS_MAGIC_BW:1032 case UFS2_MAGIC:1033 case UFS_MAGIC_LFN:1034 case UFS_MAGIC_FEA:1035 case UFS_MAGIC_4GB:1036 goto magic_found;1037 }1038 sbi->s_bytesex = BYTESEX_BE;1039 switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {1040 case UFS_MAGIC:1041 case UFS_MAGIC_BW:1042 case UFS2_MAGIC:1043 case UFS_MAGIC_LFN:1044 case UFS_MAGIC_FEA:1045 case UFS_MAGIC_4GB:1046 goto magic_found;1047 }1048 1049 if ((((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP) 1050 || ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD) 1051 || ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_OPENSTEP)) 1052 && uspi->s_sbbase < 256) {1053 ubh_brelse_uspi(uspi);1054 ubh = NULL;1055 uspi->s_sbbase += 8;1056 goto again;1057 }1058 if (!silent)1059 pr_err("%s(): bad magic number\n", __func__);1060 goto failed;1061 1062magic_found:1063 /*1064 * Check block and fragment sizes1065 */1066 uspi->s_bsize = fs32_to_cpu(sb, usb1->fs_bsize);1067 uspi->s_fsize = fs32_to_cpu(sb, usb1->fs_fsize);1068 uspi->s_sbsize = fs32_to_cpu(sb, usb1->fs_sbsize);1069 uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);1070 uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);1071 1072 if (!is_power_of_2(uspi->s_fsize)) {1073 pr_err("%s(): fragment size %u is not a power of 2\n",1074 __func__, uspi->s_fsize);1075 goto failed;1076 }1077 if (uspi->s_fsize < 512) {1078 pr_err("%s(): fragment size %u is too small\n",1079 __func__, uspi->s_fsize);1080 goto failed;1081 }1082 if (uspi->s_fsize > 4096) {1083 pr_err("%s(): fragment size %u is too large\n",1084 __func__, uspi->s_fsize);1085 goto failed;1086 }1087 if (!is_power_of_2(uspi->s_bsize)) {1088 pr_err("%s(): block size %u is not a power of 2\n",1089 __func__, uspi->s_bsize);1090 goto failed;1091 }1092 if (uspi->s_bsize < 4096) {1093 pr_err("%s(): block size %u is too small\n",1094 __func__, uspi->s_bsize);1095 goto failed;1096 }1097 if (uspi->s_bsize / uspi->s_fsize > 8) {1098 pr_err("%s(): too many fragments per block (%u)\n",1099 __func__, uspi->s_bsize / uspi->s_fsize);1100 goto failed;1101 }1102 if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) {1103 ubh_brelse_uspi(uspi);1104 ubh = NULL;1105 block_size = uspi->s_fsize;1106 super_block_size = uspi->s_sbsize;1107 UFSD("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size);1108 goto again;1109 }1110 1111 sbi->s_flags = flags;/*after that line some functions use s_flags*/1112 ufs_print_super_stuff(sb, usb1, usb2, usb3);1113 1114 /*1115 * Check, if file system was correctly unmounted.1116 * If not, make it read only.1117 */1118 if (((flags & UFS_ST_MASK) == UFS_ST_44BSD) ||1119 ((flags & UFS_ST_MASK) == UFS_ST_OLD) ||1120 (((flags & UFS_ST_MASK) == UFS_ST_SUN ||1121 (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||1122 (flags & UFS_ST_MASK) == UFS_ST_SUNx86) &&1123 (ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time))))) {1124 switch(usb1->fs_clean) {1125 case UFS_FSCLEAN:1126 UFSD("fs is clean\n");1127 break;1128 case UFS_FSSTABLE:1129 UFSD("fs is stable\n");1130 break;1131 case UFS_FSLOG:1132 UFSD("fs is logging fs\n");1133 break;1134 case UFS_FSOSF1:1135 UFSD("fs is DEC OSF/1\n");1136 break;1137 case UFS_FSACTIVE:1138 pr_err("%s(): fs is active\n", __func__);1139 sb->s_flags |= SB_RDONLY;1140 break;1141 case UFS_FSBAD:1142 pr_err("%s(): fs is bad\n", __func__);1143 sb->s_flags |= SB_RDONLY;1144 break;1145 default:1146 pr_err("%s(): can't grok fs_clean 0x%x\n",1147 __func__, usb1->fs_clean);1148 sb->s_flags |= SB_RDONLY;1149 break;1150 }1151 } else {1152 pr_err("%s(): fs needs fsck\n", __func__);1153 sb->s_flags |= SB_RDONLY;1154 }1155 1156 /*1157 * Read ufs_super_block into internal data structures1158 */1159 sb->s_op = &ufs_super_ops;1160 sb->s_export_op = &ufs_export_ops;1161 1162 sb->s_magic = fs32_to_cpu(sb, usb3->fs_magic);1163 1164 uspi->s_sblkno = fs32_to_cpu(sb, usb1->fs_sblkno);1165 uspi->s_cblkno = fs32_to_cpu(sb, usb1->fs_cblkno);1166 uspi->s_iblkno = fs32_to_cpu(sb, usb1->fs_iblkno);1167 uspi->s_dblkno = fs32_to_cpu(sb, usb1->fs_dblkno);1168 uspi->s_cgoffset = fs32_to_cpu(sb, usb1->fs_cgoffset);1169 uspi->s_cgmask = fs32_to_cpu(sb, usb1->fs_cgmask);1170 1171 if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {1172 uspi->s_size = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size);1173 uspi->s_dsize = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);1174 } else {1175 uspi->s_size = fs32_to_cpu(sb, usb1->fs_size);1176 uspi->s_dsize = fs32_to_cpu(sb, usb1->fs_dsize);1177 }1178 1179 uspi->s_ncg = fs32_to_cpu(sb, usb1->fs_ncg);1180 /* s_bsize already set */1181 /* s_fsize already set */1182 uspi->s_fpb = fs32_to_cpu(sb, usb1->fs_frag);1183 uspi->s_minfree = fs32_to_cpu(sb, usb1->fs_minfree);1184 uspi->s_bmask = fs32_to_cpu(sb, usb1->fs_bmask);1185 uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);1186 uspi->s_bshift = fs32_to_cpu(sb, usb1->fs_bshift);1187 uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);1188 UFSD("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi->s_bshift,1189 uspi->s_fshift);1190 uspi->s_fpbshift = fs32_to_cpu(sb, usb1->fs_fragshift);1191 uspi->s_fsbtodb = fs32_to_cpu(sb, usb1->fs_fsbtodb);1192 /* s_sbsize already set */1193 uspi->s_csmask = fs32_to_cpu(sb, usb1->fs_csmask);1194 uspi->s_csshift = fs32_to_cpu(sb, usb1->fs_csshift);1195 uspi->s_nindir = fs32_to_cpu(sb, usb1->fs_nindir);1196 uspi->s_inopb = fs32_to_cpu(sb, usb1->fs_inopb);1197 uspi->s_nspf = fs32_to_cpu(sb, usb1->fs_nspf);1198 uspi->s_npsect = ufs_get_fs_npsect(sb, usb1, usb3);1199 uspi->s_interleave = fs32_to_cpu(sb, usb1->fs_interleave);1200 uspi->s_trackskew = fs32_to_cpu(sb, usb1->fs_trackskew);1201 1202 if (uspi->fs_magic == UFS2_MAGIC)1203 uspi->s_csaddr = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_csaddr);1204 else1205 uspi->s_csaddr = fs32_to_cpu(sb, usb1->fs_csaddr);1206 1207 uspi->s_cssize = fs32_to_cpu(sb, usb1->fs_cssize);1208 uspi->s_cgsize = fs32_to_cpu(sb, usb1->fs_cgsize);1209 uspi->s_ntrak = fs32_to_cpu(sb, usb1->fs_ntrak);1210 uspi->s_nsect = fs32_to_cpu(sb, usb1->fs_nsect);1211 uspi->s_spc = fs32_to_cpu(sb, usb1->fs_spc);1212 uspi->s_ipg = fs32_to_cpu(sb, usb1->fs_ipg);1213 uspi->s_fpg = fs32_to_cpu(sb, usb1->fs_fpg);1214 uspi->s_cpc = fs32_to_cpu(sb, usb2->fs_un.fs_u1.fs_cpc);1215 uspi->s_contigsumsize = fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_contigsumsize);1216 uspi->s_qbmask = ufs_get_fs_qbmask(sb, usb3);1217 uspi->s_qfmask = ufs_get_fs_qfmask(sb, usb3);1218 uspi->s_nrpos = fs32_to_cpu(sb, usb3->fs_nrpos);1219 uspi->s_postbloff = fs32_to_cpu(sb, usb3->fs_postbloff);1220 uspi->s_rotbloff = fs32_to_cpu(sb, usb3->fs_rotbloff);1221 1222 uspi->s_root_blocks = mul_u64_u32_div(uspi->s_dsize,1223 uspi->s_minfree, 100);1224 if (uspi->s_minfree <= 5) {1225 uspi->s_time_to_space = ~0ULL;1226 uspi->s_space_to_time = 0;1227 usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTSPACE);1228 } else {1229 uspi->s_time_to_space = (uspi->s_root_blocks / 2) + 1;1230 uspi->s_space_to_time = mul_u64_u32_div(uspi->s_dsize,1231 uspi->s_minfree - 2, 100) - 1;1232 }1233 1234 /*1235 * Compute another frequently used values1236 */1237 uspi->s_fpbmask = uspi->s_fpb - 1;1238 if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)1239 uspi->s_apbshift = uspi->s_bshift - 3;1240 else1241 uspi->s_apbshift = uspi->s_bshift - 2;1242 1243 uspi->s_2apbshift = uspi->s_apbshift * 2;1244 uspi->s_3apbshift = uspi->s_apbshift * 3;1245 uspi->s_apb = 1 << uspi->s_apbshift;1246 uspi->s_2apb = 1 << uspi->s_2apbshift;1247 uspi->s_3apb = 1 << uspi->s_3apbshift;1248 uspi->s_apbmask = uspi->s_apb - 1;1249 uspi->s_nspfshift = uspi->s_fshift - UFS_SECTOR_BITS;1250 uspi->s_nspb = uspi->s_nspf << uspi->s_fpbshift;1251 uspi->s_inopf = uspi->s_inopb >> uspi->s_fpbshift;1252 uspi->s_bpf = uspi->s_fsize << 3;1253 uspi->s_bpfshift = uspi->s_fshift + 3;1254 uspi->s_bpfmask = uspi->s_bpf - 1;1255 if ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_44BSD ||1256 (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_UFS2)1257 uspi->s_maxsymlinklen =1258 fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen);1259 1260 if (uspi->fs_magic == UFS2_MAGIC)1261 maxsymlen = 2 * 4 * (UFS_NDADDR + UFS_NINDIR);1262 else1263 maxsymlen = 4 * (UFS_NDADDR + UFS_NINDIR);1264 if (uspi->s_maxsymlinklen > maxsymlen) {1265 ufs_warning(sb, __func__, "ufs_read_super: excessive maximum "1266 "fast symlink size (%u)\n", uspi->s_maxsymlinklen);1267 uspi->s_maxsymlinklen = maxsymlen;1268 }1269 sb->s_maxbytes = ufs_max_bytes(sb);1270 sb->s_max_links = UFS_LINK_MAX;1271 1272 inode = ufs_iget(sb, UFS_ROOTINO);1273 if (IS_ERR(inode)) {1274 ret = PTR_ERR(inode);1275 goto failed;1276 }1277 sb->s_root = d_make_root(inode);1278 if (!sb->s_root) {1279 ret = -ENOMEM;1280 goto failed;1281 }1282 1283 ufs_setup_cstotal(sb);1284 /*1285 * Read cylinder group structures1286 */1287 if (!sb_rdonly(sb))1288 if (!ufs_read_cylinder_structures(sb))1289 goto failed;1290 1291 UFSD("EXIT\n");1292 return 0;1293 1294failed:1295 if (ubh)1296 ubh_brelse_uspi (uspi);1297 kfree (uspi);1298 kfree(sbi);1299 sb->s_fs_info = NULL;1300 UFSD("EXIT (FAILED)\n");1301 return ret;1302 1303failed_nomem:1304 UFSD("EXIT (NOMEM)\n");1305 return -ENOMEM;1306}1307 1308static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)1309{1310 struct ufs_sb_private_info * uspi;1311 struct ufs_super_block_first * usb1;1312 struct ufs_super_block_third * usb3;1313 unsigned new_mount_opt, ufstype;1314 unsigned flags;1315 1316 sync_filesystem(sb);1317 mutex_lock(&UFS_SB(sb)->s_lock);1318 uspi = UFS_SB(sb)->s_uspi;1319 flags = UFS_SB(sb)->s_flags;1320 usb1 = ubh_get_usb_first(uspi);1321 usb3 = ubh_get_usb_third(uspi);1322 1323 /*1324 * Allow the "check" option to be passed as a remount option.1325 * It is not possible to change ufstype option during remount1326 */1327 ufstype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE;1328 new_mount_opt = 0;1329 ufs_set_opt (new_mount_opt, ONERROR_LOCK);1330 if (!ufs_parse_options (data, &new_mount_opt)) {1331 mutex_unlock(&UFS_SB(sb)->s_lock);1332 return -EINVAL;1333 }1334 if (!(new_mount_opt & UFS_MOUNT_UFSTYPE)) {1335 new_mount_opt |= ufstype;1336 } else if ((new_mount_opt & UFS_MOUNT_UFSTYPE) != ufstype) {1337 pr_err("ufstype can't be changed during remount\n");1338 mutex_unlock(&UFS_SB(sb)->s_lock);1339 return -EINVAL;1340 }1341 1342 if ((bool)(*mount_flags & SB_RDONLY) == sb_rdonly(sb)) {1343 UFS_SB(sb)->s_mount_opt = new_mount_opt;1344 mutex_unlock(&UFS_SB(sb)->s_lock);1345 return 0;1346 }1347 1348 /*1349 * fs was mouted as rw, remounting ro1350 */1351 if (*mount_flags & SB_RDONLY) {1352 ufs_put_super_internal(sb);1353 usb1->fs_time = ufs_get_seconds(sb);1354 if ((flags & UFS_ST_MASK) == UFS_ST_SUN1355 || (flags & UFS_ST_MASK) == UFS_ST_SUNOS1356 || (flags & UFS_ST_MASK) == UFS_ST_SUNx86) 1357 ufs_set_fs_state(sb, usb1, usb3,1358 UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));1359 ubh_mark_buffer_dirty (USPI_UBH(uspi));1360 sb->s_flags |= SB_RDONLY;1361 } else {1362 /*1363 * fs was mounted as ro, remounting rw1364 */1365#ifndef CONFIG_UFS_FS_WRITE1366 pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");1367 mutex_unlock(&UFS_SB(sb)->s_lock);1368 return -EINVAL;1369#else1370 if (ufstype != UFS_MOUNT_UFSTYPE_SUN && 1371 ufstype != UFS_MOUNT_UFSTYPE_SUNOS &&1372 ufstype != UFS_MOUNT_UFSTYPE_44BSD &&1373 ufstype != UFS_MOUNT_UFSTYPE_SUNx86 &&1374 ufstype != UFS_MOUNT_UFSTYPE_UFS2) {1375 pr_err("this ufstype is read-only supported\n");1376 mutex_unlock(&UFS_SB(sb)->s_lock);1377 return -EINVAL;1378 }1379 if (!ufs_read_cylinder_structures(sb)) {1380 pr_err("failed during remounting\n");1381 mutex_unlock(&UFS_SB(sb)->s_lock);1382 return -EPERM;1383 }1384 sb->s_flags &= ~SB_RDONLY;1385#endif1386 }1387 UFS_SB(sb)->s_mount_opt = new_mount_opt;1388 mutex_unlock(&UFS_SB(sb)->s_lock);1389 return 0;1390}1391 1392static int ufs_show_options(struct seq_file *seq, struct dentry *root)1393{1394 struct ufs_sb_info *sbi = UFS_SB(root->d_sb);1395 unsigned mval = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE;1396 const struct match_token *tp = tokens;1397 1398 while (tp->token != Opt_onerror_panic && tp->token != mval)1399 ++tp;1400 BUG_ON(tp->token == Opt_onerror_panic);1401 seq_printf(seq, ",%s", tp->pattern);1402 1403 mval = sbi->s_mount_opt & UFS_MOUNT_ONERROR;1404 while (tp->token != Opt_err && tp->token != mval)1405 ++tp;1406 BUG_ON(tp->token == Opt_err);1407 seq_printf(seq, ",%s", tp->pattern);1408 1409 return 0;1410}1411 1412static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf)1413{1414 struct super_block *sb = dentry->d_sb;1415 struct ufs_sb_private_info *uspi= UFS_SB(sb)->s_uspi;1416 unsigned flags = UFS_SB(sb)->s_flags;1417 u64 id = huge_encode_dev(sb->s_bdev->bd_dev);1418 1419 mutex_lock(&UFS_SB(sb)->s_lock);1420 1421 if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)1422 buf->f_type = UFS2_MAGIC;1423 else1424 buf->f_type = UFS_MAGIC;1425 1426 buf->f_blocks = uspi->s_dsize;1427 buf->f_bfree = ufs_freefrags(uspi);1428 buf->f_ffree = uspi->cs_total.cs_nifree;1429 buf->f_bsize = sb->s_blocksize;1430 buf->f_bavail = (buf->f_bfree > uspi->s_root_blocks)1431 ? (buf->f_bfree - uspi->s_root_blocks) : 0;1432 buf->f_files = uspi->s_ncg * uspi->s_ipg;1433 buf->f_namelen = UFS_MAXNAMLEN;1434 buf->f_fsid = u64_to_fsid(id);1435 1436 mutex_unlock(&UFS_SB(sb)->s_lock);1437 1438 return 0;1439}1440 1441static struct kmem_cache * ufs_inode_cachep;1442 1443static struct inode *ufs_alloc_inode(struct super_block *sb)1444{1445 struct ufs_inode_info *ei;1446 1447 ei = alloc_inode_sb(sb, ufs_inode_cachep, GFP_NOFS);1448 if (!ei)1449 return NULL;1450 1451 inode_set_iversion(&ei->vfs_inode, 1);1452 seqlock_init(&ei->meta_lock);1453 mutex_init(&ei->truncate_mutex);1454 return &ei->vfs_inode;1455}1456 1457static void ufs_free_in_core_inode(struct inode *inode)1458{1459 kmem_cache_free(ufs_inode_cachep, UFS_I(inode));1460}1461 1462static void init_once(void *foo)1463{1464 struct ufs_inode_info *ei = (struct ufs_inode_info *) foo;1465 1466 inode_init_once(&ei->vfs_inode);1467}1468 1469static int __init init_inodecache(void)1470{1471 ufs_inode_cachep = kmem_cache_create_usercopy("ufs_inode_cache",1472 sizeof(struct ufs_inode_info), 0,1473 (SLAB_RECLAIM_ACCOUNT | 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 1483static void destroy_inodecache(void)1484{1485 /*1486 * Make sure all delayed rcu free inodes are flushed before we1487 * destroy cache.1488 */1489 rcu_barrier();1490 kmem_cache_destroy(ufs_inode_cachep);1491}1492 1493static 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 1505static 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 1511static 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};1518MODULE_ALIAS_FS("ufs");1519 1520static 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;1529out:1530 destroy_inodecache();1531out1:1532 return err;1533}1534 1535static void __exit exit_ufs_fs(void)1536{1537 unregister_filesystem(&ufs_fs_type);1538 destroy_inodecache();1539}1540 1541module_init(init_ufs_fs)1542module_exit(exit_ufs_fs)1543MODULE_DESCRIPTION("UFS Filesystem");1544MODULE_LICENSE("GPL");1545