2 * Copyright (C) International Business Machines Corp., 2000-2004
3 * Portions Copyright (C) Christoph Hellwig, 2001-2002
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.
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.
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
21 #include <linux/config.h>
22 #include <linux/module.h>
23 #include <linux/parser.h>
24 #include <linux/completion.h>
25 #include <linux/vfs.h>
26 #include <linux/mount.h>
27 #include <linux/moduleparam.h>
28 #include <linux/kthread.h>
29 #include <linux/posix_acl.h>
30 #include <asm/uaccess.h>
31 #include <linux/seq_file.h>
33 #include "jfs_incore.h"
34 #include "jfs_filsys.h"
35 #include "jfs_inode.h"
36 #include "jfs_metapage.h"
37 #include "jfs_superblock.h"
41 #include "jfs_debug.h"
43 MODULE_DESCRIPTION("The Journaled Filesystem (JFS)");
44 MODULE_AUTHOR("Steve Best/Dave Kleikamp/Barry Arndt, IBM");
45 MODULE_LICENSE("GPL");
47 static kmem_cache_t
* jfs_inode_cachep
;
49 static struct super_operations jfs_super_operations
;
50 static struct export_operations jfs_export_operations
;
51 static struct file_system_type jfs_fs_type
;
53 #define MAX_COMMIT_THREADS 64
54 static int commit_threads
= 0;
55 module_param(commit_threads
, int, 0);
56 MODULE_PARM_DESC(commit_threads
, "Number of commit threads");
58 static struct task_struct
*jfsCommitThread
[MAX_COMMIT_THREADS
];
59 struct task_struct
*jfsIOthread
;
60 struct task_struct
*jfsSyncThread
;
62 #ifdef CONFIG_JFS_DEBUG
63 int jfsloglevel
= JFS_LOGLEVEL_WARN
;
64 module_param(jfsloglevel
, int, 0644);
65 MODULE_PARM_DESC(jfsloglevel
, "Specify JFS loglevel (0, 1 or 2)");
68 static void jfs_handle_error(struct super_block
*sb
)
70 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
72 if (sb
->s_flags
& MS_RDONLY
)
75 updateSuper(sb
, FM_DIRTY
);
77 if (sbi
->flag
& JFS_ERR_PANIC
)
78 panic("JFS (device %s): panic forced after error\n",
80 else if (sbi
->flag
& JFS_ERR_REMOUNT_RO
) {
81 jfs_err("ERROR: (device %s): remounting filesystem "
84 sb
->s_flags
|= MS_RDONLY
;
87 /* nothing is done for continue beyond marking the superblock dirty */
90 void jfs_error(struct super_block
*sb
, const char * function
, ...)
92 static char error_buf
[256];
95 va_start(args
, function
);
96 vsprintf(error_buf
, function
, args
);
99 printk(KERN_ERR
"ERROR: (device %s): %s\n", sb
->s_id
, error_buf
);
101 jfs_handle_error(sb
);
104 static struct inode
*jfs_alloc_inode(struct super_block
*sb
)
106 struct jfs_inode_info
*jfs_inode
;
108 jfs_inode
= kmem_cache_alloc(jfs_inode_cachep
, GFP_NOFS
);
111 return &jfs_inode
->vfs_inode
;
114 static void jfs_destroy_inode(struct inode
*inode
)
116 struct jfs_inode_info
*ji
= JFS_IP(inode
);
118 BUG_ON(!list_empty(&ji
->anon_inode_list
));
120 spin_lock_irq(&ji
->ag_lock
);
121 if (ji
->active_ag
!= -1) {
122 struct bmap
*bmap
= JFS_SBI(inode
->i_sb
)->bmap
;
123 atomic_dec(&bmap
->db_active
[ji
->active_ag
]);
126 spin_unlock_irq(&ji
->ag_lock
);
128 #ifdef CONFIG_JFS_POSIX_ACL
129 if (ji
->i_acl
!= JFS_ACL_NOT_CACHED
) {
130 posix_acl_release(ji
->i_acl
);
131 ji
->i_acl
= JFS_ACL_NOT_CACHED
;
133 if (ji
->i_default_acl
!= JFS_ACL_NOT_CACHED
) {
134 posix_acl_release(ji
->i_default_acl
);
135 ji
->i_default_acl
= JFS_ACL_NOT_CACHED
;
139 kmem_cache_free(jfs_inode_cachep
, ji
);
142 static int jfs_statfs(struct super_block
*sb
, struct kstatfs
*buf
)
144 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
146 struct inomap
*imap
= JFS_IP(sbi
->ipimap
)->i_imap
;
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
;
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
160 * buf->f_files = atomic_read(&imap->im_numinos);
161 * buf->f_ffree = atomic_read(&imap->im_numfree);
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
));
170 buf
->f_namelen
= JFS_NAME_MAX
;
174 static void jfs_put_super(struct super_block
*sb
)
176 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
179 jfs_info("In jfs_put_super");
182 jfs_err("jfs_umount failed with return code %d", rc
);
184 unload_nls(sbi
->nls_tab
);
187 truncate_inode_pages(sbi
->direct_inode
->i_mapping
, 0);
188 iput(sbi
->direct_inode
);
189 sbi
->direct_inode
= NULL
;
195 Opt_integrity
, Opt_nointegrity
, Opt_iocharset
, Opt_resize
,
196 Opt_resize_nosize
, Opt_errors
, Opt_ignore
, Opt_err
, Opt_quota
,
197 Opt_usrquota
, Opt_grpquota
200 static match_table_t tokens
= {
201 {Opt_integrity
, "integrity"},
202 {Opt_nointegrity
, "nointegrity"},
203 {Opt_iocharset
, "iocharset=%s"},
204 {Opt_resize
, "resize=%u"},
205 {Opt_resize_nosize
, "resize"},
206 {Opt_errors
, "errors=%s"},
207 {Opt_ignore
, "noquota"},
208 {Opt_ignore
, "quota"},
209 {Opt_usrquota
, "usrquota"},
210 {Opt_grpquota
, "grpquota"},
214 static int parse_options(char *options
, struct super_block
*sb
, s64
*newLVSize
,
217 void *nls_map
= (void *)-1; /* -1: no change; NULL: none */
219 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
226 while ((p
= strsep(&options
, ",")) != NULL
) {
227 substring_t args
[MAX_OPT_ARGS
];
232 token
= match_token(p
, tokens
, args
);
235 *flag
&= ~JFS_NOINTEGRITY
;
237 case Opt_nointegrity
:
238 *flag
|= JFS_NOINTEGRITY
;
241 /* Silently ignore the quota options */
242 /* Don't do anything ;-) */
245 if (nls_map
&& nls_map
!= (void *) -1)
247 if (!strcmp(args
[0].from
, "none"))
250 nls_map
= load_nls(args
[0].from
);
253 "JFS: charset not found\n");
260 char *resize
= args
[0].from
;
261 *newLVSize
= simple_strtoull(resize
, &resize
, 0);
264 case Opt_resize_nosize
:
266 *newLVSize
= sb
->s_bdev
->bd_inode
->i_size
>>
267 sb
->s_blocksize_bits
;
270 "JFS: Cannot determine volume size\n");
275 char *errors
= args
[0].from
;
276 if (!errors
|| !*errors
)
278 if (!strcmp(errors
, "continue")) {
279 *flag
&= ~JFS_ERR_REMOUNT_RO
;
280 *flag
&= ~JFS_ERR_PANIC
;
281 *flag
|= JFS_ERR_CONTINUE
;
282 } else if (!strcmp(errors
, "remount-ro")) {
283 *flag
&= ~JFS_ERR_CONTINUE
;
284 *flag
&= ~JFS_ERR_PANIC
;
285 *flag
|= JFS_ERR_REMOUNT_RO
;
286 } else if (!strcmp(errors
, "panic")) {
287 *flag
&= ~JFS_ERR_CONTINUE
;
288 *flag
&= ~JFS_ERR_REMOUNT_RO
;
289 *flag
|= JFS_ERR_PANIC
;
292 "JFS: %s is an invalid error handler\n",
299 #if defined(CONFIG_QUOTA)
302 *flag
|= JFS_USRQUOTA
;
305 *flag
|= JFS_GRPQUOTA
;
312 "JFS: quota operations not supported\n");
317 printk("jfs: Unrecognized mount option \"%s\" "
318 " or missing value\n", p
);
323 if (nls_map
!= (void *) -1) {
324 /* Discard old (if remount) */
326 unload_nls(sbi
->nls_tab
);
327 sbi
->nls_tab
= nls_map
;
332 if (nls_map
&& nls_map
!= (void *) -1)
337 static int jfs_remount(struct super_block
*sb
, int *flags
, char *data
)
341 int flag
= JFS_SBI(sb
)->flag
;
343 if (!parse_options(data
, sb
, &newLVSize
, &flag
)) {
347 if (sb
->s_flags
& MS_RDONLY
) {
349 "JFS: resize requires volume to be mounted read-write\n");
352 rc
= jfs_extendfs(sb
, newLVSize
, 0);
357 if ((sb
->s_flags
& MS_RDONLY
) && !(*flags
& MS_RDONLY
)) {
359 * Invalidate any previously read metadata. fsck may have
360 * changed the on-disk data since we mounted r/o
362 truncate_inode_pages(JFS_SBI(sb
)->direct_inode
->i_mapping
, 0);
364 JFS_SBI(sb
)->flag
= flag
;
365 return jfs_mount_rw(sb
, 1);
367 if ((!(sb
->s_flags
& MS_RDONLY
)) && (*flags
& MS_RDONLY
)) {
368 rc
= jfs_umount_rw(sb
);
369 JFS_SBI(sb
)->flag
= flag
;
372 if ((JFS_SBI(sb
)->flag
& JFS_NOINTEGRITY
) != (flag
& JFS_NOINTEGRITY
))
373 if (!(sb
->s_flags
& MS_RDONLY
)) {
374 rc
= jfs_umount_rw(sb
);
377 JFS_SBI(sb
)->flag
= flag
;
378 return jfs_mount_rw(sb
, 1);
380 JFS_SBI(sb
)->flag
= flag
;
385 static int jfs_fill_super(struct super_block
*sb
, void *data
, int silent
)
387 struct jfs_sb_info
*sbi
;
393 jfs_info("In jfs_read_super: s_flags=0x%lx", sb
->s_flags
);
395 if (!new_valid_dev(sb
->s_bdev
->bd_dev
))
398 sbi
= kzalloc(sizeof (struct jfs_sb_info
), GFP_KERNEL
);
404 /* initialize the mount flag and determine the default error handler */
405 flag
= JFS_ERR_REMOUNT_RO
;
407 if (!parse_options((char *) data
, sb
, &newLVSize
, &flag
)) {
413 #ifdef CONFIG_JFS_POSIX_ACL
414 sb
->s_flags
|= MS_POSIXACL
;
418 printk(KERN_ERR
"resize option for remount only\n");
423 * Initialize blocksize to 4K.
425 sb_set_blocksize(sb
, PSIZE
);
428 * Set method vectors.
430 sb
->s_op
= &jfs_super_operations
;
431 sb
->s_export_op
= &jfs_export_operations
;
434 * Initialize direct-mapping inode/address-space
436 inode
= new_inode(sb
);
441 inode
->i_size
= sb
->s_bdev
->bd_inode
->i_size
;
442 inode
->i_mapping
->a_ops
= &jfs_metapage_aops
;
443 insert_inode_hash(inode
);
444 mapping_set_gfp_mask(inode
->i_mapping
, GFP_NOFS
);
446 sbi
->direct_inode
= inode
;
451 jfs_err("jfs_mount failed w/return code = %d", rc
);
453 goto out_mount_failed
;
455 if (sb
->s_flags
& MS_RDONLY
)
458 rc
= jfs_mount_rw(sb
, 0);
461 jfs_err("jfs_mount_rw failed, return code = %d",
468 sb
->s_magic
= JFS_SUPER_MAGIC
;
470 inode
= iget(sb
, ROOT_I
);
471 if (!inode
|| is_bad_inode(inode
))
473 sb
->s_root
= d_alloc_root(inode
);
477 if (sbi
->mntflag
& JFS_OS2
)
478 sb
->s_root
->d_op
= &jfs_ci_dentry_operations
;
480 /* logical blocks are represented by 40 bits in pxd_t, etc. */
481 sb
->s_maxbytes
= ((u64
) sb
->s_blocksize
) << 40;
482 #if BITS_PER_LONG == 32
484 * Page cache is indexed by long.
485 * I would use MAX_LFS_FILESIZE, but it's only half as big
487 sb
->s_maxbytes
= min(((u64
) PAGE_CACHE_SIZE
<< 32) - 1, sb
->s_maxbytes
);
493 jfs_err("jfs_read_super: get root inode failed");
500 jfs_err("jfs_umount failed with return code %d", rc
);
503 filemap_write_and_wait(sbi
->direct_inode
->i_mapping
);
504 truncate_inode_pages(sbi
->direct_inode
->i_mapping
, 0);
505 make_bad_inode(sbi
->direct_inode
);
506 iput(sbi
->direct_inode
);
507 sbi
->direct_inode
= NULL
;
510 unload_nls(sbi
->nls_tab
);
515 static void jfs_write_super_lockfs(struct super_block
*sb
)
517 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
518 struct jfs_log
*log
= sbi
->log
;
520 if (!(sb
->s_flags
& MS_RDONLY
)) {
523 updateSuper(sb
, FM_CLEAN
);
527 static void jfs_unlockfs(struct super_block
*sb
)
529 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
530 struct jfs_log
*log
= sbi
->log
;
533 if (!(sb
->s_flags
& MS_RDONLY
)) {
534 updateSuper(sb
, FM_MOUNT
);
535 if ((rc
= lmLogInit(log
)))
536 jfs_err("jfs_unlock failed with return code %d", rc
);
542 static struct super_block
*jfs_get_sb(struct file_system_type
*fs_type
,
543 int flags
, const char *dev_name
, void *data
)
545 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, jfs_fill_super
);
548 static int jfs_sync_fs(struct super_block
*sb
, int wait
)
550 struct jfs_log
*log
= JFS_SBI(sb
)->log
;
552 /* log == NULL indicates read-only mount */
554 jfs_flush_journal(log
, wait
);
561 static int jfs_show_options(struct seq_file
*seq
, struct vfsmount
*vfs
)
563 struct jfs_sb_info
*sbi
= JFS_SBI(vfs
->mnt_sb
);
565 if (sbi
->flag
& JFS_NOINTEGRITY
)
566 seq_puts(seq
, ",nointegrity");
568 seq_puts(seq
, ",integrity");
570 #if defined(CONFIG_QUOTA)
571 if (sbi
->flag
& JFS_USRQUOTA
)
572 seq_puts(seq
, ",usrquota");
574 if (sbi
->flag
& JFS_GRPQUOTA
)
575 seq_puts(seq
, ",grpquota");
581 static struct super_operations jfs_super_operations
= {
582 .alloc_inode
= jfs_alloc_inode
,
583 .destroy_inode
= jfs_destroy_inode
,
584 .read_inode
= jfs_read_inode
,
585 .dirty_inode
= jfs_dirty_inode
,
586 .write_inode
= jfs_write_inode
,
587 .delete_inode
= jfs_delete_inode
,
588 .put_super
= jfs_put_super
,
589 .sync_fs
= jfs_sync_fs
,
590 .write_super_lockfs
= jfs_write_super_lockfs
,
591 .unlockfs
= jfs_unlockfs
,
592 .statfs
= jfs_statfs
,
593 .remount_fs
= jfs_remount
,
594 .show_options
= jfs_show_options
597 static struct export_operations jfs_export_operations
= {
598 .get_parent
= jfs_get_parent
,
601 static struct file_system_type jfs_fs_type
= {
602 .owner
= THIS_MODULE
,
604 .get_sb
= jfs_get_sb
,
605 .kill_sb
= kill_block_super
,
606 .fs_flags
= FS_REQUIRES_DEV
,
609 static void init_once(void *foo
, kmem_cache_t
* cachep
, unsigned long flags
)
611 struct jfs_inode_info
*jfs_ip
= (struct jfs_inode_info
*) foo
;
613 if ((flags
& (SLAB_CTOR_VERIFY
| SLAB_CTOR_CONSTRUCTOR
)) ==
614 SLAB_CTOR_CONSTRUCTOR
) {
615 memset(jfs_ip
, 0, sizeof(struct jfs_inode_info
));
616 INIT_LIST_HEAD(&jfs_ip
->anon_inode_list
);
617 init_rwsem(&jfs_ip
->rdwrlock
);
618 mutex_init(&jfs_ip
->commit_mutex
);
619 init_rwsem(&jfs_ip
->xattr_sem
);
620 spin_lock_init(&jfs_ip
->ag_lock
);
621 jfs_ip
->active_ag
= -1;
622 #ifdef CONFIG_JFS_POSIX_ACL
623 jfs_ip
->i_acl
= JFS_ACL_NOT_CACHED
;
624 jfs_ip
->i_default_acl
= JFS_ACL_NOT_CACHED
;
626 inode_init_once(&jfs_ip
->vfs_inode
);
630 static int __init
init_jfs_fs(void)
636 kmem_cache_create("jfs_ip", sizeof(struct jfs_inode_info
), 0,
637 SLAB_RECLAIM_ACCOUNT
, init_once
, NULL
);
638 if (jfs_inode_cachep
== NULL
)
642 * Metapage initialization
644 rc
= metapage_init();
646 jfs_err("metapage_init failed w/rc = %d", rc
);
651 * Transaction Manager initialization
655 jfs_err("txInit failed w/rc = %d", rc
);
660 * I/O completion thread (endio)
662 jfsIOthread
= kthread_run(jfsIOWait
, NULL
, "jfsIO");
663 if (IS_ERR(jfsIOthread
)) {
664 rc
= PTR_ERR(jfsIOthread
);
665 jfs_err("init_jfs_fs: fork failed w/rc = %d", rc
);
669 if (commit_threads
< 1)
670 commit_threads
= num_online_cpus();
671 if (commit_threads
> MAX_COMMIT_THREADS
)
672 commit_threads
= MAX_COMMIT_THREADS
;
674 for (i
= 0; i
< commit_threads
; i
++) {
675 jfsCommitThread
[i
] = kthread_run(jfs_lazycommit
, NULL
, "jfsCommit");
676 if (IS_ERR(jfsCommitThread
[i
])) {
677 rc
= PTR_ERR(jfsCommitThread
[i
]);
678 jfs_err("init_jfs_fs: fork failed w/rc = %d", rc
);
680 goto kill_committask
;
684 jfsSyncThread
= kthread_run(jfs_sync
, NULL
, "jfsSync");
685 if (IS_ERR(jfsSyncThread
)) {
686 rc
= PTR_ERR(jfsSyncThread
);
687 jfs_err("init_jfs_fs: fork failed w/rc = %d", rc
);
688 goto kill_committask
;
695 return register_filesystem(&jfs_fs_type
);
698 for (i
= 0; i
< commit_threads
; i
++)
699 kthread_stop(jfsCommitThread
[i
]);
700 kthread_stop(jfsIOthread
);
706 kmem_cache_destroy(jfs_inode_cachep
);
710 static void __exit
exit_jfs_fs(void)
714 jfs_info("exit_jfs_fs called");
719 kthread_stop(jfsIOthread
);
720 for (i
= 0; i
< commit_threads
; i
++)
721 kthread_stop(jfsCommitThread
[i
]);
722 kthread_stop(jfsSyncThread
);
726 unregister_filesystem(&jfs_fs_type
);
727 kmem_cache_destroy(jfs_inode_cachep
);
730 module_init(init_jfs_fs
)
731 module_exit(exit_jfs_fs
)