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