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