fs/hpfs/super.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  linux/fs/hpfs/super.c
   4  *
   5  *  Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
   6  *
   7  *  mounting, unmounting, error handling
   8  */
   9
  10 #include "hpfs_fn.h"
  11 #include <linux/module.h>
  12 #include <linux/fs_context.h>
  13 #include <linux/fs_parser.h>
  14 #include <linux/init.h>
  15 #include <linux/statfs.h>
  16 #include <linux/magic.h>
  17 #include <linux/sched.h>
  18 #include <linux/bitmap.h>
  19 #include <linux/slab.h>
  20 #include <linux/seq_file.h>
  21
  22 /* Mark the filesystem dirty, so that chkdsk checks it when os/2 booted */
  23
  24 static void mark_dirty(struct super_block *s, int remount)
  25 {
  26         if (hpfs_sb(s)->sb_chkdsk && (remount || !sb_rdonly(s))) {
  27                 struct buffer_head *bh;
  28                 struct hpfs_spare_block *sb;
  29                 if ((sb = hpfs_map_sector(s, 17, &bh, 0))) {
  30                         sb->dirty = 1;
  31                         sb->old_wrote = 0;
  32                         mark_buffer_dirty(bh);
  33                         sync_dirty_buffer(bh);
  34                         brelse(bh);
  35                 }
  36         }
  37 }
  38
  39 /* Mark the filesystem clean (mark it dirty for chkdsk if chkdsk==2 or if there
  40    were errors) */
  41
  42 static void unmark_dirty(struct super_block *s)
  43 {
  44         struct buffer_head *bh;
  45         struct hpfs_spare_block *sb;
  46         if (sb_rdonly(s)) return;
  47         sync_blockdev(s->s_bdev);
  48         if ((sb = hpfs_map_sector(s, 17, &bh, 0))) {
  49                 sb->dirty = hpfs_sb(s)->sb_chkdsk > 1 - hpfs_sb(s)->sb_was_error;
  50                 sb->old_wrote = hpfs_sb(s)->sb_chkdsk >= 2 && !hpfs_sb(s)->sb_was_error;
  51                 mark_buffer_dirty(bh);
  52                 sync_dirty_buffer(bh);
  53                 brelse(bh);
  54         }
  55 }
  56
  57 /* Filesystem error... */
  58 void hpfs_error(struct super_block *s, const char *fmt, ...)
  59 {
  60         struct va_format vaf;
  61         va_list args;
  62
  63         va_start(args, fmt);
  64
  65         vaf.fmt = fmt;
  66         vaf.va = &args;
  67
  68         pr_err("filesystem error: %pV", &vaf);
  69
  70         va_end(args);
  71
  72         if (!hpfs_sb(s)->sb_was_error) {
  73                 if (hpfs_sb(s)->sb_err == 2) {
  74                         pr_cont("; crashing the system because you wanted it\n");
  75                         mark_dirty(s, 0);
  76                         panic("HPFS panic");
  77                 } else if (hpfs_sb(s)->sb_err == 1) {
  78                         if (sb_rdonly(s))
  79                                 pr_cont("; already mounted read-only\n");
  80                         else {
  81                                 pr_cont("; remounting read-only\n");
  82                                 mark_dirty(s, 0);
  83                                 s->s_flags |= SB_RDONLY;
  84                         }
  85                 } else if (sb_rdonly(s))
  86                                 pr_cont("; going on - but anything won't be destroyed because it's read-only\n");
  87                 else
  88                         pr_cont("; corrupted filesystem mounted read/write - your computer will explode within 20 seconds ... but you wanted it so!\n");
  89         } else
  90                 pr_cont("\n");
  91         hpfs_sb(s)->sb_was_error = 1;
  92 }
  93
  94 /*
  95  * A little trick to detect cycles in many hpfs structures and don't let the
  96  * kernel crash on corrupted filesystem. When first called, set c2 to 0.
  97  *
  98  * BTW. chkdsk doesn't detect cycles correctly. When I had 2 lost directories
  99  * nested each in other, chkdsk locked up happilly.
 100  */
 101
 102 int hpfs_stop_cycles(struct super_block *s, int key, int *c1, int *c2,
 103                 char *msg)
 104 {
 105         if (*c2 && *c1 == key) {
 106                 hpfs_error(s, "cycle detected on key %08x in %s", key, msg);
 107                 return 1;
 108         }
 109         (*c2)++;
 110         if (!((*c2 - 1) & *c2)) *c1 = key;
 111         return 0;
 112 }
 113
 114 static void free_sbi(struct hpfs_sb_info *sbi)
 115 {
 116         kfree(sbi->sb_cp_table);
 117         kfree(sbi->sb_bmp_dir);
 118         kfree(sbi);
 119 }
 120
 121 static void lazy_free_sbi(struct rcu_head *rcu)
 122 {
 123         free_sbi(container_of(rcu, struct hpfs_sb_info, rcu));
 124 }
 125
 126 static void hpfs_put_super(struct super_block *s)
 127 {
 128         hpfs_lock(s);
 129         unmark_dirty(s);
 130         hpfs_unlock(s);
 131         call_rcu(&hpfs_sb(s)->rcu, lazy_free_sbi);
 132 }
 133
 134 static unsigned hpfs_count_one_bitmap(struct super_block *s, secno secno)
 135 {
 136         struct quad_buffer_head qbh;
 137         unsigned long *bits;
 138         unsigned count;
 139
 140         bits = hpfs_map_4sectors(s, secno, &qbh, 0);
 141         if (!bits)
 142                 return (unsigned)-1;
 143         count = bitmap_weight(bits, 2048 * BITS_PER_BYTE);
 144         hpfs_brelse4(&qbh);
 145         return count;
 146 }
 147
 148 static unsigned count_bitmaps(struct super_block *s)
 149 {
 150         unsigned n, count, n_bands;
 151         n_bands = (hpfs_sb(s)->sb_fs_size + 0x3fff) >> 14;
 152         count = 0;
 153         for (n = 0; n < COUNT_RD_AHEAD; n++) {
 154                 hpfs_prefetch_bitmap(s, n);
 155         }
 156         for (n = 0; n < n_bands; n++) {
 157                 unsigned c;
 158                 hpfs_prefetch_bitmap(s, n + COUNT_RD_AHEAD);
 159                 c = hpfs_count_one_bitmap(s, le32_to_cpu(hpfs_sb(s)->sb_bmp_dir[n]));
 160                 if (c != (unsigned)-1)
 161                         count += c;
 162         }
 163         return count;
 164 }
 165
 166 unsigned hpfs_get_free_dnodes(struct super_block *s)
 167 {
 168         struct hpfs_sb_info *sbi = hpfs_sb(s);
 169         if (sbi->sb_n_free_dnodes == (unsigned)-1) {
 170                 unsigned c = hpfs_count_one_bitmap(s, sbi->sb_dmap);
 171                 if (c == (unsigned)-1)
 172                         return 0;
 173                 sbi->sb_n_free_dnodes = c;
 174         }
 175         return sbi->sb_n_free_dnodes;
 176 }
 177
 178 static int hpfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 179 {
 180         struct super_block *s = dentry->d_sb;
 181         struct hpfs_sb_info *sbi = hpfs_sb(s);
 182         u64 id = huge_encode_dev(s->s_bdev->bd_dev);
 183
 184         hpfs_lock(s);
 185
 186         if (sbi->sb_n_free == (unsigned)-1)
 187                 sbi->sb_n_free = count_bitmaps(s);
 188
 189         buf->f_type = s->s_magic;
 190         buf->f_bsize = 512;
 191         buf->f_blocks = sbi->sb_fs_size;
 192         buf->f_bfree = sbi->sb_n_free;
 193         buf->f_bavail = sbi->sb_n_free;
 194         buf->f_files = sbi->sb_dirband_size / 4;
 195         buf->f_ffree = hpfs_get_free_dnodes(s);
 196         buf->f_fsid = u64_to_fsid(id);
 197         buf->f_namelen = 254;
 198
 199         hpfs_unlock(s);
 200
 201         return 0;
 202 }
 203
 204
 205 long hpfs_ioctl(struct file *file, unsigned cmd, unsigned long arg)
 206 {
 207         switch (cmd) {
 208                 case FITRIM: {
 209                         struct fstrim_range range;
 210                         secno n_trimmed;
 211                         int r;
 212                         if (!capable(CAP_SYS_ADMIN))
 213                                 return -EPERM;
 214                         if (copy_from_user(&range, (struct fstrim_range __user *)arg, sizeof(range)))
 215                                 return -EFAULT;
 216                         r = hpfs_trim_fs(file_inode(file)->i_sb, range.start >> 9, (range.start + range.len) >> 9, (range.minlen + 511) >> 9, &n_trimmed);
 217                         if (r)
 218                                 return r;
 219                         range.len = (u64)n_trimmed << 9;
 220                         if (copy_to_user((struct fstrim_range __user *)arg, &range, sizeof(range)))
 221                                 return -EFAULT;
 222                         return 0;
 223                 }
 224                 default: {
 225                         return -ENOIOCTLCMD;
 226                 }
 227         }
 228 }
 229
 230
 231 static struct kmem_cache * hpfs_inode_cachep;
 232
 233 static struct inode *hpfs_alloc_inode(struct super_block *sb)
 234 {
 235         struct hpfs_inode_info *ei;
 236         ei = alloc_inode_sb(sb, hpfs_inode_cachep, GFP_NOFS);
 237         if (!ei)
 238                 return NULL;
 239         return &ei->vfs_inode;
 240 }
 241
 242 static void hpfs_free_inode(struct inode *inode)
 243 {
 244         kmem_cache_free(hpfs_inode_cachep, hpfs_i(inode));
 245 }
 246
 247 static void init_once(void *foo)
 248 {
 249         struct hpfs_inode_info *ei = (struct hpfs_inode_info *) foo;
 250
 251         inode_init_once(&ei->vfs_inode);
 252 }
 253
 254 static int init_inodecache(void)
 255 {
 256         hpfs_inode_cachep = kmem_cache_create("hpfs_inode_cache",
 257                                              sizeof(struct hpfs_inode_info),
 258                                              0, (SLAB_RECLAIM_ACCOUNT|
 259                                                 SLAB_ACCOUNT),
 260                                              init_once);
 261         if (hpfs_inode_cachep == NULL)
 262                 return -ENOMEM;
 263         return 0;
 264 }
 265
 266 static void destroy_inodecache(void)
 267 {
 268         /*
 269          * Make sure all delayed rcu free inodes are flushed before we
 270          * destroy cache.
 271          */
 272         rcu_barrier();
 273         kmem_cache_destroy(hpfs_inode_cachep);
 274 }
 275
 276 enum {
 277         Opt_help, Opt_uid, Opt_gid, Opt_umask, Opt_case,
 278         Opt_check, Opt_err, Opt_eas, Opt_chkdsk, Opt_timeshift,
 279 };
 280
 281 static const struct constant_table hpfs_param_case[] = {
 282         {"asis",        0},
 283         {"lower",       1},
 284         {}
 285 };
 286
 287 static const struct constant_table hpfs_param_check[] = {
 288         {"none",        0},
 289         {"normal",      1},
 290         {"strict",      2},
 291         {}
 292 };
 293
 294 static const struct constant_table hpfs_param_err[] = {
 295         {"continue",    0},
 296         {"remount-ro",  1},
 297         {"panic",       2},
 298         {}
 299 };
 300
 301 static const struct constant_table hpfs_param_eas[] = {
 302         {"no",          0},
 303         {"ro",          1},
 304         {"rw",          2},
 305         {}
 306 };
 307
 308 static const struct constant_table hpfs_param_chkdsk[] = {
 309         {"no",          0},
 310         {"errors",      1},
 311         {"always",      2},
 312         {}
 313 };
 314
 315 static const struct fs_parameter_spec hpfs_param_spec[] = {
 316         fsparam_flag    ("help",        Opt_help),
 317         fsparam_uid     ("uid",         Opt_uid),
 318         fsparam_gid     ("gid",         Opt_gid),
 319         fsparam_u32oct  ("umask",       Opt_umask),
 320         fsparam_enum    ("case",        Opt_case,       hpfs_param_case),
 321         fsparam_enum    ("check",       Opt_check,      hpfs_param_check),
 322         fsparam_enum    ("errors",      Opt_err,        hpfs_param_err),
 323         fsparam_enum    ("eas",         Opt_eas,        hpfs_param_eas),
 324         fsparam_enum    ("chkdsk",      Opt_chkdsk,     hpfs_param_chkdsk),
 325         fsparam_s32     ("timeshift",   Opt_timeshift),
 326         {}
 327 };
 328
 329 struct hpfs_fc_context {
 330         kuid_t uid;
 331         kgid_t gid;
 332         umode_t umask;
 333         int lowercase;
 334         int eas;
 335         int chk;
 336         int errs;
 337         int chkdsk;
 338         int timeshift;
 339 };
 340
 341 static inline void hpfs_help(void)
 342 {
 343         pr_info("\n\
 344 HPFS filesystem options:\n\
 345       help              do not mount and display this text\n\
 346       uid=xxx           set uid of files that don't have uid specified in eas\n\
 347       gid=xxx           set gid of files that don't have gid specified in eas\n\
 348       umask=xxx         set mode of files that don't have mode specified in eas\n\
 349       case=lower        lowercase all files\n\
 350       case=asis         do not lowercase files (default)\n\
 351       check=none        no fs checks - kernel may crash on corrupted filesystem\n\
 352       check=normal      do some checks - it should not crash (default)\n\
 353       check=strict      do extra time-consuming checks, used for debugging\n\
 354       errors=continue   continue on errors\n\
 355       errors=remount-ro remount read-only if errors found (default)\n\
 356       errors=panic      panic on errors\n\
 357       chkdsk=no         do not mark fs for chkdsking even if there were errors\n\
 358       chkdsk=errors     mark fs dirty if errors found (default)\n\
 359       chkdsk=always     always mark fs dirty - used for debugging\n\
 360       eas=no            ignore extended attributes\n\
 361       eas=ro            read but do not write extended attributes\n\
 362       eas=rw            r/w eas => enables chmod, chown, mknod, ln -s (default)\n\
 363       timeshift=nnn     add nnn seconds to file times\n\
 364 \n");
 365 }
 366
 367 static int hpfs_parse_param(struct fs_context *fc, struct fs_parameter *param)
 368 {
 369         struct hpfs_fc_context *ctx = fc->fs_private;
 370         struct fs_parse_result result;
 371         int opt;
 372
 373         opt = fs_parse(fc, hpfs_param_spec, param, &result);
 374         if (opt < 0)
 375                 return opt;
 376
 377         switch (opt) {
 378         case Opt_help:
 379                 hpfs_help();
 380                 return -EINVAL;
 381         case Opt_uid:
 382                 ctx->uid = result.uid;
 383                 break;
 384         case Opt_gid:
 385                 ctx->gid = result.gid;
 386                 break;
 387         case Opt_umask:
 388                 ctx->umask = result.uint_32;
 389                 break;
 390         case Opt_case:
 391                 ctx->lowercase = result.uint_32;
 392                 break;
 393         case Opt_check:
 394                 ctx->chk = result.uint_32;
 395                 break;
 396         case Opt_err:
 397                 ctx->errs = result.uint_32;
 398                 break;
 399         case Opt_eas:
 400                 ctx->eas = result.uint_32;
 401                 break;
 402         case Opt_chkdsk:
 403                 ctx->chkdsk = result.uint_32;
 404                 break;
 405         case Opt_timeshift:
 406                 {
 407                         int m = 1;
 408                         char *rhs = param->string;
 409                         int timeshift;
 410
 411                         if (*rhs == '-') m = -1;
 412                         if (*rhs == '+' || *rhs == '-') rhs++;
 413                         timeshift = simple_strtoul(rhs, &rhs, 0) * m;
 414                         if (*rhs)
 415                                         return -EINVAL;
 416                         ctx->timeshift = timeshift;
 417                         break;
 418                 }
 419         default:
 420                 return -EINVAL;
 421         }
 422
 423         return 0;
 424 }
 425
 426 static int hpfs_reconfigure(struct fs_context *fc)
 427 {
 428         struct hpfs_fc_context *ctx = fc->fs_private;
 429         struct super_block *s = fc->root->d_sb;
 430         struct hpfs_sb_info *sbi = hpfs_sb(s);
 431
 432         sync_filesystem(s);
 433
 434         fc->sb_flags |= SB_NOATIME;
 435
 436         hpfs_lock(s);
 437
 438         if (ctx->timeshift != sbi->sb_timeshift) {
 439                 pr_err("timeshift can't be changed using remount.\n");
 440                 goto out_err;
 441         }
 442
 443         unmark_dirty(s);
 444
 445         sbi->sb_uid = ctx->uid; sbi->sb_gid = ctx->gid;
 446         sbi->sb_mode = 0777 & ~ctx->umask;
 447         sbi->sb_lowercase = ctx->lowercase;
 448         sbi->sb_eas = ctx->eas; sbi->sb_chk = ctx->chk;
 449         sbi->sb_chkdsk = ctx->chkdsk;
 450         sbi->sb_err = ctx->errs; sbi->sb_timeshift = ctx->timeshift;
 451
 452         if (!(fc->sb_flags & SB_RDONLY)) mark_dirty(s, 1);
 453
 454         hpfs_unlock(s);
 455         return 0;
 456
 457 out_err:
 458         hpfs_unlock(s);
 459         return -EINVAL;
 460 }
 461
 462 static int hpfs_show_options(struct seq_file *seq, struct dentry *root)
 463 {
 464         struct hpfs_sb_info *sbi = hpfs_sb(root->d_sb);
 465
 466         seq_printf(seq, ",uid=%u", from_kuid_munged(&init_user_ns, sbi->sb_uid));
 467         seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, sbi->sb_gid));
 468         seq_printf(seq, ",umask=%03o", (~sbi->sb_mode & 0777));
 469         if (sbi->sb_lowercase)
 470                 seq_printf(seq, ",case=lower");
 471         if (!sbi->sb_chk)
 472                 seq_printf(seq, ",check=none");
 473         if (sbi->sb_chk == 2)
 474                 seq_printf(seq, ",check=strict");
 475         if (!sbi->sb_err)
 476                 seq_printf(seq, ",errors=continue");
 477         if (sbi->sb_err == 2)
 478                 seq_printf(seq, ",errors=panic");
 479         if (!sbi->sb_chkdsk)
 480                 seq_printf(seq, ",chkdsk=no");
 481         if (sbi->sb_chkdsk == 2)
 482                 seq_printf(seq, ",chkdsk=always");
 483         if (!sbi->sb_eas)
 484                 seq_printf(seq, ",eas=no");
 485         if (sbi->sb_eas == 1)
 486                 seq_printf(seq, ",eas=ro");
 487         if (sbi->sb_timeshift)
 488                 seq_printf(seq, ",timeshift=%d", sbi->sb_timeshift);
 489         return 0;
 490 }
 491
 492 /* Super operations */
 493
 494 static const struct super_operations hpfs_sops =
 495 {
 496         .alloc_inode    = hpfs_alloc_inode,
 497         .free_inode     = hpfs_free_inode,
 498         .evict_inode    = hpfs_evict_inode,
 499         .put_super      = hpfs_put_super,
 500         .statfs         = hpfs_statfs,
 501         .show_options   = hpfs_show_options,
 502 };
 503
 504 static int hpfs_fill_super(struct super_block *s, struct fs_context *fc)
 505 {
 506         struct hpfs_fc_context *ctx = fc->fs_private;
 507         struct buffer_head *bh0, *bh1, *bh2;
 508         struct hpfs_boot_block *bootblock;
 509         struct hpfs_super_block *superblock;
 510         struct hpfs_spare_block *spareblock;
 511         struct hpfs_sb_info *sbi;
 512         struct inode *root;
 513         int silent = fc->sb_flags & SB_SILENT;
 514
 515         dnode_secno root_dno;
 516         struct hpfs_dirent *de = NULL;
 517         struct quad_buffer_head qbh;
 518
 519         sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
 520         if (!sbi) {
 521                 return -ENOMEM;
 522         }
 523         s->s_fs_info = sbi;
 524
 525         mutex_init(&sbi->hpfs_mutex);
 526         hpfs_lock(s);
 527
 528         /*sbi->sb_mounting = 1;*/
 529         sb_set_blocksize(s, 512);
 530         sbi->sb_fs_size = -1;
 531         if (!(bootblock = hpfs_map_sector(s, 0, &bh0, 0))) goto bail1;
 532         if (!(superblock = hpfs_map_sector(s, 16, &bh1, 1))) goto bail2;
 533         if (!(spareblock = hpfs_map_sector(s, 17, &bh2, 0))) goto bail3;
 534
 535         /* Check magics */
 536         if (/*le16_to_cpu(bootblock->magic) != BB_MAGIC
 537             ||*/ le32_to_cpu(superblock->magic) != SB_MAGIC
 538             || le32_to_cpu(spareblock->magic) != SP_MAGIC) {
 539                 if (!silent)
 540                         pr_err("Bad magic ... probably not HPFS\n");
 541                 goto bail4;
 542         }
 543
 544         /* Check version */
 545         if (!sb_rdonly(s) && superblock->funcversion != 2 && superblock->funcversion != 3) {
 546                 pr_err("Bad version %d,%d. Mount readonly to go around\n",
 547                         (int)superblock->version, (int)superblock->funcversion);
 548                 pr_err("please try recent version of HPFS driver at http://artax.karlin.mff.cuni.cz/~mikulas/vyplody/hpfs/index-e.cgi and if it still can't understand this format, contact author - mikulas@artax.karlin.mff.cuni.cz\n");
 549                 goto bail4;
 550         }
 551
 552         s->s_flags |= SB_NOATIME;
 553
 554         /* Fill superblock stuff */
 555         s->s_magic = HPFS_SUPER_MAGIC;
 556         s->s_op = &hpfs_sops;
 557         s->s_d_op = &hpfs_dentry_operations;
 558         s->s_time_min =  local_to_gmt(s, 0);
 559         s->s_time_max =  local_to_gmt(s, U32_MAX);
 560
 561         sbi->sb_root = le32_to_cpu(superblock->root);
 562         sbi->sb_fs_size = le32_to_cpu(superblock->n_sectors);
 563         sbi->sb_bitmaps = le32_to_cpu(superblock->bitmaps);
 564         sbi->sb_dirband_start = le32_to_cpu(superblock->dir_band_start);
 565         sbi->sb_dirband_size = le32_to_cpu(superblock->n_dir_band);
 566         sbi->sb_dmap = le32_to_cpu(superblock->dir_band_bitmap);
 567         sbi->sb_uid = ctx->uid;
 568         sbi->sb_gid = ctx->gid;
 569         sbi->sb_mode = 0777 & ~ctx->umask;
 570         sbi->sb_n_free = -1;
 571         sbi->sb_n_free_dnodes = -1;
 572         sbi->sb_lowercase = ctx->lowercase;
 573         sbi->sb_eas = ctx->eas;
 574         sbi->sb_chk = ctx->chk;
 575         sbi->sb_chkdsk = ctx->chkdsk;
 576         sbi->sb_err = ctx->errs;
 577         sbi->sb_timeshift = ctx->timeshift;
 578         sbi->sb_was_error = 0;
 579         sbi->sb_cp_table = NULL;
 580         sbi->sb_c_bitmap = -1;
 581         sbi->sb_max_fwd_alloc = 0xffffff;
 582
 583         if (sbi->sb_fs_size >= 0x80000000) {
 584                 hpfs_error(s, "invalid size in superblock: %08x",
 585                         (unsigned)sbi->sb_fs_size);
 586                 goto bail4;
 587         }
 588
 589         if (spareblock->n_spares_used)
 590                 hpfs_load_hotfix_map(s, spareblock);
 591
 592         /* Load bitmap directory */
 593         if (!(sbi->sb_bmp_dir = hpfs_load_bitmap_directory(s, le32_to_cpu(superblock->bitmaps))))
 594                 goto bail4;
 595
 596         /* Check for general fs errors*/
 597         if (spareblock->dirty && !spareblock->old_wrote) {
 598                 if (sbi->sb_err == 2) {
 599                         pr_err("Improperly stopped, not mounted\n");
 600                         goto bail4;
 601                 }
 602                 hpfs_error(s, "improperly stopped");
 603         }
 604
 605         if (!sb_rdonly(s)) {
 606                 spareblock->dirty = 1;
 607                 spareblock->old_wrote = 0;
 608                 mark_buffer_dirty(bh2);
 609         }
 610
 611         if (le32_to_cpu(spareblock->n_dnode_spares) != le32_to_cpu(spareblock->n_dnode_spares_free)) {
 612                 if (sbi->sb_err >= 2) {
 613                         pr_err("Spare dnodes used, try chkdsk\n");
 614                         mark_dirty(s, 0);
 615                         goto bail4;
 616                 }
 617                 hpfs_error(s, "warning: spare dnodes used, try chkdsk");
 618                 if (sbi->sb_err == 0)
 619                         pr_err("Proceeding, but your filesystem could be corrupted if you delete files or directories\n");
 620         }
 621         if (sbi->sb_chk) {
 622                 unsigned a;
 623                 if (le32_to_cpu(superblock->dir_band_end) - le32_to_cpu(superblock->dir_band_start) + 1 != le32_to_cpu(superblock->n_dir_band) ||
 624                     le32_to_cpu(superblock->dir_band_end) < le32_to_cpu(superblock->dir_band_start) || le32_to_cpu(superblock->n_dir_band) > 0x4000) {
 625                         hpfs_error(s, "dir band size mismatch: dir_band_start==%08x, dir_band_end==%08x, n_dir_band==%08x",
 626                                 le32_to_cpu(superblock->dir_band_start), le32_to_cpu(superblock->dir_band_end), le32_to_cpu(superblock->n_dir_band));
 627                         goto bail4;
 628                 }
 629                 a = sbi->sb_dirband_size;
 630                 sbi->sb_dirband_size = 0;
 631                 if (hpfs_chk_sectors(s, le32_to_cpu(superblock->dir_band_start), le32_to_cpu(superblock->n_dir_band), "dir_band") ||
 632                     hpfs_chk_sectors(s, le32_to_cpu(superblock->dir_band_bitmap), 4, "dir_band_bitmap") ||
 633                     hpfs_chk_sectors(s, le32_to_cpu(superblock->bitmaps), 4, "bitmaps")) {
 634                         mark_dirty(s, 0);
 635                         goto bail4;
 636                 }
 637                 sbi->sb_dirband_size = a;
 638         } else
 639                 pr_err("You really don't want any checks? You are crazy...\n");
 640
 641         /* Load code page table */
 642         if (le32_to_cpu(spareblock->n_code_pages))
 643                 if (!(sbi->sb_cp_table = hpfs_load_code_page(s, le32_to_cpu(spareblock->code_page_dir))))
 644                         pr_err("code page support is disabled\n");
 645
 646         brelse(bh2);
 647         brelse(bh1);
 648         brelse(bh0);
 649
 650         root = iget_locked(s, sbi->sb_root);
 651         if (!root)
 652                 goto bail0;
 653         hpfs_init_inode(root);
 654         hpfs_read_inode(root);
 655         unlock_new_inode(root);
 656         s->s_root = d_make_root(root);
 657         if (!s->s_root)
 658                 goto bail0;
 659
 660         /*
 661          * find the root directory's . pointer & finish filling in the inode
 662          */
 663
 664         root_dno = hpfs_fnode_dno(s, sbi->sb_root);
 665         if (root_dno)
 666                 de = map_dirent(root, root_dno, "\001\001", 2, NULL, &qbh);
 667         if (!de)
 668                 hpfs_error(s, "unable to find root dir");
 669         else {
 670                 inode_set_atime(root,
 671                                 local_to_gmt(s, le32_to_cpu(de->read_date)),
 672                                 0);
 673                 inode_set_mtime(root,
 674                                 local_to_gmt(s, le32_to_cpu(de->write_date)),
 675                                 0);
 676                 inode_set_ctime(root,
 677                                 local_to_gmt(s, le32_to_cpu(de->creation_date)),
 678                                 0);
 679                 hpfs_i(root)->i_ea_size = le32_to_cpu(de->ea_size);
 680                 hpfs_i(root)->i_parent_dir = root->i_ino;
 681                 if (root->i_size == -1)
 682                         root->i_size = 2048;
 683                 if (root->i_blocks == -1)
 684                         root->i_blocks = 5;
 685                 hpfs_brelse4(&qbh);
 686         }
 687         hpfs_unlock(s);
 688         return 0;
 689
 690 bail4:  brelse(bh2);
 691 bail3:  brelse(bh1);
 692 bail2:  brelse(bh0);
 693 bail1:
 694 bail0:
 695         hpfs_unlock(s);
 696         free_sbi(sbi);
 697         return -EINVAL;
 698 }
 699
 700 static int hpfs_get_tree(struct fs_context *fc)
 701 {
 702         return get_tree_bdev(fc, hpfs_fill_super);
 703 }
 704
 705 static void hpfs_free_fc(struct fs_context *fc)
 706 {
 707         kfree(fc->fs_private);
 708 }
 709
 710 static const struct fs_context_operations hpfs_fc_context_ops = {
 711         .parse_param    = hpfs_parse_param,
 712         .get_tree       = hpfs_get_tree,
 713         .reconfigure    = hpfs_reconfigure,
 714         .free           = hpfs_free_fc,
 715 };
 716
 717 static int hpfs_init_fs_context(struct fs_context *fc)
 718 {
 719         struct hpfs_fc_context *ctx;
 720
 721         ctx = kzalloc(sizeof(struct hpfs_fc_context), GFP_KERNEL);
 722         if (!ctx)
 723                 return -ENOMEM;
 724
 725         if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
 726                 struct super_block *sb = fc->root->d_sb;
 727                 struct hpfs_sb_info *sbi = hpfs_sb(sb);
 728
 729                 ctx->uid = sbi->sb_uid;
 730                 ctx->gid = sbi->sb_gid;
 731                 ctx->umask = 0777 & ~sbi->sb_mode;
 732                 ctx->lowercase = sbi->sb_lowercase;
 733                 ctx->eas = sbi->sb_eas;
 734                 ctx->chk = sbi->sb_chk;
 735                 ctx->chkdsk = sbi->sb_chkdsk;
 736                 ctx->errs = sbi->sb_err;
 737                 ctx->timeshift = sbi->sb_timeshift;
 738
 739         } else {
 740                 ctx->uid = current_uid();
 741                 ctx->gid = current_gid();
 742                 ctx->umask = current_umask();
 743                 ctx->lowercase = 0;
 744                 ctx->eas = 2;
 745                 ctx->chk = 1;
 746                 ctx->errs = 1;
 747                 ctx->chkdsk = 1;
 748                 ctx->timeshift = 0;
 749         }
 750
 751         fc->fs_private = ctx;
 752         fc->ops = &hpfs_fc_context_ops;
 753
 754         return 0;
 755 };
 756
 757 static struct file_system_type hpfs_fs_type = {
 758         .owner          = THIS_MODULE,
 759         .name           = "hpfs",
 760         .kill_sb        = kill_block_super,
 761         .fs_flags       = FS_REQUIRES_DEV,
 762         .init_fs_context = hpfs_init_fs_context,
 763         .parameters     = hpfs_param_spec,
 764 };
 765 MODULE_ALIAS_FS("hpfs");
 766
 767 static int __init init_hpfs_fs(void)
 768 {
 769         int err = init_inodecache();
 770         if (err)
 771                 goto out1;
 772         err = register_filesystem(&hpfs_fs_type);
 773         if (err)
 774                 goto out;
 775         return 0;
 776 out:
 777         destroy_inodecache();
 778 out1:
 779         return err;
 780 }
 781
 782 static void __exit exit_hpfs_fs(void)
 783 {
 784         unregister_filesystem(&hpfs_fs_type);
 785         destroy_inodecache();
 786 }
 787
 788 module_init(init_hpfs_fs)
 789 module_exit(exit_hpfs_fs)
 790 MODULE_DESCRIPTION("OS/2 HPFS file system support");
 791 MODULE_LICENSE("GPL");