SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/ufs/super.c

   1 /*
   2  *  linux/fs/ufs/super.c
   3  *
   4  * Copyright (C) 1998
   5  * Daniel Pirkl <daniel.pirkl@email.cz>
   6  * Charles University, Faculty of Mathematics and Physics
   7  */
   8
   9 /* Derived from
  10  *
  11  *  linux/fs/ext2/super.c
  12  *
  13  * Copyright (C) 1992, 1993, 1994, 1995
  14  * Remy Card (card@masi.ibp.fr)
  15  * Laboratoire MASI - Institut Blaise Pascal
  16  * Universite Pierre et Marie Curie (Paris VI)
  17  *
  18  *  from
  19  *
  20  *  linux/fs/minix/inode.c
  21  *
  22  *  Copyright (C) 1991, 1992  Linus Torvalds
  23  *
  24  *  Big-endian to little-endian byte-swapping/bitmaps by
  25  *        David S. Miller (davem@caip.rutgers.edu), 1995
  26  */
  27
  28 /*
  29  * Inspired by
  30  *
  31  *  linux/fs/ufs/super.c
  32  *
  33  * Copyright (C) 1996
  34  * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
  35  * Laboratory for Computer Science Research Computing Facility
  36  * Rutgers, The State University of New Jersey
  37  *
  38  * Copyright (C) 1996  Eddie C. Dost  (ecd@skynet.be)
  39  *
  40  * Kernel module support added on 96/04/26 by
  41  * Stefan Reinauer <stepan@home.culture.mipt.ru>
  42  *
  43  * Module usage counts added on 96/04/29 by
  44  * Gertjan van Wingerde <gertjan@cs.vu.nl>
  45  *
  46  * Clean swab support on 19970406 by
  47  * Francois-Rene Rideau <fare@tunes.org>
  48  *
  49  * 4.4BSD (FreeBSD) support added on February 1st 1998 by
  50  * Niels Kristian Bech Jensen <nkbj@image.dk> partially based
  51  * on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>.
  52  *
  53  * NeXTstep support added on February 5th 1998 by
  54  * Niels Kristian Bech Jensen <nkbj@image.dk>.
  55  *
  56  * write support Daniel Pirkl <daniel.pirkl@email.cz> 1998
  57  *
  58  * HP/UX hfs filesystem support added by
  59  * Martin K. Petersen <mkp@mkp.net>, August 1999
  60  *
  61  * UFS2 (of FreeBSD 5.x) support added by
  62  * Niraj Kumar <niraj17@iitbombay.org>, Jan 2004
  63  *
  64  * UFS2 write support added by
  65  * Evgeniy Dushistov <dushistov@mail.ru>, 2007
  66  */
  67
  68
  69 #include <linux/module.h>
  70 #include <linux/bitops.h>
  71
  72 #include <stdarg.h>
  73
  74 #include <asm/uaccess.h>
  75 #include <asm/system.h>
  76
  77 #include <linux/errno.h>
  78 #include <linux/fs.h>
  79 #include <linux/ufs_fs.h>
  80 #include <linux/slab.h>
  81 #include <linux/time.h>
  82 #include <linux/stat.h>
  83 #include <linux/string.h>
  84 #include <linux/blkdev.h>
  85 #include <linux/init.h>
  86 #include <linux/parser.h>
  87 #include <linux/smp_lock.h>
  88 #include <linux/buffer_head.h>
  89 #include <linux/vfs.h>
  90 #include <linux/log2.h>
  91
  92 #include "swab.h"
  93 #include "util.h"
  94
  95 #ifdef CONFIG_UFS_DEBUG
  96 /*
  97  * Print contents of ufs_super_block, useful for debugging
  98  */
  99 static void ufs_print_super_stuff(struct super_block *sb,
 100                                   struct ufs_super_block_first *usb1,
 101                                   struct ufs_super_block_second *usb2,
 102                                   struct ufs_super_block_third *usb3)
 103 {
 104         u32 magic = fs32_to_cpu(sb, usb3->fs_magic);
 105
 106         printk("ufs_print_super_stuff\n");
 107         printk("  magic:     0x%x\n", magic);
 108         if (fs32_to_cpu(sb, usb3->fs_magic) == UFS2_MAGIC) {
 109                 printk("  fs_size:   %llu\n", (unsigned long long)
 110                        fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size));
 111                 printk("  fs_dsize:  %llu\n", (unsigned long long)
 112                        fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize));
 113                 printk("  bsize:         %u\n",
 114                        fs32_to_cpu(sb, usb1->fs_bsize));
 115                 printk("  fsize:         %u\n",
 116                        fs32_to_cpu(sb, usb1->fs_fsize));
 117                 printk("  fs_volname:  %s\n", usb2->fs_un.fs_u2.fs_volname);
 118                 printk("  fs_sblockloc: %llu\n", (unsigned long long)
 119                        fs64_to_cpu(sb, usb2->fs_un.fs_u2.fs_sblockloc));
 120                 printk("  cs_ndir(No of dirs):  %llu\n", (unsigned long long)
 121                        fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir));
 122                 printk("  cs_nbfree(No of free blocks):  %llu\n",
 123                        (unsigned long long)
 124                        fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_nbfree));
 125                 printk(KERN_INFO"  cs_nifree(Num of free inodes): %llu\n",
 126                        (unsigned long long)
 127                        fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nifree));
 128                 printk(KERN_INFO"  cs_nffree(Num of free frags): %llu\n",
 129                        (unsigned long long)
 130                        fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nffree));
 131         } else {
 132                 printk(" sblkno:      %u\n", fs32_to_cpu(sb, usb1->fs_sblkno));
 133                 printk(" cblkno:      %u\n", fs32_to_cpu(sb, usb1->fs_cblkno));
 134                 printk(" iblkno:      %u\n", fs32_to_cpu(sb, usb1->fs_iblkno));
 135                 printk(" dblkno:      %u\n", fs32_to_cpu(sb, usb1->fs_dblkno));
 136                 printk(" cgoffset:    %u\n",
 137                        fs32_to_cpu(sb, usb1->fs_cgoffset));
 138                 printk(" ~cgmask:     0x%x\n",
 139                        ~fs32_to_cpu(sb, usb1->fs_cgmask));
 140                 printk(" size:        %u\n", fs32_to_cpu(sb, usb1->fs_size));
 141                 printk(" dsize:       %u\n", fs32_to_cpu(sb, usb1->fs_dsize));
 142                 printk(" ncg:         %u\n", fs32_to_cpu(sb, usb1->fs_ncg));
 143                 printk(" bsize:       %u\n", fs32_to_cpu(sb, usb1->fs_bsize));
 144                 printk(" fsize:       %u\n", fs32_to_cpu(sb, usb1->fs_fsize));
 145                 printk(" frag:        %u\n", fs32_to_cpu(sb, usb1->fs_frag));
 146                 printk(" fragshift:   %u\n",
 147                        fs32_to_cpu(sb, usb1->fs_fragshift));
 148                 printk(" ~fmask:      %u\n", ~fs32_to_cpu(sb, usb1->fs_fmask));
 149                 printk(" fshift:      %u\n", fs32_to_cpu(sb, usb1->fs_fshift));
 150                 printk(" sbsize:      %u\n", fs32_to_cpu(sb, usb1->fs_sbsize));
 151                 printk(" spc:         %u\n", fs32_to_cpu(sb, usb1->fs_spc));
 152                 printk(" cpg:         %u\n", fs32_to_cpu(sb, usb1->fs_cpg));
 153                 printk(" ipg:         %u\n", fs32_to_cpu(sb, usb1->fs_ipg));
 154                 printk(" fpg:         %u\n", fs32_to_cpu(sb, usb1->fs_fpg));
 155                 printk(" csaddr:      %u\n", fs32_to_cpu(sb, usb1->fs_csaddr));
 156                 printk(" cssize:      %u\n", fs32_to_cpu(sb, usb1->fs_cssize));
 157                 printk(" cgsize:      %u\n", fs32_to_cpu(sb, usb1->fs_cgsize));
 158                 printk(" fstodb:      %u\n",
 159                        fs32_to_cpu(sb, usb1->fs_fsbtodb));
 160                 printk(" nrpos:       %u\n", fs32_to_cpu(sb, usb3->fs_nrpos));
 161                 printk(" ndir         %u\n",
 162                        fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir));
 163                 printk(" nifree       %u\n",
 164                        fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree));
 165                 printk(" nbfree       %u\n",
 166                        fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree));
 167                 printk(" nffree       %u\n",
 168                        fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree));
 169         }
 170         printk("\n");
 171 }
 172
 173 /*
 174  * Print contents of ufs_cylinder_group, useful for debugging
 175  */
 176 static void ufs_print_cylinder_stuff(struct super_block *sb,
 177                                      struct ufs_cylinder_group *cg)
 178 {
 179         printk("\nufs_print_cylinder_stuff\n");
 180         printk("size of ucg: %zu\n", sizeof(struct ufs_cylinder_group));
 181         printk("  magic:        %x\n", fs32_to_cpu(sb, cg->cg_magic));
 182         printk("  time:         %u\n", fs32_to_cpu(sb, cg->cg_time));
 183         printk("  cgx:          %u\n", fs32_to_cpu(sb, cg->cg_cgx));
 184         printk("  ncyl:         %u\n", fs16_to_cpu(sb, cg->cg_ncyl));
 185         printk("  niblk:        %u\n", fs16_to_cpu(sb, cg->cg_niblk));
 186         printk("  ndblk:        %u\n", fs32_to_cpu(sb, cg->cg_ndblk));
 187         printk("  cs_ndir:      %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_ndir));
 188         printk("  cs_nbfree:    %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nbfree));
 189         printk("  cs_nifree:    %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nifree));
 190         printk("  cs_nffree:    %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nffree));
 191         printk("  rotor:        %u\n", fs32_to_cpu(sb, cg->cg_rotor));
 192         printk("  frotor:       %u\n", fs32_to_cpu(sb, cg->cg_frotor));
 193         printk("  irotor:       %u\n", fs32_to_cpu(sb, cg->cg_irotor));
 194         printk("  frsum:        %u, %u, %u, %u, %u, %u, %u, %u\n",
 195             fs32_to_cpu(sb, cg->cg_frsum[0]), fs32_to_cpu(sb, cg->cg_frsum[1]),
 196             fs32_to_cpu(sb, cg->cg_frsum[2]), fs32_to_cpu(sb, cg->cg_frsum[3]),
 197             fs32_to_cpu(sb, cg->cg_frsum[4]), fs32_to_cpu(sb, cg->cg_frsum[5]),
 198             fs32_to_cpu(sb, cg->cg_frsum[6]), fs32_to_cpu(sb, cg->cg_frsum[7]));
 199         printk("  btotoff:      %u\n", fs32_to_cpu(sb, cg->cg_btotoff));
 200         printk("  boff:         %u\n", fs32_to_cpu(sb, cg->cg_boff));
 201         printk("  iuseoff:      %u\n", fs32_to_cpu(sb, cg->cg_iusedoff));
 202         printk("  freeoff:      %u\n", fs32_to_cpu(sb, cg->cg_freeoff));
 203         printk("  nextfreeoff:  %u\n", fs32_to_cpu(sb, cg->cg_nextfreeoff));
 204         printk("  clustersumoff %u\n",
 205                fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clustersumoff));
 206         printk("  clusteroff    %u\n",
 207                fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clusteroff));
 208         printk("  nclusterblks  %u\n",
 209                fs32_to_cpu(sb, cg->cg_u.cg_44.cg_nclusterblks));
 210         printk("\n");
 211 }
 212 #else
 213 #  define ufs_print_super_stuff(sb, usb1, usb2, usb3) /**/
 214 #  define ufs_print_cylinder_stuff(sb, cg) /**/
 215 #endif /* CONFIG_UFS_DEBUG */
 216
 217 static const struct super_operations ufs_super_ops;
 218
 219 static char error_buf[1024];
 220
 221 void ufs_error (struct super_block * sb, const char * function,
 222         const char * fmt, ...)
 223 {
 224         struct ufs_sb_private_info * uspi;
 225         struct ufs_super_block_first * usb1;
 226         va_list args;
 227
 228         uspi = UFS_SB(sb)->s_uspi;
 229         usb1 = ubh_get_usb_first(uspi);
 230
 231         if (!(sb->s_flags & MS_RDONLY)) {
 232                 usb1->fs_clean = UFS_FSBAD;
 233                 ubh_mark_buffer_dirty(USPI_UBH(uspi));
 234                 sb->s_dirt = 1;
 235                 sb->s_flags |= MS_RDONLY;
 236         }
 237         va_start (args, fmt);
 238         vsnprintf (error_buf, sizeof(error_buf), fmt, args);
 239         va_end (args);
 240         switch (UFS_SB(sb)->s_mount_opt & UFS_MOUNT_ONERROR) {
 241         case UFS_MOUNT_ONERROR_PANIC:
 242                 panic ("UFS-fs panic (device %s): %s: %s\n",
 243                         sb->s_id, function, error_buf);
 244
 245         case UFS_MOUNT_ONERROR_LOCK:
 246         case UFS_MOUNT_ONERROR_UMOUNT:
 247         case UFS_MOUNT_ONERROR_REPAIR:
 248                 printk (KERN_CRIT "UFS-fs error (device %s): %s: %s\n",
 249                         sb->s_id, function, error_buf);
 250         }
 251 }
 252
 253 void ufs_panic (struct super_block * sb, const char * function,
 254         const char * fmt, ...)
 255 {
 256         struct ufs_sb_private_info * uspi;
 257         struct ufs_super_block_first * usb1;
 258         va_list args;
 259
 260         uspi = UFS_SB(sb)->s_uspi;
 261         usb1 = ubh_get_usb_first(uspi);
 262
 263         if (!(sb->s_flags & MS_RDONLY)) {
 264                 usb1->fs_clean = UFS_FSBAD;
 265                 ubh_mark_buffer_dirty(USPI_UBH(uspi));
 266                 sb->s_dirt = 1;
 267         }
 268         va_start (args, fmt);
 269         vsnprintf (error_buf, sizeof(error_buf), fmt, args);
 270         va_end (args);
 271         sb->s_flags |= MS_RDONLY;
 272         printk (KERN_CRIT "UFS-fs panic (device %s): %s: %s\n",
 273                 sb->s_id, function, error_buf);
 274 }
 275
 276 void ufs_warning (struct super_block * sb, const char * function,
 277         const char * fmt, ...)
 278 {
 279         va_list args;
 280
 281         va_start (args, fmt);
 282         vsnprintf (error_buf, sizeof(error_buf), fmt, args);
 283         va_end (args);
 284         printk (KERN_WARNING "UFS-fs warning (device %s): %s: %s\n",
 285                 sb->s_id, function, error_buf);
 286 }
 287
 288 enum {
 289         Opt_type_old, Opt_type_sunx86, Opt_type_sun, Opt_type_sunos, Opt_type_44bsd,
 290         Opt_type_ufs2, Opt_type_hp, Opt_type_nextstepcd, Opt_type_nextstep,
 291         Opt_type_openstep, Opt_onerror_panic, Opt_onerror_lock,
 292         Opt_onerror_umount, Opt_onerror_repair, Opt_err
 293 };
 294
 295 static match_table_t tokens = {
 296         {Opt_type_old, "ufstype=old"},
 297         {Opt_type_sunx86, "ufstype=sunx86"},
 298         {Opt_type_sun, "ufstype=sun"},
 299         {Opt_type_sunos, "ufstype=sunos"},
 300         {Opt_type_44bsd, "ufstype=44bsd"},
 301         {Opt_type_ufs2, "ufstype=ufs2"},
 302         {Opt_type_ufs2, "ufstype=5xbsd"},
 303         {Opt_type_hp, "ufstype=hp"},
 304         {Opt_type_nextstepcd, "ufstype=nextstep-cd"},
 305         {Opt_type_nextstep, "ufstype=nextstep"},
 306         {Opt_type_openstep, "ufstype=openstep"},
 307         {Opt_onerror_panic, "onerror=panic"},
 308         {Opt_onerror_lock, "onerror=lock"},
 309         {Opt_onerror_umount, "onerror=umount"},
 310         {Opt_onerror_repair, "onerror=repair"},
 311         {Opt_err, NULL}
 312 };
 313
 314 static int ufs_parse_options (char * options, unsigned * mount_options)
 315 {
 316         char * p;
 317
 318         UFSD("ENTER\n");
 319
 320         if (!options)
 321                 return 1;
 322
 323         while ((p = strsep(&options, ",")) != NULL) {
 324                 substring_t args[MAX_OPT_ARGS];
 325                 int token;
 326                 if (!*p)
 327                         continue;
 328
 329                 token = match_token(p, tokens, args);
 330                 switch (token) {
 331                 case Opt_type_old:
 332                         ufs_clear_opt (*mount_options, UFSTYPE);
 333                         ufs_set_opt (*mount_options, UFSTYPE_OLD);
 334                         break;
 335                 case Opt_type_sunx86:
 336                         ufs_clear_opt (*mount_options, UFSTYPE);
 337                         ufs_set_opt (*mount_options, UFSTYPE_SUNx86);
 338                         break;
 339                 case Opt_type_sun:
 340                         ufs_clear_opt (*mount_options, UFSTYPE);
 341                         ufs_set_opt (*mount_options, UFSTYPE_SUN);
 342                         break;
 343                 case Opt_type_sunos:
 344                         ufs_clear_opt(*mount_options, UFSTYPE);
 345                         ufs_set_opt(*mount_options, UFSTYPE_SUNOS);
 346                         break;
 347                 case Opt_type_44bsd:
 348                         ufs_clear_opt (*mount_options, UFSTYPE);
 349                         ufs_set_opt (*mount_options, UFSTYPE_44BSD);
 350                         break;
 351                 case Opt_type_ufs2:
 352                         ufs_clear_opt(*mount_options, UFSTYPE);
 353                         ufs_set_opt(*mount_options, UFSTYPE_UFS2);
 354                         break;
 355                 case Opt_type_hp:
 356                         ufs_clear_opt (*mount_options, UFSTYPE);
 357                         ufs_set_opt (*mount_options, UFSTYPE_HP);
 358                         break;
 359                 case Opt_type_nextstepcd:
 360                         ufs_clear_opt (*mount_options, UFSTYPE);
 361                         ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP_CD);
 362                         break;
 363                 case Opt_type_nextstep:
 364                         ufs_clear_opt (*mount_options, UFSTYPE);
 365                         ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP);
 366                         break;
 367                 case Opt_type_openstep:
 368                         ufs_clear_opt (*mount_options, UFSTYPE);
 369                         ufs_set_opt (*mount_options, UFSTYPE_OPENSTEP);
 370                         break;
 371                 case Opt_onerror_panic:
 372                         ufs_clear_opt (*mount_options, ONERROR);
 373                         ufs_set_opt (*mount_options, ONERROR_PANIC);
 374                         break;
 375                 case Opt_onerror_lock:
 376                         ufs_clear_opt (*mount_options, ONERROR);
 377                         ufs_set_opt (*mount_options, ONERROR_LOCK);
 378                         break;
 379                 case Opt_onerror_umount:
 380                         ufs_clear_opt (*mount_options, ONERROR);
 381                         ufs_set_opt (*mount_options, ONERROR_UMOUNT);
 382                         break;
 383                 case Opt_onerror_repair:
 384                         printk("UFS-fs: Unable to do repair on error, "
 385                                 "will lock lock instead\n");
 386                         ufs_clear_opt (*mount_options, ONERROR);
 387                         ufs_set_opt (*mount_options, ONERROR_REPAIR);
 388                         break;
 389                 default:
 390                         printk("UFS-fs: Invalid option: \"%s\" "
 391                                         "or missing value\n", p);
 392                         return 0;
 393                 }
 394         }
 395         return 1;
 396 }
 397
 398 /*
 399  * Diffrent types of UFS hold fs_cstotal in different
 400  * places, and use diffrent data structure for it.
 401  * To make things simplier we just copy fs_cstotal to ufs_sb_private_info
 402  */
 403 static void ufs_setup_cstotal(struct super_block *sb)
 404 {
 405         struct ufs_sb_info *sbi = UFS_SB(sb);
 406         struct ufs_sb_private_info *uspi = sbi->s_uspi;
 407         struct ufs_super_block_first *usb1;
 408         struct ufs_super_block_second *usb2;
 409         struct ufs_super_block_third *usb3;
 410         unsigned mtype = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE;
 411
 412         UFSD("ENTER, mtype=%u\n", mtype);
 413         usb1 = ubh_get_usb_first(uspi);
 414         usb2 = ubh_get_usb_second(uspi);
 415         usb3 = ubh_get_usb_third(uspi);
 416
 417         if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&
 418              (usb1->fs_flags & UFS_FLAGS_UPDATED)) ||
 419             mtype == UFS_MOUNT_UFSTYPE_UFS2) {
 420                 /*we have statistic in different place, then usual*/
 421                 uspi->cs_total.cs_ndir = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir);
 422                 uspi->cs_total.cs_nbfree = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_nbfree);
 423                 uspi->cs_total.cs_nifree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nifree);
 424                 uspi->cs_total.cs_nffree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nffree);
 425         } else {
 426                 uspi->cs_total.cs_ndir = fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir);
 427                 uspi->cs_total.cs_nbfree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree);
 428                 uspi->cs_total.cs_nifree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree);
 429                 uspi->cs_total.cs_nffree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree);
 430         }
 431         UFSD("EXIT\n");
 432 }
 433
 434 /*
 435  * Read on-disk structures associated with cylinder groups
 436  */
 437 static int ufs_read_cylinder_structures(struct super_block *sb)
 438 {
 439         struct ufs_sb_info *sbi = UFS_SB(sb);
 440         struct ufs_sb_private_info *uspi = sbi->s_uspi;
 441         struct ufs_buffer_head * ubh;
 442         unsigned char * base, * space;
 443         unsigned size, blks, i;
 444         struct ufs_super_block_third *usb3;
 445
 446         UFSD("ENTER\n");
 447
 448         usb3 = ubh_get_usb_third(uspi);
 449         /*
 450          * Read cs structures from (usually) first data block
 451          * on the device.
 452          */
 453         size = uspi->s_cssize;
 454         blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
 455         base = space = kmalloc(size, GFP_KERNEL);
 456         if (!base)
 457                 goto failed;
 458         sbi->s_csp = (struct ufs_csum *)space;
 459         for (i = 0; i < blks; i += uspi->s_fpb) {
 460                 size = uspi->s_bsize;
 461                 if (i + uspi->s_fpb > blks)
 462                         size = (blks - i) * uspi->s_fsize;
 463
 464                 ubh = ubh_bread(sb, uspi->s_csaddr + i, size);
 465
 466                 if (!ubh)
 467                         goto failed;
 468
 469                 ubh_ubhcpymem (space, ubh, size);
 470
 471                 space += size;
 472                 ubh_brelse (ubh);
 473                 ubh = NULL;
 474         }
 475
 476         /*
 477          * Read cylinder group (we read only first fragment from block
 478          * at this time) and prepare internal data structures for cg caching.
 479          */
 480         if (!(sbi->s_ucg = kmalloc (sizeof(struct buffer_head *) * uspi->s_ncg, GFP_KERNEL)))
 481                 goto failed;
 482         for (i = 0; i < uspi->s_ncg; i++)
 483                 sbi->s_ucg[i] = NULL;
 484         for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
 485                 sbi->s_ucpi[i] = NULL;
 486                 sbi->s_cgno[i] = UFS_CGNO_EMPTY;
 487         }
 488         for (i = 0; i < uspi->s_ncg; i++) {
 489                 UFSD("read cg %u\n", i);
 490                 if (!(sbi->s_ucg[i] = sb_bread(sb, ufs_cgcmin(i))))
 491                         goto failed;
 492                 if (!ufs_cg_chkmagic (sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data))
 493                         goto failed;
 494
 495                 ufs_print_cylinder_stuff(sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data);
 496         }
 497         for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
 498                 if (!(sbi->s_ucpi[i] = kmalloc (sizeof(struct ufs_cg_private_info), GFP_KERNEL)))
 499                         goto failed;
 500                 sbi->s_cgno[i] = UFS_CGNO_EMPTY;
 501         }
 502         sbi->s_cg_loaded = 0;
 503         UFSD("EXIT\n");
 504         return 1;
 505
 506 failed:
 507         kfree (base);
 508         if (sbi->s_ucg) {
 509                 for (i = 0; i < uspi->s_ncg; i++)
 510                         if (sbi->s_ucg[i])
 511                                 brelse (sbi->s_ucg[i]);
 512                 kfree (sbi->s_ucg);
 513                 for (i = 0; i < UFS_MAX_GROUP_LOADED; i++)
 514                         kfree (sbi->s_ucpi[i]);
 515         }
 516         UFSD("EXIT (FAILED)\n");
 517         return 0;
 518 }
 519
 520 /*
 521  * Sync our internal copy of fs_cstotal with disk
 522  */
 523 static void ufs_put_cstotal(struct super_block *sb)
 524 {
 525         unsigned mtype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE;
 526         struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
 527         struct ufs_super_block_first *usb1;
 528         struct ufs_super_block_second *usb2;
 529         struct ufs_super_block_third *usb3;
 530
 531         UFSD("ENTER\n");
 532         usb1 = ubh_get_usb_first(uspi);
 533         usb2 = ubh_get_usb_second(uspi);
 534         usb3 = ubh_get_usb_third(uspi);
 535
 536         if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&
 537              (usb1->fs_flags & UFS_FLAGS_UPDATED)) ||
 538             mtype == UFS_MOUNT_UFSTYPE_UFS2) {
 539                 /*we have statistic in different place, then usual*/
 540                 usb2->fs_un.fs_u2.cs_ndir =
 541                         cpu_to_fs64(sb, uspi->cs_total.cs_ndir);
 542                 usb2->fs_un.fs_u2.cs_nbfree =
 543                         cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);
 544                 usb3->fs_un1.fs_u2.cs_nifree =
 545                         cpu_to_fs64(sb, uspi->cs_total.cs_nifree);
 546                 usb3->fs_un1.fs_u2.cs_nffree =
 547                         cpu_to_fs64(sb, uspi->cs_total.cs_nffree);
 548         } else {
 549                 usb1->fs_cstotal.cs_ndir =
 550                         cpu_to_fs32(sb, uspi->cs_total.cs_ndir);
 551                 usb1->fs_cstotal.cs_nbfree =
 552                         cpu_to_fs32(sb, uspi->cs_total.cs_nbfree);
 553                 usb1->fs_cstotal.cs_nifree =
 554                         cpu_to_fs32(sb, uspi->cs_total.cs_nifree);
 555                 usb1->fs_cstotal.cs_nffree =
 556                         cpu_to_fs32(sb, uspi->cs_total.cs_nffree);
 557         }
 558         ubh_mark_buffer_dirty(USPI_UBH(uspi));
 559         ufs_print_super_stuff(sb, usb1, usb2, usb3);
 560         UFSD("EXIT\n");
 561 }
 562
 563 /**
 564  * ufs_put_super_internal() - put on-disk intrenal structures
 565  * @sb: pointer to super_block structure
 566  * Put on-disk structures associated with cylinder groups
 567  * and write them back to disk, also update cs_total on disk
 568  */
 569 static void ufs_put_super_internal(struct super_block *sb)
 570 {
 571         struct ufs_sb_info *sbi = UFS_SB(sb);
 572         struct ufs_sb_private_info *uspi = sbi->s_uspi;
 573         struct ufs_buffer_head * ubh;
 574         unsigned char * base, * space;
 575         unsigned blks, size, i;
 576
 577
 578         UFSD("ENTER\n");
 579         ufs_put_cstotal(sb);
 580         size = uspi->s_cssize;
 581         blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
 582         base = space = (char*) sbi->s_csp;
 583         for (i = 0; i < blks; i += uspi->s_fpb) {
 584                 size = uspi->s_bsize;
 585                 if (i + uspi->s_fpb > blks)
 586                         size = (blks - i) * uspi->s_fsize;
 587
 588                 ubh = ubh_bread(sb, uspi->s_csaddr + i, size);
 589
 590                 ubh_memcpyubh (ubh, space, size);
 591                 space += size;
 592                 ubh_mark_buffer_uptodate (ubh, 1);
 593                 ubh_mark_buffer_dirty (ubh);
 594                 ubh_brelse (ubh);
 595         }
 596         for (i = 0; i < sbi->s_cg_loaded; i++) {
 597                 ufs_put_cylinder (sb, i);
 598                 kfree (sbi->s_ucpi[i]);
 599         }
 600         for (; i < UFS_MAX_GROUP_LOADED; i++)
 601                 kfree (sbi->s_ucpi[i]);
 602         for (i = 0; i < uspi->s_ncg; i++)
 603                 brelse (sbi->s_ucg[i]);
 604         kfree (sbi->s_ucg);
 605         kfree (base);
 606         UFSD("EXIT\n");
 607 }
 608
 609 static int ufs_fill_super(struct super_block *sb, void *data, int silent)
 610 {
 611         struct ufs_sb_info * sbi;
 612         struct ufs_sb_private_info * uspi;
 613         struct ufs_super_block_first * usb1;
 614         struct ufs_super_block_second * usb2;
 615         struct ufs_super_block_third * usb3;
 616         struct ufs_buffer_head * ubh;
 617         struct inode *inode;
 618         unsigned block_size, super_block_size;
 619         unsigned flags;
 620         unsigned super_block_offset;
 621
 622         uspi = NULL;
 623         ubh = NULL;
 624         flags = 0;
 625
 626         UFSD("ENTER\n");
 627
 628         sbi = kzalloc(sizeof(struct ufs_sb_info), GFP_KERNEL);
 629         if (!sbi)
 630                 goto failed_nomem;
 631         sb->s_fs_info = sbi;
 632
 633         UFSD("flag %u\n", (int)(sb->s_flags & MS_RDONLY));
 634
 635 #ifndef CONFIG_UFS_FS_WRITE
 636         if (!(sb->s_flags & MS_RDONLY)) {
 637                 printk("ufs was compiled with read-only support, "
 638                 "can't be mounted as read-write\n");
 639                 goto failed;
 640         }
 641 #endif
 642         /*
 643          * Set default mount options
 644          * Parse mount options
 645          */
 646         sbi->s_mount_opt = 0;
 647         ufs_set_opt (sbi->s_mount_opt, ONERROR_LOCK);
 648         if (!ufs_parse_options ((char *) data, &sbi->s_mount_opt)) {
 649                 printk("wrong mount options\n");
 650                 goto failed;
 651         }
 652         if (!(sbi->s_mount_opt & UFS_MOUNT_UFSTYPE)) {
 653                 if (!silent)
 654                         printk("You didn't specify the type of your ufs filesystem\n\n"
 655                         "mount -t ufs -o ufstype="
 656                         "sun|sunx86|44bsd|ufs2|5xbsd|old|hp|nextstep|nextstep-cd|openstep ...\n\n"
 657                         ">>>WARNING<<< Wrong ufstype may corrupt your filesystem, "
 658                         "default is ufstype=old\n");
 659                 ufs_set_opt (sbi->s_mount_opt, UFSTYPE_OLD);
 660         }
 661
 662         uspi = kzalloc(sizeof(struct ufs_sb_private_info), GFP_KERNEL);
 663         sbi->s_uspi = uspi;
 664         if (!uspi)
 665                 goto failed;
 666         uspi->s_dirblksize = UFS_SECTOR_SIZE;
 667         super_block_offset=UFS_SBLOCK;
 668
 669         /* Keep 2Gig file limit. Some UFS variants need to override
 670            this but as I don't know which I'll let those in the know loosen
 671            the rules */
 672         switch (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) {
 673         case UFS_MOUNT_UFSTYPE_44BSD:
 674                 UFSD("ufstype=44bsd\n");
 675                 uspi->s_fsize = block_size = 512;
 676                 uspi->s_fmask = ~(512 - 1);
 677                 uspi->s_fshift = 9;
 678                 uspi->s_sbsize = super_block_size = 1536;
 679                 uspi->s_sbbase = 0;
 680                 flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
 681                 break;
 682         case UFS_MOUNT_UFSTYPE_UFS2:
 683                 UFSD("ufstype=ufs2\n");
 684                 super_block_offset=SBLOCK_UFS2;
 685                 uspi->s_fsize = block_size = 512;
 686                 uspi->s_fmask = ~(512 - 1);
 687                 uspi->s_fshift = 9;
 688                 uspi->s_sbsize = super_block_size = 1536;
 689                 uspi->s_sbbase =  0;
 690                 flags |= UFS_TYPE_UFS2 | UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
 691                 break;
 692
 693         case UFS_MOUNT_UFSTYPE_SUN:
 694                 UFSD("ufstype=sun\n");
 695                 uspi->s_fsize = block_size = 1024;
 696                 uspi->s_fmask = ~(1024 - 1);
 697                 uspi->s_fshift = 10;
 698                 uspi->s_sbsize = super_block_size = 2048;
 699                 uspi->s_sbbase = 0;
 700                 uspi->s_maxsymlinklen = 0; /* Not supported on disk */
 701                 flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUN | UFS_CG_SUN;
 702                 break;
 703
 704         case UFS_MOUNT_UFSTYPE_SUNOS:
 705                 UFSD(("ufstype=sunos\n"))
 706                 uspi->s_fsize = block_size = 1024;
 707                 uspi->s_fmask = ~(1024 - 1);
 708                 uspi->s_fshift = 10;
 709                 uspi->s_sbsize = 2048;
 710                 super_block_size = 2048;
 711                 uspi->s_sbbase = 0;
 712                 uspi->s_maxsymlinklen = 0; /* Not supported on disk */
 713                 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_SUNOS | UFS_CG_SUN;
 714                 break;
 715
 716         case UFS_MOUNT_UFSTYPE_SUNx86:
 717                 UFSD("ufstype=sunx86\n");
 718                 uspi->s_fsize = block_size = 1024;
 719                 uspi->s_fmask = ~(1024 - 1);
 720                 uspi->s_fshift = 10;
 721                 uspi->s_sbsize = super_block_size = 2048;
 722                 uspi->s_sbbase = 0;
 723                 uspi->s_maxsymlinklen = 0; /* Not supported on disk */
 724                 flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUNx86 | UFS_CG_SUN;
 725                 break;
 726
 727         case UFS_MOUNT_UFSTYPE_OLD:
 728                 UFSD("ufstype=old\n");
 729                 uspi->s_fsize = block_size = 1024;
 730                 uspi->s_fmask = ~(1024 - 1);
 731                 uspi->s_fshift = 10;
 732                 uspi->s_sbsize = super_block_size = 2048;
 733                 uspi->s_sbbase = 0;
 734                 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
 735                 if (!(sb->s_flags & MS_RDONLY)) {
 736                         if (!silent)
 737                                 printk(KERN_INFO "ufstype=old is supported read-only\n");
 738                         sb->s_flags |= MS_RDONLY;
 739                 }
 740                 break;
 741
 742         case UFS_MOUNT_UFSTYPE_NEXTSTEP:
 743                 /*TODO: check may be we need set special dir block size?*/
 744                 UFSD("ufstype=nextstep\n");
 745                 uspi->s_fsize = block_size = 1024;
 746                 uspi->s_fmask = ~(1024 - 1);
 747                 uspi->s_fshift = 10;
 748                 uspi->s_sbsize = super_block_size = 2048;
 749                 uspi->s_sbbase = 0;
 750                 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
 751                 if (!(sb->s_flags & MS_RDONLY)) {
 752                         if (!silent)
 753                                 printk(KERN_INFO "ufstype=nextstep is supported read-only\n");
 754                         sb->s_flags |= MS_RDONLY;
 755                 }
 756                 break;
 757
 758         case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD:
 759                 /*TODO: check may be we need set special dir block size?*/
 760                 UFSD("ufstype=nextstep-cd\n");
 761                 uspi->s_fsize = block_size = 2048;
 762                 uspi->s_fmask = ~(2048 - 1);
 763                 uspi->s_fshift = 11;
 764                 uspi->s_sbsize = super_block_size = 2048;
 765                 uspi->s_sbbase = 0;
 766                 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
 767                 if (!(sb->s_flags & MS_RDONLY)) {
 768                         if (!silent)
 769                                 printk(KERN_INFO "ufstype=nextstep-cd is supported read-only\n");
 770                         sb->s_flags |= MS_RDONLY;
 771                 }
 772                 break;
 773
 774         case UFS_MOUNT_UFSTYPE_OPENSTEP:
 775                 UFSD("ufstype=openstep\n");
 776                 uspi->s_fsize = block_size = 1024;
 777                 uspi->s_fmask = ~(1024 - 1);
 778                 uspi->s_fshift = 10;
 779                 uspi->s_sbsize = super_block_size = 2048;
 780                 uspi->s_sbbase = 0;
 781                 uspi->s_dirblksize = 1024;
 782                 flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
 783                 if (!(sb->s_flags & MS_RDONLY)) {
 784                         if (!silent)
 785                                 printk(KERN_INFO "ufstype=openstep is supported read-only\n");
 786                         sb->s_flags |= MS_RDONLY;
 787                 }
 788                 break;
 789
 790         case UFS_MOUNT_UFSTYPE_HP:
 791                 UFSD("ufstype=hp\n");
 792                 uspi->s_fsize = block_size = 1024;
 793                 uspi->s_fmask = ~(1024 - 1);
 794                 uspi->s_fshift = 10;
 795                 uspi->s_sbsize = super_block_size = 2048;
 796                 uspi->s_sbbase = 0;
 797                 flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
 798                 if (!(sb->s_flags & MS_RDONLY)) {
 799                         if (!silent)
 800                                 printk(KERN_INFO "ufstype=hp is supported read-only\n");
 801                         sb->s_flags |= MS_RDONLY;
 802                 }
 803                 break;
 804         default:
 805                 if (!silent)
 806                         printk("unknown ufstype\n");
 807                 goto failed;
 808         }
 809
 810 again:
 811         if (!sb_set_blocksize(sb, block_size)) {
 812                 printk(KERN_ERR "UFS: failed to set blocksize\n");
 813                 goto failed;
 814         }
 815
 816         /*
 817          * read ufs super block from device
 818          */
 819
 820         ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size);
 821
 822         if (!ubh)
 823             goto failed;
 824
 825         usb1 = ubh_get_usb_first(uspi);
 826         usb2 = ubh_get_usb_second(uspi);
 827         usb3 = ubh_get_usb_third(uspi);
 828
 829         /* Sort out mod used on SunOS 4.1.3 for fs_state */
 830         uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);
 831         if (((flags & UFS_ST_MASK) == UFS_ST_SUNOS) &&
 832             (uspi->s_postblformat != UFS_42POSTBLFMT)) {
 833                 flags &= ~UFS_ST_MASK;
 834                 flags |=  UFS_ST_SUN;
 835         }
 836
 837         /*
 838          * Check ufs magic number
 839          */
 840         sbi->s_bytesex = BYTESEX_LE;
 841         switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
 842                 case UFS_MAGIC:
 843                 case UFS2_MAGIC:
 844                 case UFS_MAGIC_LFN:
 845                 case UFS_MAGIC_FEA:
 846                 case UFS_MAGIC_4GB:
 847                         goto magic_found;
 848         }
 849         sbi->s_bytesex = BYTESEX_BE;
 850         switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
 851                 case UFS_MAGIC:
 852                 case UFS2_MAGIC:
 853                 case UFS_MAGIC_LFN:
 854                 case UFS_MAGIC_FEA:
 855                 case UFS_MAGIC_4GB:
 856                         goto magic_found;
 857         }
 858
 859         if ((((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP)
 860           || ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD)
 861           || ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_OPENSTEP))
 862           && uspi->s_sbbase < 256) {
 863                 ubh_brelse_uspi(uspi);
 864                 ubh = NULL;
 865                 uspi->s_sbbase += 8;
 866                 goto again;
 867         }
 868         if (!silent)
 869                 printk("ufs_read_super: bad magic number\n");
 870         goto failed;
 871
 872 magic_found:
 873         /*
 874          * Check block and fragment sizes
 875          */
 876         uspi->s_bsize = fs32_to_cpu(sb, usb1->fs_bsize);
 877         uspi->s_fsize = fs32_to_cpu(sb, usb1->fs_fsize);
 878         uspi->s_sbsize = fs32_to_cpu(sb, usb1->fs_sbsize);
 879         uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
 880         uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
 881
 882         if (!is_power_of_2(uspi->s_fsize)) {
 883                 printk(KERN_ERR "ufs_read_super: fragment size %u is not a power of 2\n",
 884                         uspi->s_fsize);
 885                         goto failed;
 886         }
 887         if (uspi->s_fsize < 512) {
 888                 printk(KERN_ERR "ufs_read_super: fragment size %u is too small\n",
 889                         uspi->s_fsize);
 890                 goto failed;
 891         }
 892         if (uspi->s_fsize > 4096) {
 893                 printk(KERN_ERR "ufs_read_super: fragment size %u is too large\n",
 894                         uspi->s_fsize);
 895                 goto failed;
 896         }
 897         if (!is_power_of_2(uspi->s_bsize)) {
 898                 printk(KERN_ERR "ufs_read_super: block size %u is not a power of 2\n",
 899                         uspi->s_bsize);
 900                 goto failed;
 901         }
 902         if (uspi->s_bsize < 4096) {
 903                 printk(KERN_ERR "ufs_read_super: block size %u is too small\n",
 904                         uspi->s_bsize);
 905                 goto failed;
 906         }
 907         if (uspi->s_bsize / uspi->s_fsize > 8) {
 908                 printk(KERN_ERR "ufs_read_super: too many fragments per block (%u)\n",
 909                         uspi->s_bsize / uspi->s_fsize);
 910                 goto failed;
 911         }
 912         if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) {
 913                 ubh_brelse_uspi(uspi);
 914                 ubh = NULL;
 915                 block_size = uspi->s_fsize;
 916                 super_block_size = uspi->s_sbsize;
 917                 UFSD("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size);
 918                 goto again;
 919         }
 920
 921         sbi->s_flags = flags;/*after that line some functions use s_flags*/
 922         ufs_print_super_stuff(sb, usb1, usb2, usb3);
 923
 924         /*
 925          * Check, if file system was correctly unmounted.
 926          * If not, make it read only.
 927          */
 928         if (((flags & UFS_ST_MASK) == UFS_ST_44BSD) ||
 929           ((flags & UFS_ST_MASK) == UFS_ST_OLD) ||
 930           (((flags & UFS_ST_MASK) == UFS_ST_SUN ||
 931             (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
 932           (flags & UFS_ST_MASK) == UFS_ST_SUNx86) &&
 933           (ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time))))) {
 934                 switch(usb1->fs_clean) {
 935                 case UFS_FSCLEAN:
 936                         UFSD("fs is clean\n");
 937                         break;
 938                 case UFS_FSSTABLE:
 939                         UFSD("fs is stable\n");
 940                         break;
 941                 case UFS_FSOSF1:
 942                         UFSD("fs is DEC OSF/1\n");
 943                         break;
 944                 case UFS_FSACTIVE:
 945                         printk("ufs_read_super: fs is active\n");
 946                         sb->s_flags |= MS_RDONLY;
 947                         break;
 948                 case UFS_FSBAD:
 949                         printk("ufs_read_super: fs is bad\n");
 950                         sb->s_flags |= MS_RDONLY;
 951                         break;
 952                 default:
 953                         printk("ufs_read_super: can't grok fs_clean 0x%x\n", usb1->fs_clean);
 954                         sb->s_flags |= MS_RDONLY;
 955                         break;
 956                 }
 957         } else {
 958                 printk("ufs_read_super: fs needs fsck\n");
 959                 sb->s_flags |= MS_RDONLY;
 960         }
 961
 962         /*
 963          * Read ufs_super_block into internal data structures
 964          */
 965         sb->s_op = &ufs_super_ops;
 966         sb->dq_op = NULL; /***/
 967         sb->s_magic = fs32_to_cpu(sb, usb3->fs_magic);
 968
 969         uspi->s_sblkno = fs32_to_cpu(sb, usb1->fs_sblkno);
 970         uspi->s_cblkno = fs32_to_cpu(sb, usb1->fs_cblkno);
 971         uspi->s_iblkno = fs32_to_cpu(sb, usb1->fs_iblkno);
 972         uspi->s_dblkno = fs32_to_cpu(sb, usb1->fs_dblkno);
 973         uspi->s_cgoffset = fs32_to_cpu(sb, usb1->fs_cgoffset);
 974         uspi->s_cgmask = fs32_to_cpu(sb, usb1->fs_cgmask);
 975
 976         if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
 977                 uspi->s_u2_size  = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size);
 978                 uspi->s_u2_dsize = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);
 979         } else {
 980                 uspi->s_size  =  fs32_to_cpu(sb, usb1->fs_size);
 981                 uspi->s_dsize =  fs32_to_cpu(sb, usb1->fs_dsize);
 982         }
 983
 984         uspi->s_ncg = fs32_to_cpu(sb, usb1->fs_ncg);
 985         /* s_bsize already set */
 986         /* s_fsize already set */
 987         uspi->s_fpb = fs32_to_cpu(sb, usb1->fs_frag);
 988         uspi->s_minfree = fs32_to_cpu(sb, usb1->fs_minfree);
 989         uspi->s_bmask = fs32_to_cpu(sb, usb1->fs_bmask);
 990         uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
 991         uspi->s_bshift = fs32_to_cpu(sb, usb1->fs_bshift);
 992         uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
 993         UFSD("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi->s_bshift,
 994                 uspi->s_fshift);
 995         uspi->s_fpbshift = fs32_to_cpu(sb, usb1->fs_fragshift);
 996         uspi->s_fsbtodb = fs32_to_cpu(sb, usb1->fs_fsbtodb);
 997         /* s_sbsize already set */
 998         uspi->s_csmask = fs32_to_cpu(sb, usb1->fs_csmask);
 999         uspi->s_csshift = fs32_to_cpu(sb, usb1->fs_csshift);
