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/posix_acl.h>
29 #include <asm/uaccess.h>
30 #include <linux/seq_file.h>
32 #include "jfs_incore.h"
33 #include "jfs_filsys.h"
34 #include "jfs_inode.h"
35 #include "jfs_metapage.h"
36 #include "jfs_superblock.h"
40 #include "jfs_debug.h"
42 MODULE_DESCRIPTION("The Journaled Filesystem (JFS)");
43 MODULE_AUTHOR("Steve Best/Dave Kleikamp/Barry Arndt, IBM");
44 MODULE_LICENSE("GPL");
46 static kmem_cache_t
* jfs_inode_cachep
;
48 static struct super_operations jfs_super_operations
;
49 static struct export_operations jfs_export_operations
;
50 static struct file_system_type jfs_fs_type
;
52 #define MAX_COMMIT_THREADS 64
53 static int commit_threads
= 0;
54 module_param(commit_threads
, int, 0);
55 MODULE_PARM_DESC(commit_threads
, "Number of commit threads");
58 static pid_t jfsIOthread
;
59 static pid_t jfsCommitThread
[MAX_COMMIT_THREADS
];
60 static pid_t jfsSyncThread
;
61 DECLARE_COMPLETION(jfsIOwait
);
63 #ifdef CONFIG_JFS_DEBUG
64 int jfsloglevel
= JFS_LOGLEVEL_WARN
;
65 module_param(jfsloglevel
, int, 0644);
66 MODULE_PARM_DESC(jfsloglevel
, "Specify JFS loglevel (0, 1 or 2)");
69 static void jfs_handle_error(struct super_block
*sb
)
71 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
73 if (sb
->s_flags
& MS_RDONLY
)
76 updateSuper(sb
, FM_DIRTY
);
78 if (sbi
->flag
& JFS_ERR_PANIC
)
79 panic("JFS (device %s): panic forced after error\n",
81 else if (sbi
->flag
& JFS_ERR_REMOUNT_RO
) {
82 jfs_err("ERROR: (device %s): remounting filesystem "
85 sb
->s_flags
|= MS_RDONLY
;
88 /* nothing is done for continue beyond marking the superblock dirty */
91 void jfs_error(struct super_block
*sb
, const char * function
, ...)
93 static char error_buf
[256];
96 va_start(args
, function
);
97 vsprintf(error_buf
, function
, args
);
100 printk(KERN_ERR
"ERROR: (device %s): %s\n", sb
->s_id
, error_buf
);
102 jfs_handle_error(sb
);
105 static struct inode
*jfs_alloc_inode(struct super_block
*sb
)
107 struct jfs_inode_info
*jfs_inode
;
109 jfs_inode
= kmem_cache_alloc(jfs_inode_cachep
, GFP_NOFS
);
112 return &jfs_inode
->vfs_inode
;
115 static void jfs_destroy_inode(struct inode
*inode
)
117 struct jfs_inode_info
*ji
= JFS_IP(inode
);
119 BUG_ON(!list_empty(&ji
->anon_inode_list
));
121 spin_lock_irq(&ji
->ag_lock
);
122 if (ji
->active_ag
!= -1) {
123 struct bmap
*bmap
= JFS_SBI(inode
->i_sb
)->bmap
;
124 atomic_dec(&bmap
->db_active
[ji
->active_ag
]);
127 spin_unlock_irq(&ji
->ag_lock
);
129 #ifdef CONFIG_JFS_POSIX_ACL
130 if (ji
->i_acl
!= JFS_ACL_NOT_CACHED
) {
131 posix_acl_release(ji
->i_acl
);
132 ji
->i_acl
= JFS_ACL_NOT_CACHED
;
134 if (ji
->i_default_acl
!= JFS_ACL_NOT_CACHED
) {
135 posix_acl_release(ji
->i_default_acl
);
136 ji
->i_default_acl
= JFS_ACL_NOT_CACHED
;
140 kmem_cache_free(jfs_inode_cachep
, ji
);
143 static int jfs_statfs(struct super_block
*sb
, struct kstatfs
*buf
)
145 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
147 struct inomap
*imap
= JFS_IP(sbi
->ipimap
)->i_imap
;
149 jfs_info("In jfs_statfs");
150 buf
->f_type
= JFS_SUPER_MAGIC
;
151 buf
->f_bsize
= sbi
->bsize
;
152 buf
->f_blocks
= sbi
->bmap
->db_mapsize
;
153 buf
->f_bfree
= sbi
->bmap
->db_nfree
;
154 buf
->f_bavail
= sbi
->bmap
->db_nfree
;
156 * If we really return the number of allocated & free inodes, some
157 * applications will fail because they won't see enough free inodes.
158 * We'll try to calculate some guess as to how may inodes we can
161 * buf->f_files = atomic_read(&imap->im_numinos);
162 * buf->f_ffree = atomic_read(&imap->im_numfree);
164 maxinodes
= min((s64
) atomic_read(&imap
->im_numinos
) +
165 ((sbi
->bmap
->db_nfree
>> imap
->im_l2nbperiext
)
166 << L2INOSPEREXT
), (s64
) 0xffffffffLL
);
167 buf
->f_files
= maxinodes
;
168 buf
->f_ffree
= maxinodes
- (atomic_read(&imap
->im_numinos
) -
169 atomic_read(&imap
->im_numfree
));
171 buf
->f_namelen
= JFS_NAME_MAX
;
175 static void jfs_put_super(struct super_block
*sb
)
177 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
180 jfs_info("In jfs_put_super");
183 jfs_err("jfs_umount failed with return code %d", rc
);
185 unload_nls(sbi
->nls_tab
);
188 truncate_inode_pages(sbi
->direct_inode
->i_mapping
, 0);
189 iput(sbi
->direct_inode
);
190 sbi
->direct_inode
= NULL
;
196 Opt_integrity
, Opt_nointegrity
, Opt_iocharset
, Opt_resize
,
197 Opt_resize_nosize
, Opt_errors
, Opt_ignore
, Opt_err
, Opt_quota
,
198 Opt_usrquota
, Opt_grpquota
201 static match_table_t tokens
= {
202 {Opt_integrity
, "integrity"},
203 {Opt_nointegrity
, "nointegrity"},
204 {Opt_iocharset
, "iocharset=%s"},
205 {Opt_resize
, "resize=%u"},
206 {Opt_resize_nosize
, "resize"},
207 {Opt_errors
, "errors=%s"},
208 {Opt_ignore
, "noquota"},
209 {Opt_ignore
, "quota"},
210 {Opt_usrquota
, "usrquota"},
211 {Opt_grpquota
, "grpquota"},
215 static int parse_options(char *options
, struct super_block
*sb
, s64
*newLVSize
,
218 void *nls_map
= (void *)-1; /* -1: no change; NULL: none */
220 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
227 while ((p
= strsep(&options
, ",")) != NULL
) {
228 substring_t args
[MAX_OPT_ARGS
];
233 token
= match_token(p
, tokens
, args
);
236 *flag
&= ~JFS_NOINTEGRITY
;
238 case Opt_nointegrity
:
239 *flag
|= JFS_NOINTEGRITY
;
242 /* Silently ignore the quota options */
243 /* Don't do anything ;-) */
246 if (nls_map
&& nls_map
!= (void *) -1)
248 if (!strcmp(args
[0].from
, "none"))
251 nls_map
= load_nls(args
[0].from
);
254 "JFS: charset not found\n");
261 char *resize
= args
[0].from
;
262 *newLVSize
= simple_strtoull(resize
, &resize
, 0);
265 case Opt_resize_nosize
:
267 *newLVSize
= sb
->s_bdev
->bd_inode
->i_size
>>
268 sb
->s_blocksize_bits
;
271 "JFS: Cannot determine volume size\n");
276 char *errors
= args
[0].from
;
277 if (!errors
|| !*errors
)
279 if (!strcmp(errors
, "continue")) {
280 *flag
&= ~JFS_ERR_REMOUNT_RO
;
281 *flag
&= ~JFS_ERR_PANIC
;
282 *flag
|= JFS_ERR_CONTINUE
;
283 } else if (!strcmp(errors
, "remount-ro")) {
284 *flag
&= ~JFS_ERR_CONTINUE
;
285 *flag
&= ~JFS_ERR_PANIC
;
286 *flag
|= JFS_ERR_REMOUNT_RO
;
287 } else if (!strcmp(errors
, "panic")) {
288 *flag
&= ~JFS_ERR_CONTINUE
;
289 *flag
&= ~JFS_ERR_REMOUNT_RO
;
290 *flag
|= JFS_ERR_PANIC
;
293 "JFS: %s is an invalid error handler\n",
300 #if defined(CONFIG_QUOTA)
303 *flag
|= JFS_USRQUOTA
;
306 *flag
|= JFS_GRPQUOTA
;
313 "JFS: quota operations not supported\n");
318 printk("jfs: Unrecognized mount option \"%s\" "
319 " or missing value\n", p
);
324 if (nls_map
!= (void *) -1) {
325 /* Discard old (if remount) */
327 unload_nls(sbi
->nls_tab
);
328 sbi
->nls_tab
= nls_map
;
333 if (nls_map
&& nls_map
!= (void *) -1)
338 static int jfs_remount(struct super_block
*sb
, int *flags
, char *data
)
342 int flag
= JFS_SBI(sb
)->flag
;
344 if (!parse_options(data
, sb
, &newLVSize
, &flag
)) {
348 if (sb
->s_flags
& MS_RDONLY
) {
350 "JFS: resize requires volume to be mounted read-write\n");
353 rc
= jfs_extendfs(sb
, newLVSize
, 0);
358 if ((sb
->s_flags
& MS_RDONLY
) && !(*flags
& MS_RDONLY
)) {
360 * Invalidate any previously read metadata. fsck may have
361 * changed the on-disk data since we mounted r/o
363 truncate_inode_pages(JFS_SBI(sb
)->direct_inode
->i_mapping
, 0);
365 JFS_SBI(sb
)->flag
= flag
;
366 return jfs_mount_rw(sb
, 1);
368 if ((!(sb
->s_flags
& MS_RDONLY
)) && (*flags
& MS_RDONLY
)) {
369 rc
= jfs_umount_rw(sb
);
370 JFS_SBI(sb
)->flag
= flag
;
373 if ((JFS_SBI(sb
)->flag
& JFS_NOINTEGRITY
) != (flag
& JFS_NOINTEGRITY
))
374 if (!(sb
->s_flags
& MS_RDONLY
)) {
375 rc
= jfs_umount_rw(sb
);
378 JFS_SBI(sb
)->flag
= flag
;
379 return jfs_mount_rw(sb
, 1);
381 JFS_SBI(sb
)->flag
= flag
;
386 static int jfs_fill_super(struct super_block
*sb
, void *data
, int silent
)
388 struct jfs_sb_info
*sbi
;
394 jfs_info("In jfs_read_super: s_flags=0x%lx", sb
->s_flags
);
396 if (!new_valid_dev(sb
->s_bdev
->bd_dev
))
399 sbi
= kmalloc(sizeof (struct jfs_sb_info
), GFP_KERNEL
);
402 memset(sbi
, 0, sizeof (struct jfs_sb_info
));
406 /* initialize the mount flag and determine the default error handler */
407 flag
= JFS_ERR_REMOUNT_RO
;
409 if (!parse_options((char *) data
, sb
, &newLVSize
, &flag
)) {
415 #ifdef CONFIG_JFS_POSIX_ACL
416 sb
->s_flags
|= MS_POSIXACL
;
420 printk(KERN_ERR
"resize option for remount only\n");
425 * Initialize blocksize to 4K.
427 sb_set_blocksize(sb
, PSIZE
);
430 * Set method vectors.
432 sb
->s_op
= &jfs_super_operations
;
433 sb
->s_export_op
= &jfs_export_operations
;
436 * Initialize direct-mapping inode/address-space
438 inode
= new_inode(sb
);
443 inode
->i_size
= sb
->s_bdev
->bd_inode
->i_size
;
444 inode
->i_mapping
->a_ops
= &jfs_metapage_aops
;
445 mapping_set_gfp_mask(inode
->i_mapping
, GFP_NOFS
);
447 sbi
->direct_inode
= inode
;
452 jfs_err("jfs_mount failed w/return code = %d", rc
);
454 goto out_mount_failed
;
456 if (sb
->s_flags
& MS_RDONLY
)
459 rc
= jfs_mount_rw(sb
, 0);
462 jfs_err("jfs_mount_rw failed, return code = %d",
469 sb
->s_magic
= JFS_SUPER_MAGIC
;
471 inode
= iget(sb
, ROOT_I
);
472 if (!inode
|| is_bad_inode(inode
))
474 sb
->s_root
= d_alloc_root(inode
);
478 if (sbi
->mntflag
& JFS_OS2
)
479 sb
->s_root
->d_op
= &jfs_ci_dentry_operations
;
481 /* logical blocks are represented by 40 bits in pxd_t, etc. */
482 sb
->s_maxbytes
= ((u64
) sb
->s_blocksize
) << 40;
483 #if BITS_PER_LONG == 32
485 * Page cache is indexed by long.
486 * I would use MAX_LFS_FILESIZE, but it's only half as big
488 sb
->s_maxbytes
= min(((u64
) PAGE_CACHE_SIZE
<< 32) - 1, sb
->s_maxbytes
);
494 jfs_err("jfs_read_super: get root inode failed");
501 jfs_err("jfs_umount failed with return code %d", rc
);
504 filemap_fdatawrite(sbi
->direct_inode
->i_mapping
);
505 filemap_fdatawait(sbi
->direct_inode
->i_mapping
);
506 truncate_inode_pages(sbi
->direct_inode
->i_mapping
, 0);
507 make_bad_inode(sbi
->direct_inode
);
508 iput(sbi
->direct_inode
);
509 sbi
->direct_inode
= NULL
;
512 unload_nls(sbi
->nls_tab
);
517 static void jfs_write_super_lockfs(struct super_block
*sb
)
519 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
520 struct jfs_log
*log
= sbi
->log
;
522 if (!(sb
->s_flags
& MS_RDONLY
)) {
525 updateSuper(sb
, FM_CLEAN
);
529 static void jfs_unlockfs(struct super_block
*sb
)
531 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
532 struct jfs_log
*log
= sbi
->log
;
535 if (!(sb
->s_flags
& MS_RDONLY
)) {
536 updateSuper(sb
, FM_MOUNT
);
537 if ((rc
= lmLogInit(log
)))
538 jfs_err("jfs_unlock failed with return code %d", rc
);
544 static struct super_block
*jfs_get_sb(struct file_system_type
*fs_type
,
545 int flags
, const char *dev_name
, void *data
)
547 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, jfs_fill_super
);
550 static int jfs_sync_fs(struct super_block
*sb
, int wait
)
552 struct jfs_log
*log
= JFS_SBI(sb
)->log
;
554 /* log == NULL indicates read-only mount */
556 jfs_flush_journal(log
, wait
);
563 static int jfs_show_options(struct seq_file
*seq
, struct vfsmount
*vfs
)
565 struct jfs_sb_info
*sbi
= JFS_SBI(vfs
->mnt_sb
);
567 if (sbi
->flag
& JFS_NOINTEGRITY
)
568 seq_puts(seq
, ",nointegrity");
570 seq_puts(seq
, ",integrity");
572 #if defined(CONFIG_QUOTA)
573 if (sbi
->flag
& JFS_USRQUOTA
)
574 seq_puts(seq
, ",usrquota");
576 if (sbi
->flag
& JFS_GRPQUOTA
)
577 seq_puts(seq
, ",grpquota");
583 static struct super_operations jfs_super_operations
= {
584 .alloc_inode
= jfs_alloc_inode
,
585 .destroy_inode
= jfs_destroy_inode
,
586 .read_inode
= jfs_read_inode
,
587 .dirty_inode
= jfs_dirty_inode
,
588 .write_inode
= jfs_write_inode
,
589 .delete_inode
= jfs_delete_inode
,
590 .put_super
= jfs_put_super
,
591 .sync_fs
= jfs_sync_fs
,
592 .write_super_lockfs
= jfs_write_super_lockfs
,
593 .unlockfs
= jfs_unlockfs
,
594 .statfs
= jfs_statfs
,
595 .remount_fs
= jfs_remount
,
596 .show_options
= jfs_show_options
599 static struct export_operations jfs_export_operations
= {
600 .get_parent
= jfs_get_parent
,
603 static struct file_system_type jfs_fs_type
= {
604 .owner
= THIS_MODULE
,
606 .get_sb
= jfs_get_sb
,
607 .kill_sb
= kill_block_super
,
608 .fs_flags
= FS_REQUIRES_DEV
,
611 static void init_once(void *foo
, kmem_cache_t
* cachep
, unsigned long flags
)
613 struct jfs_inode_info
*jfs_ip
= (struct jfs_inode_info
*) foo
;
615 if ((flags
& (SLAB_CTOR_VERIFY
| SLAB_CTOR_CONSTRUCTOR
)) ==
616 SLAB_CTOR_CONSTRUCTOR
) {
617 memset(jfs_ip
, 0, sizeof(struct jfs_inode_info
));
618 INIT_LIST_HEAD(&jfs_ip
->anon_inode_list
);
619 init_rwsem(&jfs_ip
->rdwrlock
);
620 init_MUTEX(&jfs_ip
->commit_sem
);
621 init_rwsem(&jfs_ip
->xattr_sem
);
622 spin_lock_init(&jfs_ip
->ag_lock
);
623 jfs_ip
->active_ag
= -1;
624 #ifdef CONFIG_JFS_POSIX_ACL
625 jfs_ip
->i_acl
= JFS_ACL_NOT_CACHED
;
626 jfs_ip
->i_default_acl
= JFS_ACL_NOT_CACHED
;
628 inode_init_once(&jfs_ip
->vfs_inode
);
632 static int __init
init_jfs_fs(void)
638 kmem_cache_create("jfs_ip", sizeof(struct jfs_inode_info
), 0,
639 SLAB_RECLAIM_ACCOUNT
, init_once
, NULL
);
640 if (jfs_inode_cachep
== NULL
)
644 * Metapage initialization
646 rc
= metapage_init();
648 jfs_err("metapage_init failed w/rc = %d", rc
);
653 * Transaction Manager initialization
657 jfs_err("txInit failed w/rc = %d", rc
);
662 * I/O completion thread (endio)
664 jfsIOthread
= kernel_thread(jfsIOWait
, NULL
, CLONE_KERNEL
);
665 if (jfsIOthread
< 0) {
666 jfs_err("init_jfs_fs: fork failed w/rc = %d", jfsIOthread
);
669 wait_for_completion(&jfsIOwait
); /* Wait until thread starts */
671 if (commit_threads
< 1)
672 commit_threads
= num_online_cpus();
673 if (commit_threads
> MAX_COMMIT_THREADS
)
674 commit_threads
= MAX_COMMIT_THREADS
;
676 for (i
= 0; i
< commit_threads
; i
++) {
677 jfsCommitThread
[i
] = kernel_thread(jfs_lazycommit
, NULL
,
679 if (jfsCommitThread
[i
] < 0) {
680 jfs_err("init_jfs_fs: fork failed w/rc = %d",
683 goto kill_committask
;
685 /* Wait until thread starts */
686 wait_for_completion(&jfsIOwait
);
689 jfsSyncThread
= kernel_thread(jfs_sync
, NULL
, CLONE_KERNEL
);
690 if (jfsSyncThread
< 0) {
691 jfs_err("init_jfs_fs: fork failed w/rc = %d", jfsSyncThread
);
692 goto kill_committask
;
694 wait_for_completion(&jfsIOwait
); /* Wait until thread starts */
700 return register_filesystem(&jfs_fs_type
);
703 jfs_stop_threads
= 1;
704 wake_up_all(&jfs_commit_thread_wait
);
705 for (i
= 0; i
< commit_threads
; i
++)
706 wait_for_completion(&jfsIOwait
);
708 wake_up(&jfs_IO_thread_wait
);
709 wait_for_completion(&jfsIOwait
); /* Wait for thread exit */
715 kmem_cache_destroy(jfs_inode_cachep
);
719 static void __exit
exit_jfs_fs(void)
723 jfs_info("exit_jfs_fs called");
725 jfs_stop_threads
= 1;
728 wake_up(&jfs_IO_thread_wait
);
729 wait_for_completion(&jfsIOwait
); /* Wait until IO thread exits */
730 wake_up_all(&jfs_commit_thread_wait
);
731 for (i
= 0; i
< commit_threads
; i
++)
732 wait_for_completion(&jfsIOwait
);
733 wake_up(&jfs_sync_thread_wait
);
734 wait_for_completion(&jfsIOwait
); /* Wait until Sync thread exits */
738 unregister_filesystem(&jfs_fs_type
);
739 kmem_cache_destroy(jfs_inode_cachep
);
742 module_init(init_jfs_fs
)
743 module_exit(exit_jfs_fs
)