fs/jfs/super.c

   1 /*
   2  *   Copyright (C) International Business Machines Corp., 2000-2004
   3  *   Portions Copyright (C) Christoph Hellwig, 2001-2002
   4  *
   5  *   This program is free software;  you can redistribute it and/or modify
   6  *   it under the terms of the GNU General Public License as published by
   7  *   the Free Software Foundation; either version 2 of the License, or
   8  *   (at your option) any later version.
   9  *
  10  *   This program is distributed in the hope that it will be useful,
  11  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  13  *   the GNU General Public License for more details.
  14  *
  15  *   You should have received a copy of the GNU General Public License
  16  *   along with this program;  if not, write to the Free Software
  17  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  18  */
  19
  20 #include <linux/fs.h>
  21 #include <linux/module.h>
  22 #include <linux/parser.h>
  23 #include <linux/completion.h>
  24 #include <linux/vfs.h>
  25 #include <linux/quotaops.h>
  26 #include <linux/mount.h>
  27 #include <linux/moduleparam.h>
  28 #include <linux/kthread.h>
  29 #include <linux/posix_acl.h>
  30 #include <linux/buffer_head.h>
  31 #include <linux/exportfs.h>
  32 #include <linux/crc32.h>
  33 #include <linux/slab.h>
  34 #include <linux/uaccess.h>
  35 #include <linux/seq_file.h>
  36 #include <linux/blkdev.h>
  37
  38 #include "jfs_incore.h"
  39 #include "jfs_filsys.h"
  40 #include "jfs_inode.h"
  41 #include "jfs_metapage.h"
  42 #include "jfs_superblock.h"
  43 #include "jfs_dmap.h"
  44 #include "jfs_imap.h"
  45 #include "jfs_acl.h"
  46 #include "jfs_debug.h"
  47 #include "jfs_xattr.h"
  48 #include "jfs_dinode.h"
  49
  50 MODULE_DESCRIPTION("The Journaled Filesystem (JFS)");
  51 MODULE_AUTHOR("Steve Best/Dave Kleikamp/Barry Arndt, IBM");
  52 MODULE_LICENSE("GPL");
  53
  54 static struct kmem_cache *jfs_inode_cachep;
  55
  56 static const struct super_operations jfs_super_operations;
  57 static const struct export_operations jfs_export_operations;
  58 static struct file_system_type jfs_fs_type;
  59
  60 #define MAX_COMMIT_THREADS 64
  61 static int commit_threads;
  62 module_param(commit_threads, int, 0);
  63 MODULE_PARM_DESC(commit_threads, "Number of commit threads");
  64
  65 static struct task_struct *jfsCommitThread[MAX_COMMIT_THREADS];
  66 struct task_struct *jfsIOthread;
  67 struct task_struct *jfsSyncThread;
  68
  69 #ifdef CONFIG_JFS_DEBUG
  70 int jfsloglevel = JFS_LOGLEVEL_WARN;
  71 module_param(jfsloglevel, int, 0644);
  72 MODULE_PARM_DESC(jfsloglevel, "Specify JFS loglevel (0, 1 or 2)");
  73 #endif
  74
  75 static void jfs_handle_error(struct super_block *sb)
  76 {
  77         struct jfs_sb_info *sbi = JFS_SBI(sb);
  78
  79         if (sb_rdonly(sb))
  80                 return;
  81
  82         updateSuper(sb, FM_DIRTY);
  83
  84         if (sbi->flag & JFS_ERR_PANIC)
  85                 panic("JFS (device %s): panic forced after error\n",
  86                         sb->s_id);
  87         else if (sbi->flag & JFS_ERR_REMOUNT_RO) {
  88                 jfs_err("ERROR: (device %s): remounting filesystem as read-only",
  89                         sb->s_id);
  90                 sb->s_flags |= MS_RDONLY;
  91         }
  92
  93         /* nothing is done for continue beyond marking the superblock dirty */
  94 }
  95
  96 void jfs_error(struct super_block *sb, const char *fmt, ...)
  97 {
  98         struct va_format vaf;
  99         va_list args;
 100
 101         va_start(args, fmt);
 102
 103         vaf.fmt = fmt;
 104         vaf.va = &args;
 105
 106         pr_err("ERROR: (device %s): %ps: %pV\n",
 107                sb->s_id, __builtin_return_address(0), &vaf);
 108
 109         va_end(args);
 110
 111         jfs_handle_error(sb);
 112 }
 113
 114 static struct inode *jfs_alloc_inode(struct super_block *sb)
 115 {
 116         struct jfs_inode_info *jfs_inode;
 117
 118         jfs_inode = kmem_cache_alloc(jfs_inode_cachep, GFP_NOFS);
 119         if (!jfs_inode)
 120                 return NULL;
 121 #ifdef CONFIG_QUOTA
 122         memset(&jfs_inode->i_dquot, 0, sizeof(jfs_inode->i_dquot));
 123 #endif
 124         return &jfs_inode->vfs_inode;
 125 }
 126
 127 static void jfs_i_callback(struct rcu_head *head)
 128 {
 129         struct inode *inode = container_of(head, struct inode, i_rcu);
 130         struct jfs_inode_info *ji = JFS_IP(inode);
 131         kmem_cache_free(jfs_inode_cachep, ji);
 132 }
 133
 134 static void jfs_destroy_inode(struct inode *inode)
 135 {
 136         struct jfs_inode_info *ji = JFS_IP(inode);
 137
 138         BUG_ON(!list_empty(&ji->anon_inode_list));
 139
 140         spin_lock_irq(&ji->ag_lock);
 141         if (ji->active_ag != -1) {
 142                 struct bmap *bmap = JFS_SBI(inode->i_sb)->bmap;
 143                 atomic_dec(&bmap->db_active[ji->active_ag]);
 144                 ji->active_ag = -1;
 145         }
 146         spin_unlock_irq(&ji->ag_lock);
 147         call_rcu(&inode->i_rcu, jfs_i_callback);
 148 }
 149
 150 static int jfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 151 {
 152         struct jfs_sb_info *sbi = JFS_SBI(dentry->d_sb);
 153         s64 maxinodes;
 154         struct inomap *imap = JFS_IP(sbi->ipimap)->i_imap;
 155
 156         jfs_info("In jfs_statfs");
 157         buf->f_type = JFS_SUPER_MAGIC;
 158         buf->f_bsize = sbi->bsize;
 159         buf->f_blocks = sbi->bmap->db_mapsize;
 160         buf->f_bfree = sbi->bmap->db_nfree;
 161         buf->f_bavail = sbi->bmap->db_nfree;
 162         /*
 163          * If we really return the number of allocated & free inodes, some
 164          * applications will fail because they won't see enough free inodes.
 165          * We'll try to calculate some guess as to how many inodes we can
 166          * really allocate
 167          *
 168          * buf->f_files = atomic_read(&imap->im_numinos);
 169          * buf->f_ffree = atomic_read(&imap->im_numfree);
 170          */
 171         maxinodes = min((s64) atomic_read(&imap->im_numinos) +
 172                         ((sbi->bmap->db_nfree >> imap->im_l2nbperiext)
 173                          << L2INOSPEREXT), (s64) 0xffffffffLL);
 174         buf->f_files = maxinodes;
 175         buf->f_ffree = maxinodes - (atomic_read(&imap->im_numinos) -
 176                                     atomic_read(&imap->im_numfree));
 177         buf->f_fsid.val[0] = (u32)crc32_le(0, sbi->uuid, sizeof(sbi->uuid)/2);
 178         buf->f_fsid.val[1] = (u32)crc32_le(0, sbi->uuid + sizeof(sbi->uuid)/2,
 179                                         sizeof(sbi->uuid)/2);
 180
 181         buf->f_namelen = JFS_NAME_MAX;
 182         return 0;
 183 }
 184
 185 #ifdef CONFIG_QUOTA
 186 static int jfs_quota_off(struct super_block *sb, int type);
 187 static int jfs_quota_on(struct super_block *sb, int type, int format_id,
 188                         const struct path *path);
 189
 190 static void jfs_quota_off_umount(struct super_block *sb)
 191 {
 192         int type;
 193
 194         for (type = 0; type < MAXQUOTAS; type++)
 195                 jfs_quota_off(sb, type);
 196 }
 197
 198 static const struct quotactl_ops jfs_quotactl_ops = {
 199         .quota_on       = jfs_quota_on,
 200         .quota_off      = jfs_quota_off,
 201         .quota_sync     = dquot_quota_sync,
 202         .get_state      = dquot_get_state,
 203         .set_info       = dquot_set_dqinfo,
 204         .get_dqblk      = dquot_get_dqblk,
 205         .set_dqblk      = dquot_set_dqblk,
 206         .get_nextdqblk  = dquot_get_next_dqblk,
 207 };
 208 #else
 209 static inline void jfs_quota_off_umount(struct super_block *sb)
 210 {
 211 }
 212 #endif
 213
 214 static void jfs_put_super(struct super_block *sb)
 215 {
 216         struct jfs_sb_info *sbi = JFS_SBI(sb);
 217         int rc;
 218
 219         jfs_info("In jfs_put_super");
 220
 221         jfs_quota_off_umount(sb);
 222
 223         rc = jfs_umount(sb);
 224         if (rc)
 225                 jfs_err("jfs_umount failed with return code %d", rc);
 226
 227         unload_nls(sbi->nls_tab);
 228
 229         truncate_inode_pages(sbi->direct_inode->i_mapping, 0);
 230         iput(sbi->direct_inode);
 231
 232         kfree(sbi);
 233 }
 234
 235 enum {
 236         Opt_integrity, Opt_nointegrity, Opt_iocharset, Opt_resize,
 237         Opt_resize_nosize, Opt_errors, Opt_ignore, Opt_err, Opt_quota,
 238         Opt_usrquota, Opt_grpquota, Opt_uid, Opt_gid, Opt_umask,
 239         Opt_discard, Opt_nodiscard, Opt_discard_minblk
 240 };
 241
 242 static const match_table_t tokens = {
 243         {Opt_integrity, "integrity"},
 244         {Opt_nointegrity, "nointegrity"},
 245         {Opt_iocharset, "iocharset=%s"},
 246         {Opt_resize, "resize=%u"},
 247         {Opt_resize_nosize, "resize"},
 248         {Opt_errors, "errors=%s"},
 249         {Opt_ignore, "noquota"},
 250         {Opt_ignore, "quota"},
 251         {Opt_usrquota, "usrquota"},
 252         {Opt_grpquota, "grpquota"},
 253         {Opt_uid, "uid=%u"},
 254         {Opt_gid, "gid=%u"},
 255         {Opt_umask, "umask=%u"},
 256         {Opt_discard, "discard"},
 257         {Opt_nodiscard, "nodiscard"},
 258         {Opt_discard_minblk, "discard=%u"},
 259         {Opt_err, NULL}
 260 };
 261
 262 static int parse_options(char *options, struct super_block *sb, s64 *newLVSize,
 263                          int *flag)
 264 {
 265         void *nls_map = (void *)-1;     /* -1: no change;  NULL: none */
 266         char *p;
 267         struct jfs_sb_info *sbi = JFS_SBI(sb);
 268
 269         *newLVSize = 0;
 270
 271         if (!options)
 272                 return 1;
 273
 274         while ((p = strsep(&options, ",")) != NULL) {
 275                 substring_t args[MAX_OPT_ARGS];
 276                 int token;
 277                 if (!*p)
 278                         continue;
 279
 280                 token = match_token(p, tokens, args);
 281                 switch (token) {
 282                 case Opt_integrity:
 283                         *flag &= ~JFS_NOINTEGRITY;
 284                         break;
 285                 case Opt_nointegrity:
 286                         *flag |= JFS_NOINTEGRITY;
 287                         break;
 288                 case Opt_ignore:
 289                         /* Silently ignore the quota options */
 290                         /* Don't do anything ;-) */
 291                         break;
 292                 case Opt_iocharset:
 293                         if (nls_map && nls_map != (void *) -1)
 294                                 unload_nls(nls_map);
 295                         if (!strcmp(args[0].from, "none"))
 296                                 nls_map = NULL;
 297                         else {
 298                                 nls_map = load_nls(args[0].from);
 299                                 if (!nls_map) {
 300                                         pr_err("JFS: charset not found\n");
 301                                         goto cleanup;
 302                                 }
 303                         }
 304                         break;
 305                 case Opt_resize:
 306                 {
 307                         char *resize = args[0].from;
 308                         int rc = kstrtoll(resize, 0, newLVSize);
 309
 310                         if (rc)
 311                                 goto cleanup;
 312                         break;
 313                 }
 314                 case Opt_resize_nosize:
 315                 {
 316                         *newLVSize = i_size_read(sb->s_bdev->bd_inode) >>
 317                                 sb->s_blocksize_bits;
 318                         if (*newLVSize == 0)
 319                                 pr_err("JFS: Cannot determine volume size\n");
 320                         break;
 321                 }
 322                 case Opt_errors:
 323                 {
 324                         char *errors = args[0].from;
 325                         if (!errors || !*errors)
 326                                 goto cleanup;
 327                         if (!strcmp(errors, "continue")) {
 328                                 *flag &= ~JFS_ERR_REMOUNT_RO;
 329                                 *flag &= ~JFS_ERR_PANIC;
 330                                 *flag |= JFS_ERR_CONTINUE;
 331                         } else if (!strcmp(errors, "remount-ro")) {
 332                                 *flag &= ~JFS_ERR_CONTINUE;
 333                                 *flag &= ~JFS_ERR_PANIC;
 334                                 *flag |= JFS_ERR_REMOUNT_RO;
 335                         } else if (!strcmp(errors, "panic")) {
 336                                 *flag &= ~JFS_ERR_CONTINUE;
 337                                 *flag &= ~JFS_ERR_REMOUNT_RO;
 338                                 *flag |= JFS_ERR_PANIC;
 339                         } else {
 340                                 pr_err("JFS: %s is an invalid error handler\n",
 341                                        errors);
 342                                 goto cleanup;
 343                         }
 344                         break;
 345                 }
 346
 347 #ifdef CONFIG_QUOTA
 348                 case Opt_quota:
 349                 case Opt_usrquota:
 350                         *flag |= JFS_USRQUOTA;
 351                         break;
 352                 case Opt_grpquota:
 353                         *flag |= JFS_GRPQUOTA;
 354                         break;
 355 #else
 356                 case Opt_usrquota:
 357                 case Opt_grpquota:
 358                 case Opt_quota:
 359                         pr_err("JFS: quota operations not supported\n");
 360                         break;
 361 #endif
 362                 case Opt_uid:
 363                 {
 364                         char *uid = args[0].from;
 365                         uid_t val;
 366                         int rc = kstrtouint(uid, 0, &val);
 367
 368                         if (rc)
 369                                 goto cleanup;
 370                         sbi->uid = make_kuid(current_user_ns(), val);
 371                         if (!uid_valid(sbi->uid))
 372                                 goto cleanup;
 373                         break;
 374                 }
 375
 376                 case Opt_gid:
 377                 {
 378                         char *gid = args[0].from;
 379                         gid_t val;
 380                         int rc = kstrtouint(gid, 0, &val);
 381
 382                         if (rc)
 383                                 goto cleanup;
 384                         sbi->gid = make_kgid(current_user_ns(), val);
 385                         if (!gid_valid(sbi->gid))
 386                                 goto cleanup;
 387                         break;
 388                 }
 389
 390                 case Opt_umask:
 391                 {
 392                         char *umask = args[0].from;
 393                         int rc = kstrtouint(umask, 8, &sbi->umask);
 394
 395                         if (rc)
 396                                 goto cleanup;
 397                         if (sbi->umask & ~0777) {
 398                                 pr_err("JFS: Invalid value of umask\n");
 399                                 goto cleanup;
 400                         }
 401                         break;
 402                 }
 403
 404                 case Opt_discard:
 405                 {
 406                         struct request_queue *q = bdev_get_queue(sb->s_bdev);
 407                         /* if set to 1, even copying files will cause
 408                          * trimming :O
 409                          * -> user has more control over the online trimming
 410                          */
 411                         sbi->minblks_trim = 64;
 412                         if (blk_queue_discard(q))
 413                                 *flag |= JFS_DISCARD;
 414                         else
 415                                 pr_err("JFS: discard option not supported on device\n");
 416                         break;
 417                 }
 418
 419                 case Opt_nodiscard:
 420                         *flag &= ~JFS_DISCARD;
 421                         break;
 422
 423                 case Opt_discard_minblk:
 424                 {
 425                         struct request_queue *q = bdev_get_queue(sb->s_bdev);
 426                         char *minblks_trim = args[0].from;
 427                         int rc;
 428                         if (blk_queue_discard(q)) {
 429                                 *flag |= JFS_DISCARD;
 430                                 rc = kstrtouint(minblks_trim, 0,
 431                                                 &sbi->minblks_trim);
 432                                 if (rc)
 433                                         goto cleanup;
 434                         } else
 435                                 pr_err("JFS: discard option not supported on device\n");
 436                         break;
 437                 }
 438
 439                 default:
 440                         printk("jfs: Unrecognized mount option \"%s\" or missing value\n",
 441                                p);
 442                         goto cleanup;
 443                 }
 444         }
 445
 446         if (nls_map != (void *) -1) {
 447                 /* Discard old (if remount) */
 448                 unload_nls(sbi->nls_tab);
 449                 sbi->nls_tab = nls_map;
 450         }
 451         return 1;
 452
 453 cleanup:
 454         if (nls_map && nls_map != (void *) -1)
 455                 unload_nls(nls_map);
 456         return 0;
 457 }
 458
 459 static int jfs_remount(struct super_block *sb, int *flags, char *data)
 460 {
 461         s64 newLVSize = 0;
 462         int rc = 0;
 463         int flag = JFS_SBI(sb)->flag;
 464         int ret;
 465
 466         sync_filesystem(sb);
 467         if (!parse_options(data, sb, &newLVSize, &flag))
 468                 return -EINVAL;
 469
 470         if (newLVSize) {
 471                 if (sb_rdonly(sb)) {
 472                         pr_err("JFS: resize requires volume to be mounted read-write\n");
 473                         return -EROFS;
 474                 }
 475                 rc = jfs_extendfs(sb, newLVSize, 0);
 476                 if (rc)
 477                         return rc;
 478         }
 479
 480         if (sb_rdonly(sb) && !(*flags & MS_RDONLY)) {
 481                 /*
 482                  * Invalidate any previously read metadata.  fsck may have
 483                  * changed the on-disk data since we mounted r/o
 484                  */
 485                 truncate_inode_pages(JFS_SBI(sb)->direct_inode->i_mapping, 0);
 486
 487                 JFS_SBI(sb)->flag = flag;
 488                 ret = jfs_mount_rw(sb, 1);
 489
 490                 /* mark the fs r/w for quota activity */
 491                 sb->s_flags &= ~MS_RDONLY;
 492
 493                 dquot_resume(sb, -1);
 494                 return ret;
 495         }
 496         if (!sb_rdonly(sb) && (*flags & MS_RDONLY)) {
 497                 rc = dquot_suspend(sb, -1);
 498                 if (rc < 0)
 499                         return rc;
 500                 rc = jfs_umount_rw(sb);
 501                 JFS_SBI(sb)->flag = flag;
 502                 return rc;
 503         }
 504         if ((JFS_SBI(sb)->flag & JFS_NOINTEGRITY) != (flag & JFS_NOINTEGRITY))
 505                 if (!sb_rdonly(sb)) {
 506                         rc = jfs_umount_rw(sb);
 507                         if (rc)
 508                                 return rc;
 509
 510                         JFS_SBI(sb)->flag = flag;
 511                         ret = jfs_mount_rw(sb, 1);
 512                         return ret;
 513                 }
 514         JFS_SBI(sb)->flag = flag;
 515
 516         return 0;
 517 }
 518
 519 static int jfs_fill_super(struct super_block *sb, void *data, int silent)
 520 {
 521         struct jfs_sb_info *sbi;
 522         struct inode *inode;
 523         int rc;
 524         s64 newLVSize = 0;
 525         int flag, ret = -EINVAL;
 526
 527         jfs_info("In jfs_read_super: s_flags=0x%lx", sb->s_flags);
 528
 529         sbi = kzalloc(sizeof(struct jfs_sb_info), GFP_KERNEL);
 530         if (!sbi)
 531                 return -ENOMEM;
 532
 533         sb->s_fs_info = sbi;
 534         sb->s_max_links = JFS_LINK_MAX;
 535         sbi->sb = sb;
 536         sbi->uid = INVALID_UID;
 537         sbi->gid = INVALID_GID;
 538         sbi->umask = -1;
 539
 540         /* initialize the mount flag and determine the default error handler */
 541         flag = JFS_ERR_REMOUNT_RO;
 542
 543         if (!parse_options((char *) data, sb, &newLVSize, &flag))
 544                 goto out_kfree;
 545         sbi->flag = flag;
 546
 547 #ifdef CONFIG_JFS_POSIX_ACL
 548         sb->s_flags |= MS_POSIXACL;
 549 #endif
 550
 551         if (newLVSize) {
 552                 pr_err("resize option for remount only\n");
 553                 goto out_kfree;
 554         }
 555
 556         /*
 557          * Initialize blocksize to 4K.
 558          */
 559         sb_set_blocksize(sb, PSIZE);
 560
 561         /*
 562          * Set method vectors.
 563          */
 564         sb->s_op = &jfs_super_operations;
 565         sb->s_export_op = &jfs_export_operations;
 566         sb->s_xattr = jfs_xattr_handlers;
 567 #ifdef CONFIG_QUOTA
 568         sb->dq_op = &dquot_operations;
 569         sb->s_qcop = &jfs_quotactl_ops;
 570         sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;
 571 #endif
 572
 573         /*
 574          * Initialize direct-mapping inode/address-space
 575          */
 576         inode = new_inode(sb);
 577         if (inode == NULL) {
 578                 ret = -ENOMEM;
 579                 goto out_unload;
 580         }
 581         inode->i_ino = 0;
 582         inode->i_size = i_size_read(sb->s_bdev->bd_inode);
 583         inode->i_mapping->a_ops = &jfs_metapage_aops;
 584         hlist_add_fake(&inode->i_hash);
 585         mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
 586
 587         sbi->direct_inode = inode;
 588
 589         rc = jfs_mount(sb);
 590         if (rc) {
 591                 if (!silent)
 592                         jfs_err("jfs_mount failed w/return code = %d", rc);
 593                 goto out_mount_failed;
 594         }
 595         if (sb_rdonly(sb))
 596                 sbi->log = NULL;
 597         else {
 598                 rc = jfs_mount_rw(sb, 0);
 599                 if (rc) {
 600                         if (!silent) {
 601                                 jfs_err("jfs_mount_rw failed, return code = %d",
 602                                         rc);
 603                         }
 604                         goto out_no_rw;
 605                 }
 606         }
 607
 608         sb->s_magic = JFS_SUPER_MAGIC;
 609
 610         if (sbi->mntflag & JFS_OS2)
 611                 sb->s_d_op = &jfs_ci_dentry_operations;
 612
 613         inode = jfs_iget(sb, ROOT_I);
 614         if (IS_ERR(inode)) {
 615                 ret = PTR_ERR(inode);
 616                 goto out_no_rw;
 617         }
 618         sb->s_root = d_make_root(inode);
 619         if (!sb->s_root)
 620                 goto out_no_root;
 621
 622         /* logical blocks are represented by 40 bits in pxd_t, etc.
 623          * and page cache is indexed by long
 624          */
 625         sb->s_maxbytes = min(((loff_t)sb->s_blocksize) << 40, MAX_LFS_FILESIZE);
 626         sb->s_time_gran = 1;
 627         return 0;
 628
 629 out_no_root:
 630         jfs_err("jfs_read_super: get root dentry failed");
 631
 632 out_no_rw:
 633         rc = jfs_umount(sb);
 634         if (rc)
 635                 jfs_err("jfs_umount failed with return code %d", rc);
 636 out_mount_failed:
 637         filemap_write_and_wait(sbi->direct_inode->i_mapping);
 638         truncate_inode_pages(sbi->direct_inode->i_mapping, 0);
 639         make_bad_inode(sbi->direct_inode);
 640         iput(sbi->direct_inode);
 641         sbi->direct_inode = NULL;
 642 out_unload:
 643         unload_nls(sbi->nls_tab);
 644 out_kfree:
 645         kfree(sbi);
 646         return ret;
 647 }
 648
 649 static int jfs_freeze(struct super_block *sb)
 650 {
 651         struct jfs_sb_info *sbi = JFS_SBI(sb);
 652         struct jfs_log *log = sbi->log;
 653         int rc = 0;
 654
 655         if (!sb_rdonly(sb)) {
 656                 txQuiesce(sb);
 657                 rc = lmLogShutdown(log);
 658                 if (rc) {
 659                         jfs_error(sb, "lmLogShutdown failed\n");
 660
 661                         /* let operations fail rather than hang */
 662                         txResume(sb);
 663
 664                         return rc;
 665                 }
 666                 rc = updateSuper(sb, FM_CLEAN);
 667                 if (rc) {
 668                         jfs_err("jfs_freeze: updateSuper failed");
 669                         /*
 670                          * Don't fail here. Everything succeeded except
 671                          * marking the superblock clean, so there's really
 672                          * no harm in leaving it frozen for now.
 673                          */
 674                 }
 675         }
 676         return 0;
 677 }
 678
 679 static int jfs_unfreeze(struct super_block *sb)
 680 {
 681         struct jfs_sb_info *sbi = JFS_SBI(sb);
 682         struct jfs_log *log = sbi->log;
 683         int rc = 0;
 684
 685         if (!sb_rdonly(sb)) {
 686                 rc = updateSuper(sb, FM_MOUNT);
 687                 if (rc) {
 688                         jfs_error(sb, "updateSuper failed\n");
 689                         goto out;
 690                 }
 691                 rc = lmLogInit(log);
 692                 if (rc)
 693                         jfs_error(sb, "lmLogInit failed\n");
 694 out:
 695                 txResume(sb);
 696         }
 697         return rc;
 698 }
 699
 700 static struct dentry *jfs_do_mount(struct file_system_type *fs_type,
 701         int flags, const char *dev_name, void *data)
 702 {
 703         return mount_bdev(fs_type, flags, dev_name, data, jfs_fill_super);
 704 }
 705
 706 static int jfs_sync_fs(struct super_block *sb, int wait)
 707 {
 708         struct jfs_log *log = JFS_SBI(sb)->log;
 709
 710         /* log == NULL indicates read-only mount */
 711         if (log) {
 712                 /*
 713                  * Write quota structures to quota file, sync_blockdev() will
 714                  * write them to disk later
 715                  */
 716                 dquot_writeback_dquots(sb, -1);
 717                 jfs_flush_journal(log, wait);
 718                 jfs_syncpt(log, 0);
 719         }
 720
 721         return 0;
 722 }
 723
 724 static int jfs_show_options(struct seq_file *seq, struct dentry *root)
 725 {
 726         struct jfs_sb_info *sbi = JFS_SBI(root->d_sb);
 727
 728         if (uid_valid(sbi->uid))
 729                 seq_printf(seq, ",uid=%d", from_kuid(&init_user_ns, sbi->uid));
 730         if (gid_valid(sbi->gid))
 731                 seq_printf(seq, ",gid=%d", from_kgid(&init_user_ns, sbi->gid));
 732         if (sbi->umask != -1)
 733                 seq_printf(seq, ",umask=%03o", sbi->umask);
 734         if (sbi->flag & JFS_NOINTEGRITY)
 735                 seq_puts(seq, ",nointegrity");
 736         if (sbi->flag & JFS_DISCARD)
 737                 seq_printf(seq, ",discard=%u", sbi->minblks_trim);
 738         if (sbi->nls_tab)
 739                 seq_printf(seq, ",iocharset=%s", sbi->nls_tab->charset);
 740         if (sbi->flag & JFS_ERR_CONTINUE)
 741                 seq_printf(seq, ",errors=continue");
 742         if (sbi->flag & JFS_ERR_PANIC)
 743                 seq_printf(seq, ",errors=panic");
 744
 745 #ifdef CONFIG_QUOTA
 746         if (sbi->flag & JFS_USRQUOTA)
 747                 seq_puts(seq, ",usrquota");
 748
 749         if (sbi->flag & JFS_GRPQUOTA)
 750                 seq_puts(seq, ",grpquota");
 751 #endif
 752
 753         return 0;
 754 }
 755
 756 #ifdef CONFIG_QUOTA
 757
 758 /* Read data from quotafile - avoid pagecache and such because we cannot afford
 759  * acquiring the locks... As quota files are never truncated and quota code
 760  * itself serializes the operations (and no one else should touch the files)
 761  * we don't have to be afraid of races */
 762 static ssize_t jfs_quota_read(struct super_block *sb, int type, char *data,
 763                               size_t len, loff_t off)
 764 {
 765         struct inode *inode = sb_dqopt(sb)->files[type];
 766         sector_t blk = off >> sb->s_blocksize_bits;
 767         int err = 0;
 768         int offset = off & (sb->s_blocksize - 1);
 769         int tocopy;
 770         size_t toread;
 771         struct buffer_head tmp_bh;
 772         struct buffer_head *bh;
 773         loff_t i_size = i_size_read(inode);
 774
 775         if (off > i_size)
 776                 return 0;
 777         if (off+len > i_size)
 778                 len = i_size-off;
 779         toread = len;
 780         while (toread > 0) {
 781                 tocopy = sb->s_blocksize - offset < toread ?
 782                                 sb->s_blocksize - offset : toread;
 783
 784                 tmp_bh.b_state = 0;
 785                 tmp_bh.b_size = i_blocksize(inode);
 786                 err = jfs_get_block(inode, blk, &tmp_bh, 0);
 787                 if (err)
 788                         return err;
 789                 if (!buffer_mapped(&tmp_bh))    /* A hole? */
 790                         memset(data, 0, tocopy);
 791                 else {
 792                         bh = sb_bread(sb, tmp_bh.b_blocknr);
 793                         if (!bh)
 794                                 return -EIO;
 795                         memcpy(data, bh->b_data+offset, tocopy);
 796                         brelse(bh);
 797                 }
 798                 offset = 0;
 799                 toread -= tocopy;
 800                 data += tocopy;
 801                 blk++;
 802         }
 803         return len;
 804 }
 805
 806 /* Write to quotafile */
 807 static ssize_t jfs_quota_write(struct super_block *sb, int type,
 808                                const char *data, size_t len, loff_t off)
 809 {
 810         struct inode *inode = sb_dqopt(sb)->files[type];
 811         sector_t blk = off >> sb->s_blocksize_bits;
 812         int err = 0;
 813         int offset = off & (sb->s_blocksize - 1);
 814         int tocopy;
 815         size_t towrite = len;
 816         struct buffer_head tmp_bh;
 817         struct buffer_head *bh;
 818
 819         inode_lock(inode);
 820         while (towrite > 0) {
 821                 tocopy = sb->s_blocksize - offset < towrite ?
 822                                 sb->s_blocksize - offset : towrite;
 823
 824                 tmp_bh.b_state = 0;
 825                 tmp_bh.b_size = i_blocksize(inode);
 826                 err = jfs_get_block(inode, blk, &tmp_bh, 1);
 827                 if (err)
 828                         goto out;
 829                 if (offset || tocopy != sb->s_blocksize)
 830                         bh = sb_bread(sb, tmp_bh.b_blocknr);
 831                 else
 832                         bh = sb_getblk(sb, tmp_bh.b_blocknr);
 833                 if (!bh) {
 834                         err = -EIO;
 835                         goto out;
 836                 }
 837                 lock_buffer(bh);
 838                 memcpy(bh->b_data+offset, data, tocopy);
 839                 flush_dcache_page(bh->b_page);
 840                 set_buffer_uptodate(bh);
 841                 mark_buffer_dirty(bh);
 842                 unlock_buffer(bh);
 843                 brelse(bh);
 844                 offset = 0;
 845                 towrite -= tocopy;
 846                 data += tocopy;
 847                 blk++;
 848         }
 849 out:
 850         if (len == towrite) {
 851                 inode_unlock(inode);
 852                 return err;
 853         }
 854         if (inode->i_size < off+len-towrite)
 855                 i_size_write(inode, off+len-towrite);
 856         inode->i_version++;
 857         inode->i_mtime = inode->i_ctime = current_time(inode);
 858         mark_inode_dirty(inode);
 859         inode_unlock(inode);
 860         return len - towrite;
 861 }
 862
 863 static struct dquot **jfs_get_dquots(struct inode *inode)
 864 {
 865         return JFS_IP(inode)->i_dquot;
 866 }
 867
 868 static int jfs_quota_on(struct super_block *sb, int type, int format_id,
 869                         const struct path *path)
 870 {
 871         int err;
 872         struct inode *inode;
 873
 874         err = dquot_quota_on(sb, type, format_id, path);
 875         if (err)
 876                 return err;
 877
 878         inode = d_inode(path->dentry);
 879         inode_lock(inode);
 880         JFS_IP(inode)->mode2 |= JFS_NOATIME_FL | JFS_IMMUTABLE_FL;
 881         inode_set_flags(inode, S_NOATIME | S_IMMUTABLE,
 882                         S_NOATIME | S_IMMUTABLE);
 883         inode_unlock(inode);
 884         mark_inode_dirty(inode);
 885
 886         return 0;
 887 }
 888
 889 static int jfs_quota_off(struct super_block *sb, int type)
 890 {
 891         struct inode *inode = sb_dqopt(sb)->files[type];
 892         int err;
 893
 894         if (!inode || !igrab(inode))
 895                 goto out;
 896
 897         err = dquot_quota_off(sb, type);
 898         if (err)
 899                 goto out_put;
 900
 901         inode_lock(inode);
 902         JFS_IP(inode)->mode2 &= ~(JFS_NOATIME_FL | JFS_IMMUTABLE_FL);
 903         inode_set_flags(inode, 0, S_NOATIME | S_IMMUTABLE);
 904         inode_unlock(inode);
 905         mark_inode_dirty(inode);
 906 out_put:
 907         iput(inode);
 908         return err;
 909 out:
 910         return dquot_quota_off(sb, type);
 911 }
 912 #endif
 913
 914 static const struct super_operations jfs_super_operations = {
 915         .alloc_inode    = jfs_alloc_inode,
 916         .destroy_inode  = jfs_destroy_inode,
 917         .dirty_inode    = jfs_dirty_inode,
 918         .write_inode    = jfs_write_inode,
 919         .evict_inode    = jfs_evict_inode,
 920         .put_super      = jfs_put_super,
 921         .sync_fs        = jfs_sync_fs,
 922         .freeze_fs      = jfs_freeze,
 923         .unfreeze_fs    = jfs_unfreeze,
 924         .statfs         = jfs_statfs,
 925         .remount_fs     = jfs_remount,
 926         .show_options   = jfs_show_options,
 927 #ifdef CONFIG_QUOTA
 928         .quota_read     = jfs_quota_read,
 929         .quota_write    = jfs_quota_write,
 930         .get_dquots     = jfs_get_dquots,
 931 #endif
 932 };
 933
 934 static const struct export_operations jfs_export_operations = {
 935         .fh_to_dentry   = jfs_fh_to_dentry,
 936         .fh_to_parent   = jfs_fh_to_parent,
 937         .get_parent     = jfs_get_parent,
 938 };
 939
 940 static struct file_system_type jfs_fs_type = {
 941         .owner          = THIS_MODULE,
 942         .name           = "jfs",
 943         .mount          = jfs_do_mount,
 944         .kill_sb        = kill_block_super,
 945         .fs_flags       = FS_REQUIRES_DEV,
 946 };
 947 MODULE_ALIAS_FS("jfs");
 948
 949 static void init_once(void *foo)
 950 {
 951         struct jfs_inode_info *jfs_ip = (struct jfs_inode_info *) foo;
 952
 953         memset(jfs_ip, 0, sizeof(struct jfs_inode_info));
 954         INIT_LIST_HEAD(&jfs_ip->anon_inode_list);
 955         init_rwsem(&jfs_ip->rdwrlock);
 956         mutex_init(&jfs_ip->commit_mutex);
 957         init_rwsem(&jfs_ip->xattr_sem);
 958         spin_lock_init(&jfs_ip->ag_lock);
 959         jfs_ip->active_ag = -1;
 960         inode_init_once(&jfs_ip->vfs_inode);
 961 }
 962
 963 static int __init init_jfs_fs(void)
 964 {
 965         int i;
 966         int rc;
 967
 968         jfs_inode_cachep =
 969             kmem_cache_create("jfs_ip", sizeof(struct jfs_inode_info), 0,
 970                             SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|SLAB_ACCOUNT,
 971                             init_once);
 972         if (jfs_inode_cachep == NULL)
 973                 return -ENOMEM;
 974
 975         /*
 976          * Metapage initialization
 977          */
 978         rc = metapage_init();
 979         if (rc) {
 980                 jfs_err("metapage_init failed w/rc = %d", rc);
 981                 goto free_slab;
 982         }
 983
 984         /*
 985          * Transaction Manager initialization
 986          */
 987         rc = txInit();
 988         if (rc) {
 989                 jfs_err("txInit failed w/rc = %d", rc);
 990                 goto free_metapage;
 991         }
 992
 993         /*
 994          * I/O completion thread (endio)
 995          */
 996         jfsIOthread = kthread_run(jfsIOWait, NULL, "jfsIO");
 997         if (IS_ERR(jfsIOthread)) {
 998                 rc = PTR_ERR(jfsIOthread);
 999                 jfs_err("init_jfs_fs: fork failed w/rc = %d", rc);
1000                 goto end_txmngr;
1001         }
1002
1003         if (commit_threads < 1)
1004                 commit_threads = num_online_cpus();
1005         if (commit_threads > MAX_COMMIT_THREADS)
1006                 commit_threads = MAX_COMMIT_THREADS;
1007
1008         for (i = 0; i < commit_threads; i++) {
1009                 jfsCommitThread[i] = kthread_run(jfs_lazycommit, NULL,
1010                                                  "jfsCommit");
1011                 if (IS_ERR(jfsCommitThread[i])) {
1012                         rc = PTR_ERR(jfsCommitThread[i]);
1013                         jfs_err("init_jfs_fs: fork failed w/rc = %d", rc);
1014                         commit_threads = i;
1015                         goto kill_committask;
1016                 }
1017         }
1018
1019         jfsSyncThread = kthread_run(jfs_sync, NULL, "jfsSync");
1020         if (IS_ERR(jfsSyncThread)) {
1021                 rc = PTR_ERR(jfsSyncThread);
1022                 jfs_err("init_jfs_fs: fork failed w/rc = %d", rc);
1023                 goto kill_committask;
1024         }
1025
1026 #ifdef PROC_FS_JFS
1027         jfs_proc_init();
1028 #endif
1029
1030         rc = register_filesystem(&jfs_fs_type);
1031         if (!rc)
1032                 return 0;
1033
1034 #ifdef PROC_FS_JFS
1035         jfs_proc_clean();
1036 #endif
1037         kthread_stop(jfsSyncThread);
1038 kill_committask:
1039         for (i = 0; i < commit_threads; i++)
1040                 kthread_stop(jfsCommitThread[i]);
1041         kthread_stop(jfsIOthread);
1042 end_txmngr:
1043         txExit();
1044 free_metapage:
1045         metapage_exit();
1046 free_slab:
1047         kmem_cache_destroy(jfs_inode_cachep);
1048         return rc;
1049 }
1050
1051 static void __exit exit_jfs_fs(void)
1052 {
1053         int i;
1054
1055         jfs_info("exit_jfs_fs called");
1056
1057         txExit();
1058         metapage_exit();
1059
1060         kthread_stop(jfsIOthread);
1061         for (i = 0; i < commit_threads; i++)
1062                 kthread_stop(jfsCommitThread[i]);
1063         kthread_stop(jfsSyncThread);
1064 #ifdef PROC_FS_JFS
1065         jfs_proc_clean();
1066 #endif
1067         unregister_filesystem(&jfs_fs_type);
1068
1069         /*
1070          * Make sure all delayed rcu free inodes are flushed before we
1071          * destroy cache.
1072          */
1073         rcu_barrier();
1074         kmem_cache_destroy(jfs_inode_cachep);
1075 }
1076
1077 module_init(init_jfs_fs)
1078 module_exit(exit_jfs_fs)