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/moduleparam.h>
27 #include <asm/uaccess.h>
29 #include "jfs_incore.h"
30 #include "jfs_filsys.h"
31 #include "jfs_metapage.h"
32 #include "jfs_superblock.h"
36 #include "jfs_debug.h"
38 MODULE_DESCRIPTION("The Journaled Filesystem (JFS)");
39 MODULE_AUTHOR("Steve Best/Dave Kleikamp/Barry Arndt, IBM");
40 MODULE_LICENSE("GPL");
42 static kmem_cache_t
* jfs_inode_cachep
;
44 static struct super_operations jfs_super_operations
;
45 static struct export_operations jfs_export_operations
;
46 static struct file_system_type jfs_fs_type
;
48 #define MAX_COMMIT_THREADS 64
49 static int commit_threads
= 0;
50 module_param(commit_threads
, int, 0);
51 MODULE_PARM_DESC(commit_threads
, "Number of commit threads");
54 static pid_t jfsIOthread
;
55 static pid_t jfsCommitThread
[MAX_COMMIT_THREADS
];
56 static pid_t jfsSyncThread
;
57 DECLARE_COMPLETION(jfsIOwait
);
59 #ifdef CONFIG_JFS_DEBUG
60 int jfsloglevel
= JFS_LOGLEVEL_WARN
;
61 module_param(jfsloglevel
, int, 0644);
62 MODULE_PARM_DESC(jfsloglevel
, "Specify JFS loglevel (0, 1 or 2)");
66 * External declarations
68 extern int jfs_mount(struct super_block
*);
69 extern int jfs_mount_rw(struct super_block
*, int);
70 extern int jfs_umount(struct super_block
*);
71 extern int jfs_umount_rw(struct super_block
*);
73 extern int jfsIOWait(void *);
74 extern int jfs_lazycommit(void *);
75 extern int jfs_sync(void *);
77 extern void jfs_read_inode(struct inode
*inode
);
78 extern void jfs_dirty_inode(struct inode
*inode
);
79 extern void jfs_delete_inode(struct inode
*inode
);
80 extern int jfs_write_inode(struct inode
*inode
, int wait
);
82 extern struct dentry
*jfs_get_parent(struct dentry
*dentry
);
83 extern int jfs_extendfs(struct super_block
*, s64
, int);
85 extern struct dentry_operations jfs_ci_dentry_operations
;
87 #ifdef PROC_FS_JFS /* see jfs_debug.h */
88 extern void jfs_proc_init(void);
89 extern void jfs_proc_clean(void);
92 extern wait_queue_head_t jfs_IO_thread_wait
;
93 extern wait_queue_head_t jfs_commit_thread_wait
;
94 extern wait_queue_head_t jfs_sync_thread_wait
;
96 static void jfs_handle_error(struct super_block
*sb
)
98 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
100 if (sb
->s_flags
& MS_RDONLY
)
103 updateSuper(sb
, FM_DIRTY
);
105 if (sbi
->flag
& JFS_ERR_PANIC
)
106 panic("JFS (device %s): panic forced after error\n",
108 else if (sbi
->flag
& JFS_ERR_REMOUNT_RO
) {
109 jfs_err("ERROR: (device %s): remounting filesystem "
112 sb
->s_flags
|= MS_RDONLY
;
115 /* nothing is done for continue beyond marking the superblock dirty */
118 void jfs_error(struct super_block
*sb
, const char * function
, ...)
120 static char error_buf
[256];
123 va_start(args
, function
);
124 vsprintf(error_buf
, function
, args
);
127 printk(KERN_ERR
"ERROR: (device %s): %s\n", sb
->s_id
, error_buf
);
129 jfs_handle_error(sb
);
132 static struct inode
*jfs_alloc_inode(struct super_block
*sb
)
134 struct jfs_inode_info
*jfs_inode
;
136 jfs_inode
= kmem_cache_alloc(jfs_inode_cachep
, GFP_NOFS
);
139 return &jfs_inode
->vfs_inode
;
142 static void jfs_destroy_inode(struct inode
*inode
)
144 struct jfs_inode_info
*ji
= JFS_IP(inode
);
146 spin_lock_irq(&ji
->ag_lock
);
147 if (ji
->active_ag
!= -1) {
148 struct bmap
*bmap
= JFS_SBI(inode
->i_sb
)->bmap
;
149 atomic_dec(&bmap
->db_active
[ji
->active_ag
]);
152 spin_unlock_irq(&ji
->ag_lock
);
154 #ifdef CONFIG_JFS_POSIX_ACL
155 if (ji
->i_acl
!= JFS_ACL_NOT_CACHED
) {
156 posix_acl_release(ji
->i_acl
);
157 ji
->i_acl
= JFS_ACL_NOT_CACHED
;
159 if (ji
->i_default_acl
!= JFS_ACL_NOT_CACHED
) {
160 posix_acl_release(ji
->i_default_acl
);
161 ji
->i_default_acl
= JFS_ACL_NOT_CACHED
;
165 kmem_cache_free(jfs_inode_cachep
, ji
);
168 static int jfs_statfs(struct super_block
*sb
, struct kstatfs
*buf
)
170 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
172 struct inomap
*imap
= JFS_IP(sbi
->ipimap
)->i_imap
;
174 jfs_info("In jfs_statfs");
175 buf
->f_type
= JFS_SUPER_MAGIC
;
176 buf
->f_bsize
= sbi
->bsize
;
177 buf
->f_blocks
= sbi
->bmap
->db_mapsize
;
178 buf
->f_bfree
= sbi
->bmap
->db_nfree
;
179 buf
->f_bavail
= sbi
->bmap
->db_nfree
;
181 * If we really return the number of allocated & free inodes, some
182 * applications will fail because they won't see enough free inodes.
183 * We'll try to calculate some guess as to how may inodes we can
186 * buf->f_files = atomic_read(&imap->im_numinos);
187 * buf->f_ffree = atomic_read(&imap->im_numfree);
189 maxinodes
= min((s64
) atomic_read(&imap
->im_numinos
) +
190 ((sbi
->bmap
->db_nfree
>> imap
->im_l2nbperiext
)
191 << L2INOSPEREXT
), (s64
) 0xffffffffLL
);
192 buf
->f_files
= maxinodes
;
193 buf
->f_ffree
= maxinodes
- (atomic_read(&imap
->im_numinos
) -
194 atomic_read(&imap
->im_numfree
));
196 buf
->f_namelen
= JFS_NAME_MAX
;
200 static void jfs_put_super(struct super_block
*sb
)
202 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
205 jfs_info("In jfs_put_super");
208 jfs_err("jfs_umount failed with return code %d", rc
);
210 unload_nls(sbi
->nls_tab
);
217 Opt_integrity
, Opt_nointegrity
, Opt_iocharset
, Opt_resize
,
218 Opt_resize_nosize
, Opt_errors
, Opt_ignore
, Opt_err
,
221 static match_table_t tokens
= {
222 {Opt_integrity
, "integrity"},
223 {Opt_nointegrity
, "nointegrity"},
224 {Opt_iocharset
, "iocharset=%s"},
225 {Opt_resize
, "resize=%u"},
226 {Opt_resize_nosize
, "resize"},
227 {Opt_errors
, "errors=%s"},
228 {Opt_ignore
, "noquota"},
229 {Opt_ignore
, "quota"},
230 {Opt_ignore
, "usrquota"},
231 {Opt_ignore
, "grpquota"},
235 static int parse_options(char *options
, struct super_block
*sb
, s64
*newLVSize
,
238 void *nls_map
= (void *)-1; /* -1: no change; NULL: none */
240 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
247 while ((p
= strsep(&options
, ",")) != NULL
) {
248 substring_t args
[MAX_OPT_ARGS
];
253 token
= match_token(p
, tokens
, args
);
256 *flag
&= ~JFS_NOINTEGRITY
;
258 case Opt_nointegrity
:
259 *flag
|= JFS_NOINTEGRITY
;
262 /* Silently ignore the quota options */
263 /* Don't do anything ;-) */
266 if (nls_map
&& nls_map
!= (void *) -1)
268 if (!strcmp(args
[0].from
, "none"))
271 nls_map
= load_nls(args
[0].from
);
274 "JFS: charset not found\n");
281 char *resize
= args
[0].from
;
282 *newLVSize
= simple_strtoull(resize
, &resize
, 0);
285 case Opt_resize_nosize
:
287 *newLVSize
= sb
->s_bdev
->bd_inode
->i_size
>>
288 sb
->s_blocksize_bits
;
291 "JFS: Cannot determine volume size\n");
296 char *errors
= args
[0].from
;
297 if (!errors
|| !*errors
)
299 if (!strcmp(errors
, "continue")) {
300 *flag
&= ~JFS_ERR_REMOUNT_RO
;
301 *flag
&= ~JFS_ERR_PANIC
;
302 *flag
|= JFS_ERR_CONTINUE
;
303 } else if (!strcmp(errors
, "remount-ro")) {
304 *flag
&= ~JFS_ERR_CONTINUE
;
305 *flag
&= ~JFS_ERR_PANIC
;
306 *flag
|= JFS_ERR_REMOUNT_RO
;
307 } else if (!strcmp(errors
, "panic")) {
308 *flag
&= ~JFS_ERR_CONTINUE
;
309 *flag
&= ~JFS_ERR_REMOUNT_RO
;
310 *flag
|= JFS_ERR_PANIC
;
313 "JFS: %s is an invalid error handler\n",
320 printk("jfs: Unrecognized mount option \"%s\" "
321 " or missing value\n", p
);
326 if (nls_map
!= (void *) -1) {
327 /* Discard old (if remount) */
329 unload_nls(sbi
->nls_tab
);
330 sbi
->nls_tab
= nls_map
;
335 if (nls_map
&& nls_map
!= (void *) -1)
340 static int jfs_remount(struct super_block
*sb
, int *flags
, char *data
)
344 int flag
= JFS_SBI(sb
)->flag
;
346 if (!parse_options(data
, sb
, &newLVSize
, &flag
)) {
350 if (sb
->s_flags
& MS_RDONLY
) {
352 "JFS: resize requires volume to be mounted read-write\n");
355 rc
= jfs_extendfs(sb
, newLVSize
, 0);
360 if ((sb
->s_flags
& MS_RDONLY
) && !(*flags
& MS_RDONLY
)) {
361 JFS_SBI(sb
)->flag
= flag
;
362 return jfs_mount_rw(sb
, 1);
364 if ((!(sb
->s_flags
& MS_RDONLY
)) && (*flags
& MS_RDONLY
)) {
365 rc
= jfs_umount_rw(sb
);
366 JFS_SBI(sb
)->flag
= flag
;
369 if ((JFS_SBI(sb
)->flag
& JFS_NOINTEGRITY
) != (flag
& JFS_NOINTEGRITY
))
370 if (!(sb
->s_flags
& MS_RDONLY
)) {
371 rc
= jfs_umount_rw(sb
);
374 JFS_SBI(sb
)->flag
= flag
;
375 return jfs_mount_rw(sb
, 1);
377 JFS_SBI(sb
)->flag
= flag
;
382 static int jfs_fill_super(struct super_block
*sb
, void *data
, int silent
)
384 struct jfs_sb_info
*sbi
;
390 jfs_info("In jfs_read_super: s_flags=0x%lx", sb
->s_flags
);
392 if (!new_valid_dev(sb
->s_bdev
->bd_dev
))
395 sbi
= kmalloc(sizeof (struct jfs_sb_info
), GFP_KERNEL
);
398 memset(sbi
, 0, sizeof (struct jfs_sb_info
));
402 /* initialize the mount flag and determine the default error handler */
403 flag
= JFS_ERR_REMOUNT_RO
;
405 if (!parse_options((char *) data
, sb
, &newLVSize
, &flag
)) {
411 #ifdef CONFIG_JFS_POSIX_ACL
412 sb
->s_flags
|= MS_POSIXACL
;
416 printk(KERN_ERR
"resize option for remount only\n");
421 * Initialize blocksize to 4K.
423 sb_set_blocksize(sb
, PSIZE
);
426 * Set method vectors.
428 sb
->s_op
= &jfs_super_operations
;
429 sb
->s_export_op
= &jfs_export_operations
;
434 jfs_err("jfs_mount failed w/return code = %d", rc
);
438 if (sb
->s_flags
& MS_RDONLY
)
441 rc
= jfs_mount_rw(sb
, 0);
444 jfs_err("jfs_mount_rw failed, return code = %d",
451 sb
->s_magic
= JFS_SUPER_MAGIC
;
453 inode
= iget(sb
, ROOT_I
);
454 if (!inode
|| is_bad_inode(inode
))
456 sb
->s_root
= d_alloc_root(inode
);
460 if (sbi
->mntflag
& JFS_OS2
)
461 sb
->s_root
->d_op
= &jfs_ci_dentry_operations
;
463 /* logical blocks are represented by 40 bits in pxd_t, etc. */
464 sb
->s_maxbytes
= ((u64
) sb
->s_blocksize
) << 40;
465 #if BITS_PER_LONG == 32
467 * Page cache is indexed by long.
468 * I would use MAX_LFS_FILESIZE, but it's only half as big
470 sb
->s_maxbytes
= min(((u64
) PAGE_CACHE_SIZE
<< 32) - 1, sb
->s_maxbytes
);
476 jfs_err("jfs_read_super: get root inode failed");
483 jfs_err("jfs_umount failed with return code %d", rc
);
487 unload_nls(sbi
->nls_tab
);
492 static void jfs_write_super_lockfs(struct super_block
*sb
)
494 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
495 struct jfs_log
*log
= sbi
->log
;
497 if (!(sb
->s_flags
& MS_RDONLY
)) {
500 updateSuper(sb
, FM_CLEAN
);
504 static void jfs_unlockfs(struct super_block
*sb
)
506 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
507 struct jfs_log
*log
= sbi
->log
;
510 if (!(sb
->s_flags
& MS_RDONLY
)) {
511 updateSuper(sb
, FM_MOUNT
);
512 if ((rc
= lmLogInit(log
)))
513 jfs_err("jfs_unlock failed with return code %d", rc
);
519 static struct super_block
*jfs_get_sb(struct file_system_type
*fs_type
,
520 int flags
, const char *dev_name
, void *data
)
522 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, jfs_fill_super
);
525 static int jfs_sync_fs(struct super_block
*sb
, int wait
)
527 struct jfs_log
*log
= JFS_SBI(sb
)->log
;
529 /* log == NULL indicates read-only mount */
531 jfs_flush_journal(log
, wait
);
536 static struct super_operations jfs_super_operations
= {
537 .alloc_inode
= jfs_alloc_inode
,
538 .destroy_inode
= jfs_destroy_inode
,
539 .read_inode
= jfs_read_inode
,
540 .dirty_inode
= jfs_dirty_inode
,
541 .write_inode
= jfs_write_inode
,
542 .delete_inode
= jfs_delete_inode
,
543 .put_super
= jfs_put_super
,
544 .sync_fs
= jfs_sync_fs
,
545 .write_super_lockfs
= jfs_write_super_lockfs
,
546 .unlockfs
= jfs_unlockfs
,
547 .statfs
= jfs_statfs
,
548 .remount_fs
= jfs_remount
,
551 static struct export_operations jfs_export_operations
= {
552 .get_parent
= jfs_get_parent
,
555 static struct file_system_type jfs_fs_type
= {
556 .owner
= THIS_MODULE
,
558 .get_sb
= jfs_get_sb
,
559 .kill_sb
= kill_block_super
,
560 .fs_flags
= FS_REQUIRES_DEV
,
563 extern int metapage_init(void);
564 extern int txInit(void);
565 extern void txExit(void);
566 extern void metapage_exit(void);
568 static void init_once(void *foo
, kmem_cache_t
* cachep
, unsigned long flags
)
570 struct jfs_inode_info
*jfs_ip
= (struct jfs_inode_info
*) foo
;
572 if ((flags
& (SLAB_CTOR_VERIFY
| SLAB_CTOR_CONSTRUCTOR
)) ==
573 SLAB_CTOR_CONSTRUCTOR
) {
574 memset(jfs_ip
, 0, sizeof(struct jfs_inode_info
));
575 INIT_LIST_HEAD(&jfs_ip
->anon_inode_list
);
576 init_rwsem(&jfs_ip
->rdwrlock
);
577 init_MUTEX(&jfs_ip
->commit_sem
);
578 init_rwsem(&jfs_ip
->xattr_sem
);
579 spin_lock_init(&jfs_ip
->ag_lock
);
580 jfs_ip
->active_ag
= -1;
581 #ifdef CONFIG_JFS_POSIX_ACL
582 jfs_ip
->i_acl
= JFS_ACL_NOT_CACHED
;
583 jfs_ip
->i_default_acl
= JFS_ACL_NOT_CACHED
;
585 inode_init_once(&jfs_ip
->vfs_inode
);
589 static int __init
init_jfs_fs(void)
595 kmem_cache_create("jfs_ip", sizeof(struct jfs_inode_info
), 0,
596 SLAB_RECLAIM_ACCOUNT
, init_once
, NULL
);
597 if (jfs_inode_cachep
== NULL
)
601 * Metapage initialization
603 rc
= metapage_init();
605 jfs_err("metapage_init failed w/rc = %d", rc
);
610 * Transaction Manager initialization
614 jfs_err("txInit failed w/rc = %d", rc
);
619 * I/O completion thread (endio)
621 jfsIOthread
= kernel_thread(jfsIOWait
, NULL
, CLONE_KERNEL
);
622 if (jfsIOthread
< 0) {
623 jfs_err("init_jfs_fs: fork failed w/rc = %d", jfsIOthread
);
626 wait_for_completion(&jfsIOwait
); /* Wait until thread starts */
628 if (commit_threads
< 1)
629 commit_threads
= num_online_cpus();
630 if (commit_threads
> MAX_COMMIT_THREADS
)
631 commit_threads
= MAX_COMMIT_THREADS
;
633 for (i
= 0; i
< commit_threads
; i
++) {
634 jfsCommitThread
[i
] = kernel_thread(jfs_lazycommit
, NULL
,
636 if (jfsCommitThread
[i
] < 0) {
637 jfs_err("init_jfs_fs: fork failed w/rc = %d",
640 goto kill_committask
;
642 /* Wait until thread starts */
643 wait_for_completion(&jfsIOwait
);
646 jfsSyncThread
= kernel_thread(jfs_sync
, NULL
, CLONE_KERNEL
);
647 if (jfsSyncThread
< 0) {
648 jfs_err("init_jfs_fs: fork failed w/rc = %d", jfsSyncThread
);
649 goto kill_committask
;
651 wait_for_completion(&jfsIOwait
); /* Wait until thread starts */
657 return register_filesystem(&jfs_fs_type
);
660 jfs_stop_threads
= 1;
661 wake_up_all(&jfs_commit_thread_wait
);
662 for (i
= 0; i
< commit_threads
; i
++)
663 wait_for_completion(&jfsIOwait
);
665 wake_up(&jfs_IO_thread_wait
);
666 wait_for_completion(&jfsIOwait
); /* Wait for thread exit */
672 kmem_cache_destroy(jfs_inode_cachep
);
676 static void __exit
exit_jfs_fs(void)
680 jfs_info("exit_jfs_fs called");
682 jfs_stop_threads
= 1;
685 wake_up(&jfs_IO_thread_wait
);
686 wait_for_completion(&jfsIOwait
); /* Wait until IO thread exits */
687 wake_up_all(&jfs_commit_thread_wait
);
688 for (i
= 0; i
< commit_threads
; i
++)
689 wait_for_completion(&jfsIOwait
);
690 wake_up(&jfs_sync_thread_wait
);
691 wait_for_completion(&jfsIOwait
); /* Wait until Sync thread exits */
695 unregister_filesystem(&jfs_fs_type
);
696 kmem_cache_destroy(jfs_inode_cachep
);
699 module_init(init_jfs_fs
)
700 module_exit(exit_jfs_fs
)