1000         uspi->s_nindir = fs32_to_cpu(sb, usb1->fs_nindir);
1001         uspi->s_inopb = fs32_to_cpu(sb, usb1->fs_inopb);
1002         uspi->s_nspf = fs32_to_cpu(sb, usb1->fs_nspf);
1003         uspi->s_npsect = ufs_get_fs_npsect(sb, usb1, usb3);
1004         uspi->s_interleave = fs32_to_cpu(sb, usb1->fs_interleave);
1005         uspi->s_trackskew = fs32_to_cpu(sb, usb1->fs_trackskew);
1006
1007         if (uspi->fs_magic == UFS2_MAGIC)
1008                 uspi->s_csaddr = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_csaddr);
1009         else
1010                 uspi->s_csaddr = fs32_to_cpu(sb, usb1->fs_csaddr);
1011
1012         uspi->s_cssize = fs32_to_cpu(sb, usb1->fs_cssize);
1013         uspi->s_cgsize = fs32_to_cpu(sb, usb1->fs_cgsize);
1014         uspi->s_ntrak = fs32_to_cpu(sb, usb1->fs_ntrak);
1015         uspi->s_nsect = fs32_to_cpu(sb, usb1->fs_nsect);
1016         uspi->s_spc = fs32_to_cpu(sb, usb1->fs_spc);
1017         uspi->s_ipg = fs32_to_cpu(sb, usb1->fs_ipg);
1018         uspi->s_fpg = fs32_to_cpu(sb, usb1->fs_fpg);
1019         uspi->s_cpc = fs32_to_cpu(sb, usb2->fs_un.fs_u1.fs_cpc);
1020         uspi->s_contigsumsize = fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_contigsumsize);
1021         uspi->s_qbmask = ufs_get_fs_qbmask(sb, usb3);
1022         uspi->s_qfmask = ufs_get_fs_qfmask(sb, usb3);
1023         uspi->s_nrpos = fs32_to_cpu(sb, usb3->fs_nrpos);
1024         uspi->s_postbloff = fs32_to_cpu(sb, usb3->fs_postbloff);
1025         uspi->s_rotbloff = fs32_to_cpu(sb, usb3->fs_rotbloff);
1026
1027         /*
1028          * Compute another frequently used values
1029          */
1030         uspi->s_fpbmask = uspi->s_fpb - 1;
1031         if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
1032                 uspi->s_apbshift = uspi->s_bshift - 3;
1033         else
1034                 uspi->s_apbshift = uspi->s_bshift - 2;
1035
1036         uspi->s_2apbshift = uspi->s_apbshift * 2;
1037         uspi->s_3apbshift = uspi->s_apbshift * 3;
1038         uspi->s_apb = 1 << uspi->s_apbshift;
1039         uspi->s_2apb = 1 << uspi->s_2apbshift;
1040         uspi->s_3apb = 1 << uspi->s_3apbshift;
1041         uspi->s_apbmask = uspi->s_apb - 1;
1042         uspi->s_nspfshift = uspi->s_fshift - UFS_SECTOR_BITS;
1043         uspi->s_nspb = uspi->s_nspf << uspi->s_fpbshift;
1044         uspi->s_inopf = uspi->s_inopb >> uspi->s_fpbshift;
1045         uspi->s_bpf = uspi->s_fsize << 3;
1046         uspi->s_bpfshift = uspi->s_fshift + 3;
1047         uspi->s_bpfmask = uspi->s_bpf - 1;
1048         if ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) ==
1049             UFS_MOUNT_UFSTYPE_44BSD)
1050                 uspi->s_maxsymlinklen =
1051                     fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen);
1052
1053         inode = iget(sb, UFS_ROOTINO);
1054         if (!inode || is_bad_inode(inode))
1055                 goto failed;
1056         sb->s_root = d_alloc_root(inode);
1057         if (!sb->s_root)
1058                 goto dalloc_failed;
1059
1060         ufs_setup_cstotal(sb);
1061         /*
1062          * Read cylinder group structures
1063          */
1064         if (!(sb->s_flags & MS_RDONLY))
1065                 if (!ufs_read_cylinder_structures(sb))
1066                         goto failed;
1067
1068         UFSD("EXIT\n");
1069         return 0;
1070
1071 dalloc_failed:
1072         iput(inode);
1073 failed:
1074         if (ubh)
1075                 ubh_brelse_uspi (uspi);
1076         kfree (uspi);
1077         kfree(sbi);
1078         sb->s_fs_info = NULL;
1079         UFSD("EXIT (FAILED)\n");
1080         return -EINVAL;
1081
1082 failed_nomem:
1083         UFSD("EXIT (NOMEM)\n");
1084         return -ENOMEM;
1085 }
1086
1087 static void ufs_write_super(struct super_block *sb)
1088 {
1089         struct ufs_sb_private_info * uspi;
1090         struct ufs_super_block_first * usb1;
1091         struct ufs_super_block_third * usb3;
1092         unsigned flags;
1093
1094         lock_kernel();
1095         UFSD("ENTER\n");
1096         flags = UFS_SB(sb)->s_flags;
1097         uspi = UFS_SB(sb)->s_uspi;
1098         usb1 = ubh_get_usb_first(uspi);
1099         usb3 = ubh_get_usb_third(uspi);
1100
1101         if (!(sb->s_flags & MS_RDONLY)) {
1102                 usb1->fs_time = cpu_to_fs32(sb, get_seconds());
1103                 if ((flags & UFS_ST_MASK) == UFS_ST_SUN
1104                   || (flags & UFS_ST_MASK) == UFS_ST_SUNOS
1105                   || (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
1106                         ufs_set_fs_state(sb, usb1, usb3,
1107                                         UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
1108                 ufs_put_cstotal(sb);
1109         }
1110         sb->s_dirt = 0;
1111         UFSD("EXIT\n");
1112         unlock_kernel();
1113 }
1114
1115 static void ufs_put_super(struct super_block *sb)
1116 {
1117         struct ufs_sb_info * sbi = UFS_SB(sb);
1118
1119         UFSD("ENTER\n");
1120
1121         if (!(sb->s_flags & MS_RDONLY))
1122                 ufs_put_super_internal(sb);
1123
1124         ubh_brelse_uspi (sbi->s_uspi);
1125         kfree (sbi->s_uspi);
1126         kfree (sbi);
1127         sb->s_fs_info = NULL;
1128         UFSD("EXIT\n");
1129         return;
1130 }
1131
1132
1133 static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
1134 {
1135         struct ufs_sb_private_info * uspi;
1136         struct ufs_super_block_first * usb1;
1137         struct ufs_super_block_third * usb3;
1138         unsigned new_mount_opt, ufstype;
1139         unsigned flags;
1140
1141         uspi = UFS_SB(sb)->s_uspi;
1142         flags = UFS_SB(sb)->s_flags;
1143         usb1 = ubh_get_usb_first(uspi);
1144         usb3 = ubh_get_usb_third(uspi);
1145
1146         /*
1147          * Allow the "check" option to be passed as a remount option.
1148          * It is not possible to change ufstype option during remount
1149          */
1150         ufstype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE;
1151         new_mount_opt = 0;
1152         ufs_set_opt (new_mount_opt, ONERROR_LOCK);
1153         if (!ufs_parse_options (data, &new_mount_opt))
1154                 return -EINVAL;
1155         if (!(new_mount_opt & UFS_MOUNT_UFSTYPE)) {
1156                 new_mount_opt |= ufstype;
1157         } else if ((new_mount_opt & UFS_MOUNT_UFSTYPE) != ufstype) {
1158                 printk("ufstype can't be changed during remount\n");
1159                 return -EINVAL;
1160         }
1161
1162         if ((*mount_flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) {
1163                 UFS_SB(sb)->s_mount_opt = new_mount_opt;
1164                 return 0;
1165         }
1166
1167         /*
1168          * fs was mouted as rw, remounting ro
1169          */
1170         if (*mount_flags & MS_RDONLY) {
1171                 ufs_put_super_internal(sb);
1172                 usb1->fs_time = cpu_to_fs32(sb, get_seconds());
1173                 if ((flags & UFS_ST_MASK) == UFS_ST_SUN
1174                   || (flags & UFS_ST_MASK) == UFS_ST_SUNOS
1175                   || (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
1176                         ufs_set_fs_state(sb, usb1, usb3,
1177                                 UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
1178                 ubh_mark_buffer_dirty (USPI_UBH(uspi));
1179                 sb->s_dirt = 0;
1180                 sb->s_flags |= MS_RDONLY;
1181         } else {
1182         /*
1183          * fs was mounted as ro, remounting rw
1184          */
1185 #ifndef CONFIG_UFS_FS_WRITE
1186                 printk("ufs was compiled with read-only support, "
1187                 "can't be mounted as read-write\n");
1188                 return -EINVAL;
1189 #else
1190                 if (ufstype != UFS_MOUNT_UFSTYPE_SUN &&
1191                     ufstype != UFS_MOUNT_UFSTYPE_SUNOS &&
1192                     ufstype != UFS_MOUNT_UFSTYPE_44BSD &&
1193                     ufstype != UFS_MOUNT_UFSTYPE_SUNx86 &&
1194                     ufstype != UFS_MOUNT_UFSTYPE_UFS2) {
1195                         printk("this ufstype is read-only supported\n");
1196                         return -EINVAL;
1197                 }
1198                 if (!ufs_read_cylinder_structures(sb)) {
1199                         printk("failed during remounting\n");
1200                         return -EPERM;
1201                 }
1202                 sb->s_flags &= ~MS_RDONLY;
1203 #endif
1204         }
1205         UFS_SB(sb)->s_mount_opt = new_mount_opt;
1206         return 0;
1207 }
1208
1209 static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf)
1210 {
1211         struct super_block *sb = dentry->d_sb;
1212         struct ufs_sb_private_info *uspi= UFS_SB(sb)->s_uspi;
1213         unsigned  flags = UFS_SB(sb)->s_flags;
1214         struct ufs_super_block_first *usb1;
1215         struct ufs_super_block_second *usb2;
1216         struct ufs_super_block_third *usb3;
1217
1218         lock_kernel();
1219
1220         usb1 = ubh_get_usb_first(uspi);
1221         usb2 = ubh_get_usb_second(uspi);
1222         usb3 = ubh_get_usb_third(uspi);
1223
1224         if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
1225                 buf->f_type = UFS2_MAGIC;
1226                 buf->f_blocks = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);
1227         } else {
1228                 buf->f_type = UFS_MAGIC;
1229                 buf->f_blocks = uspi->s_dsize;
1230         }
1231         buf->f_bfree = ufs_blkstofrags(uspi->cs_total.cs_nbfree) +
1232                 uspi->cs_total.cs_nffree;
1233         buf->f_ffree = uspi->cs_total.cs_nifree;
1234         buf->f_bsize = sb->s_blocksize;
1235         buf->f_bavail = (buf->f_bfree > (((long)buf->f_blocks / 100) * uspi->s_minfree))
1236                 ? (buf->f_bfree - (((long)buf->f_blocks / 100) * uspi->s_minfree)) : 0;
1237         buf->f_files = uspi->s_ncg * uspi->s_ipg;
1238         buf->f_namelen = UFS_MAXNAMLEN;
1239
1240         unlock_kernel();
1241
1242         return 0;
1243 }
1244
1245 static struct kmem_cache * ufs_inode_cachep;
1246
1247 static struct inode *ufs_alloc_inode(struct super_block *sb)
1248 {
1249         struct ufs_inode_info *ei;
1250         ei = (struct ufs_inode_info *)kmem_cache_alloc(ufs_inode_cachep, GFP_KERNEL);
1251         if (!ei)
1252                 return NULL;
1253         ei->vfs_inode.i_version = 1;
1254         return &ei->vfs_inode;
1255 }
1256
1257 static void ufs_destroy_inode(struct inode *inode)
1258 {
1259         kmem_cache_free(ufs_inode_cachep, UFS_I(inode));
1260 }
1261
1262 static void init_once(struct kmem_cache * cachep, void *foo)
1263 {
1264         struct ufs_inode_info *ei = (struct ufs_inode_info *) foo;
1265
1266         inode_init_once(&ei->vfs_inode);
1267 }
1268
1269 static int init_inodecache(void)
1270 {
1271         ufs_inode_cachep = kmem_cache_create("ufs_inode_cache",
1272                                              sizeof(struct ufs_inode_info),
1273                                              0, (SLAB_RECLAIM_ACCOUNT|
1274                                                 SLAB_MEM_SPREAD),
1275                                              init_once);
1276         if (ufs_inode_cachep == NULL)
1277                 return -ENOMEM;
1278         return 0;
1279 }
1280
1281 static void destroy_inodecache(void)
1282 {
1283         kmem_cache_destroy(ufs_inode_cachep);
1284 }
1285
1286 #ifdef CONFIG_QUOTA
1287 static ssize_t ufs_quota_read(struct super_block *, int, char *,size_t, loff_t);
1288 static ssize_t ufs_quota_write(struct super_block *, int, const char *, size_t, loff_t);
1289 #endif
1290
1291 static const struct super_operations ufs_super_ops = {
1292         .alloc_inode    = ufs_alloc_inode,
1293         .destroy_inode  = ufs_destroy_inode,
1294         .read_inode     = ufs_read_inode,
1295         .write_inode    = ufs_write_inode,
1296         .delete_inode   = ufs_delete_inode,
1297         .put_super      = ufs_put_super,
1298         .write_super    = ufs_write_super,
1299         .statfs         = ufs_statfs,
1300         .remount_fs     = ufs_remount,
1301 #ifdef CONFIG_QUOTA
1302         .quota_read     = ufs_quota_read,
1303         .quota_write    = ufs_quota_write,
1304 #endif
1305 };
1306
1307 #ifdef CONFIG_QUOTA
1308
1309 /* Read data from quotafile - avoid pagecache and such because we cannot afford
1310  * acquiring the locks... As quota files are never truncated and quota code
1311  * itself serializes the operations (and noone else should touch the files)
1312  * we don't have to be afraid of races */
1313 static ssize_t ufs_quota_read(struct super_block *sb, int type, char *data,
1314                                size_t len, loff_t off)
1315 {
1316         struct inode *inode = sb_dqopt(sb)->files[type];
1317         sector_t blk = off >> sb->s_blocksize_bits;
1318         int err = 0;
1319         int offset = off & (sb->s_blocksize - 1);
1320         int tocopy;
1321         size_t toread;
1322         struct buffer_head *bh;
1323         loff_t i_size = i_size_read(inode);
1324
1325         if (off > i_size)
1326                 return 0;
1327         if (off+len > i_size)
1328                 len = i_size-off;
1329         toread = len;
1330         while (toread > 0) {
1331                 tocopy = sb->s_blocksize - offset < toread ?
1332                                 sb->s_blocksize - offset : toread;
1333
1334                 bh = ufs_bread(inode, blk, 0, &err);
1335                 if (err)
1336                         return err;
1337                 if (!bh)        /* A hole? */
1338                         memset(data, 0, tocopy);
1339                 else {
1340                         memcpy(data, bh->b_data+offset, tocopy);
1341                         brelse(bh);
1342                 }
1343                 offset = 0;
1344                 toread -= tocopy;
1345                 data += tocopy;
1346                 blk++;
1347         }
1348         return len;
1349 }
1350
1351 /* Write to quotafile */
1352 static ssize_t ufs_quota_write(struct super_block *sb, int type,
1353                                 const char *data, size_t len, loff_t off)
1354 {
1355         struct inode *inode = sb_dqopt(sb)->files[type];
1356         sector_t blk = off >> sb->s_blocksize_bits;
1357         int err = 0;
1358         int offset = off & (sb->s_blocksize - 1);
1359         int tocopy;
1360         size_t towrite = len;
1361         struct buffer_head *bh;
1362
1363         mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
1364         while (towrite > 0) {
1365                 tocopy = sb->s_blocksize - offset < towrite ?
1366                                 sb->s_blocksize - offset : towrite;
1367
1368                 bh = ufs_bread(inode, blk, 1, &err);
1369                 if (!bh)
1370                         goto out;
1371                 lock_buffer(bh);
1372                 memcpy(bh->b_data+offset, data, tocopy);
1373                 flush_dcache_page(bh->b_page);
1374                 set_buffer_uptodate(bh);
1375                 mark_buffer_dirty(bh);
1376                 unlock_buffer(bh);
1377                 brelse(bh);
1378                 offset = 0;
1379                 towrite -= tocopy;
1380                 data += tocopy;
1381                 blk++;
1382         }
1383 out:
1384         if (len == towrite) {
1385                 mutex_unlock(&inode->i_mutex);
1386                 return err;
1387         }
1388         if (inode->i_size < off+len-towrite)
1389                 i_size_write(inode, off+len-towrite);
1390         inode->i_version++;
1391         inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
1392         mark_inode_dirty(inode);
1393         mutex_unlock(&inode->i_mutex);
1394         return len - towrite;
1395 }
1396
1397 #endif
1398
1399 static int ufs_get_sb(struct file_system_type *fs_type,
1400         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
1401 {
1402         return get_sb_bdev(fs_type, flags, dev_name, data, ufs_fill_super, mnt);
1403 }
1404
1405 static struct file_system_type ufs_fs_type = {
1406         .owner          = THIS_MODULE,
1407         .name           = "ufs",
1408         .get_sb         = ufs_get_sb,
1409         .kill_sb        = kill_block_super,
1410         .fs_flags       = FS_REQUIRES_DEV,
1411 };
1412
1413 static int __init init_ufs_fs(void)
1414 {
1415         int err = init_inodecache();
1416         if (err)
1417                 goto out1;
1418         err = register_filesystem(&ufs_fs_type);
1419         if (err)
1420                 goto out;
1421         return 0;
1422 out:
1423         destroy_inodecache();
1424 out1:
1425         return err;
1426 }
1427
1428 static void __exit exit_ufs_fs(void)
1429 {
1430         unregister_filesystem(&ufs_fs_type);
1431         destroy_inodecache();
1432 }
1433
1434 module_init(init_ufs_fs)
1435 module_exit(exit_ufs_fs)
1436 MODULE_LICENSE("GPL");