1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) International Business Machines Corp., 2000-2004
4 * Portions Copyright (C) Christoph Hellwig, 2001-2002
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>
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"
33 #include "jfs_debug.h"
34 #include "jfs_xattr.h"
35 #include "jfs_dinode.h"
37 MODULE_DESCRIPTION("The Journaled Filesystem (JFS)");
38 MODULE_AUTHOR("Steve Best/Dave Kleikamp/Barry Arndt, IBM");
39 MODULE_LICENSE("GPL");
41 static struct kmem_cache
*jfs_inode_cachep
;
43 static const struct super_operations jfs_super_operations
;
44 static const struct export_operations jfs_export_operations
;
45 static struct file_system_type jfs_fs_type
;
47 #define MAX_COMMIT_THREADS 64
48 static int commit_threads
;
49 module_param(commit_threads
, int, 0);
50 MODULE_PARM_DESC(commit_threads
, "Number of commit threads");
52 static struct task_struct
*jfsCommitThread
[MAX_COMMIT_THREADS
];
53 struct task_struct
*jfsIOthread
;
54 struct task_struct
*jfsSyncThread
;
56 #ifdef CONFIG_JFS_DEBUG
57 int jfsloglevel
= JFS_LOGLEVEL_WARN
;
58 module_param(jfsloglevel
, int, 0644);
59 MODULE_PARM_DESC(jfsloglevel
, "Specify JFS loglevel (0, 1 or 2)");
62 static void jfs_handle_error(struct super_block
*sb
)
64 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
69 updateSuper(sb
, FM_DIRTY
);
71 if (sbi
->flag
& JFS_ERR_PANIC
)
72 panic("JFS (device %s): panic forced after error\n",
74 else if (sbi
->flag
& JFS_ERR_REMOUNT_RO
) {
75 jfs_err("ERROR: (device %s): remounting filesystem as read-only",
77 sb
->s_flags
|= SB_RDONLY
;
80 /* nothing is done for continue beyond marking the superblock dirty */
83 void jfs_error(struct super_block
*sb
, const char *fmt
, ...)
93 pr_err("ERROR: (device %s): %ps: %pV\n",
94 sb
->s_id
, __builtin_return_address(0), &vaf
);
101 static struct inode
*jfs_alloc_inode(struct super_block
*sb
)
103 struct jfs_inode_info
*jfs_inode
;
105 jfs_inode
= kmem_cache_alloc(jfs_inode_cachep
, GFP_NOFS
);
109 memset(&jfs_inode
->i_dquot
, 0, sizeof(jfs_inode
->i_dquot
));
111 return &jfs_inode
->vfs_inode
;
114 static void jfs_free_inode(struct inode
*inode
)
116 kmem_cache_free(jfs_inode_cachep
, JFS_IP(inode
));
119 static int jfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
121 struct jfs_sb_info
*sbi
= JFS_SBI(dentry
->d_sb
);
123 struct inomap
*imap
= JFS_IP(sbi
->ipimap
)->i_imap
;
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
;
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
137 * buf->f_files = atomic_read(&imap->im_numinos);
138 * buf->f_ffree = atomic_read(&imap->im_numfree);
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);
152 buf
->f_namelen
= JFS_NAME_MAX
;
157 static int jfs_quota_off(struct super_block
*sb
, int type
);
158 static int jfs_quota_on(struct super_block
*sb
, int type
, int format_id
,
159 const struct path
*path
);
161 static void jfs_quota_off_umount(struct super_block
*sb
)
165 for (type
= 0; type
< MAXQUOTAS
; type
++)
166 jfs_quota_off(sb
, type
);
169 static 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
,
180 static inline void jfs_quota_off_umount(struct super_block
*sb
)
185 static void jfs_put_super(struct super_block
*sb
)
187 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
190 jfs_info("In jfs_put_super");
192 jfs_quota_off_umount(sb
);
196 jfs_err("jfs_umount failed with return code %d", rc
);
198 unload_nls(sbi
->nls_tab
);
200 truncate_inode_pages(sbi
->direct_inode
->i_mapping
, 0);
201 iput(sbi
->direct_inode
);
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
213 static 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"},
226 {Opt_umask
, "umask=%u"},
227 {Opt_discard
, "discard"},
228 {Opt_nodiscard
, "nodiscard"},
229 {Opt_discard_minblk
, "discard=%u"},
233 static int parse_options(char *options
, struct super_block
*sb
, s64
*newLVSize
,
236 void *nls_map
= (void *)-1; /* -1: no change; NULL: none */
238 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
245 while ((p
= strsep(&options
, ",")) != NULL
) {
246 substring_t args
[MAX_OPT_ARGS
];
251 token
= match_token(p
, tokens
, args
);
254 *flag
&= ~JFS_NOINTEGRITY
;
256 case Opt_nointegrity
:
257 *flag
|= JFS_NOINTEGRITY
;
260 /* Silently ignore the quota options */
261 /* Don't do anything ;-) */
264 if (nls_map
&& nls_map
!= (void *) -1)
266 if (!strcmp(args
[0].from
, "none"))
269 nls_map
= load_nls(args
[0].from
);
271 pr_err("JFS: charset not found\n");
278 char *resize
= args
[0].from
;
279 int rc
= kstrtoll(resize
, 0, newLVSize
);
285 case Opt_resize_nosize
:
287 *newLVSize
= i_size_read(sb
->s_bdev
->bd_inode
) >>
288 sb
->s_blocksize_bits
;
290 pr_err("JFS: Cannot determine volume size\n");
295 char *errors
= args
[0].from
;
296 if (!errors
|| !*errors
)
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
;
311 pr_err("JFS: %s is an invalid error handler\n",
321 *flag
|= JFS_USRQUOTA
;
324 *flag
|= JFS_GRPQUOTA
;
330 pr_err("JFS: quota operations not supported\n");
335 char *uid
= args
[0].from
;
337 int rc
= kstrtouint(uid
, 0, &val
);
341 sbi
->uid
= make_kuid(current_user_ns(), val
);
342 if (!uid_valid(sbi
->uid
))
349 char *gid
= args
[0].from
;
351 int rc
= kstrtouint(gid
, 0, &val
);
355 sbi
->gid
= make_kgid(current_user_ns(), val
);
356 if (!gid_valid(sbi
->gid
))
363 char *umask
= args
[0].from
;
364 int rc
= kstrtouint(umask
, 8, &sbi
->umask
);
368 if (sbi
->umask
& ~0777) {
369 pr_err("JFS: Invalid value of umask\n");
377 struct request_queue
*q
= bdev_get_queue(sb
->s_bdev
);
378 /* if set to 1, even copying files will cause
380 * -> user has more control over the online trimming
382 sbi
->minblks_trim
= 64;
383 if (blk_queue_discard(q
))
384 *flag
|= JFS_DISCARD
;
386 pr_err("JFS: discard option not supported on device\n");
391 *flag
&= ~JFS_DISCARD
;
394 case Opt_discard_minblk
:
396 struct request_queue
*q
= bdev_get_queue(sb
->s_bdev
);
397 char *minblks_trim
= args
[0].from
;
399 if (blk_queue_discard(q
)) {
400 *flag
|= JFS_DISCARD
;
401 rc
= kstrtouint(minblks_trim
, 0,
406 pr_err("JFS: discard option not supported on device\n");
411 printk("jfs: Unrecognized mount option \"%s\" or missing value\n",
417 if (nls_map
!= (void *) -1) {
418 /* Discard old (if remount) */
419 unload_nls(sbi
->nls_tab
);
420 sbi
->nls_tab
= nls_map
;
425 if (nls_map
&& nls_map
!= (void *) -1)
430 static int jfs_remount(struct super_block
*sb
, int *flags
, char *data
)
434 int flag
= JFS_SBI(sb
)->flag
;
438 if (!parse_options(data
, sb
, &newLVSize
, &flag
))
443 pr_err("JFS: resize requires volume to be mounted read-write\n");
446 rc
= jfs_extendfs(sb
, newLVSize
, 0);
451 if (sb_rdonly(sb
) && !(*flags
& SB_RDONLY
)) {
453 * Invalidate any previously read metadata. fsck may have
454 * changed the on-disk data since we mounted r/o
456 truncate_inode_pages(JFS_SBI(sb
)->direct_inode
->i_mapping
, 0);
458 JFS_SBI(sb
)->flag
= flag
;
459 ret
= jfs_mount_rw(sb
, 1);
461 /* mark the fs r/w for quota activity */
462 sb
->s_flags
&= ~SB_RDONLY
;
464 dquot_resume(sb
, -1);
467 if (!sb_rdonly(sb
) && (*flags
& SB_RDONLY
)) {
468 rc
= dquot_suspend(sb
, -1);
471 rc
= jfs_umount_rw(sb
);
472 JFS_SBI(sb
)->flag
= flag
;
475 if ((JFS_SBI(sb
)->flag
& JFS_NOINTEGRITY
) != (flag
& JFS_NOINTEGRITY
))
476 if (!sb_rdonly(sb
)) {
477 rc
= jfs_umount_rw(sb
);
481 JFS_SBI(sb
)->flag
= flag
;
482 ret
= jfs_mount_rw(sb
, 1);
485 JFS_SBI(sb
)->flag
= flag
;
490 static int jfs_fill_super(struct super_block
*sb
, void *data
, int silent
)
492 struct jfs_sb_info
*sbi
;
496 int flag
, ret
= -EINVAL
;
498 jfs_info("In jfs_read_super: s_flags=0x%lx", sb
->s_flags
);
500 sbi
= kzalloc(sizeof(struct jfs_sb_info
), GFP_KERNEL
);
505 sb
->s_max_links
= JFS_LINK_MAX
;
507 sbi
->uid
= INVALID_UID
;
508 sbi
->gid
= INVALID_GID
;
511 /* initialize the mount flag and determine the default error handler */
512 flag
= JFS_ERR_REMOUNT_RO
;
514 if (!parse_options((char *) data
, sb
, &newLVSize
, &flag
))
518 #ifdef CONFIG_JFS_POSIX_ACL
519 sb
->s_flags
|= SB_POSIXACL
;
523 pr_err("resize option for remount only\n");
528 * Initialize blocksize to 4K.
530 sb_set_blocksize(sb
, PSIZE
);
533 * Set method vectors.
535 sb
->s_op
= &jfs_super_operations
;
536 sb
->s_export_op
= &jfs_export_operations
;
537 sb
->s_xattr
= jfs_xattr_handlers
;
539 sb
->dq_op
= &dquot_operations
;
540 sb
->s_qcop
= &jfs_quotactl_ops
;
541 sb
->s_quota_types
= QTYPE_MASK_USR
| QTYPE_MASK_GRP
;
545 * Initialize direct-mapping inode/address-space
547 inode
= new_inode(sb
);
553 inode
->i_size
= i_size_read(sb
->s_bdev
->bd_inode
);
554 inode
->i_mapping
->a_ops
= &jfs_metapage_aops
;
555 inode_fake_hash(inode
);
556 mapping_set_gfp_mask(inode
->i_mapping
, GFP_NOFS
);
558 sbi
->direct_inode
= inode
;
563 jfs_err("jfs_mount failed w/return code = %d", rc
);
564 goto out_mount_failed
;
569 rc
= jfs_mount_rw(sb
, 0);
572 jfs_err("jfs_mount_rw failed, return code = %d",
579 sb
->s_magic
= JFS_SUPER_MAGIC
;
581 if (sbi
->mntflag
& JFS_OS2
)
582 sb
->s_d_op
= &jfs_ci_dentry_operations
;
584 inode
= jfs_iget(sb
, ROOT_I
);
586 ret
= PTR_ERR(inode
);
589 sb
->s_root
= d_make_root(inode
);
593 /* logical blocks are represented by 40 bits in pxd_t, etc.
594 * and page cache is indexed by long
596 sb
->s_maxbytes
= min(((loff_t
)sb
->s_blocksize
) << 40, MAX_LFS_FILESIZE
);
601 jfs_err("jfs_read_super: get root dentry failed");
606 jfs_err("jfs_umount failed with return code %d", rc
);
608 filemap_write_and_wait(sbi
->direct_inode
->i_mapping
);
609 truncate_inode_pages(sbi
->direct_inode
->i_mapping
, 0);
610 make_bad_inode(sbi
->direct_inode
);
611 iput(sbi
->direct_inode
);
612 sbi
->direct_inode
= NULL
;
614 unload_nls(sbi
->nls_tab
);
620 static int jfs_freeze(struct super_block
*sb
)
622 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
623 struct jfs_log
*log
= sbi
->log
;
626 if (!sb_rdonly(sb
)) {
628 rc
= lmLogShutdown(log
);
630 jfs_error(sb
, "lmLogShutdown failed\n");
632 /* let operations fail rather than hang */
637 rc
= updateSuper(sb
, FM_CLEAN
);
639 jfs_err("jfs_freeze: updateSuper failed");
641 * Don't fail here. Everything succeeded except
642 * marking the superblock clean, so there's really
643 * no harm in leaving it frozen for now.
650 static int jfs_unfreeze(struct super_block
*sb
)
652 struct jfs_sb_info
*sbi
= JFS_SBI(sb
);
653 struct jfs_log
*log
= sbi
->log
;
656 if (!sb_rdonly(sb
)) {
657 rc
= updateSuper(sb
, FM_MOUNT
);
659 jfs_error(sb
, "updateSuper failed\n");
664 jfs_error(sb
, "lmLogInit failed\n");
671 static struct dentry
*jfs_do_mount(struct file_system_type
*fs_type
,
672 int flags
, const char *dev_name
, void *data
)
674 return mount_bdev(fs_type
, flags
, dev_name
, data
, jfs_fill_super
);
677 static int jfs_sync_fs(struct super_block
*sb
, int wait
)
679 struct jfs_log
*log
= JFS_SBI(sb
)->log
;
681 /* log == NULL indicates read-only mount */
684 * Write quota structures to quota file, sync_blockdev() will
685 * write them to disk later
687 dquot_writeback_dquots(sb
, -1);
688 jfs_flush_journal(log
, wait
);
695 static int jfs_show_options(struct seq_file
*seq
, struct dentry
*root
)
697 struct jfs_sb_info
*sbi
= JFS_SBI(root
->d_sb
);
699 if (uid_valid(sbi
->uid
))
700 seq_printf(seq
, ",uid=%d", from_kuid(&init_user_ns
, sbi
->uid
));
701 if (gid_valid(sbi
->gid
))
702 seq_printf(seq
, ",gid=%d", from_kgid(&init_user_ns
, sbi
->gid
));
703 if (sbi
->umask
!= -1)
704 seq_printf(seq
, ",umask=%03o", sbi
->umask
);
705 if (sbi
->flag
& JFS_NOINTEGRITY
)
706 seq_puts(seq
, ",nointegrity");
707 if (sbi
->flag
& JFS_DISCARD
)
708 seq_printf(seq
, ",discard=%u", sbi
->minblks_trim
);
710 seq_printf(seq
, ",iocharset=%s", sbi
->nls_tab
->charset
);
711 if (sbi
->flag
& JFS_ERR_CONTINUE
)
712 seq_printf(seq
, ",errors=continue");
713 if (sbi
->flag
& JFS_ERR_PANIC
)
714 seq_printf(seq
, ",errors=panic");
717 if (sbi
->flag
& JFS_USRQUOTA
)
718 seq_puts(seq
, ",usrquota");
720 if (sbi
->flag
& JFS_GRPQUOTA
)
721 seq_puts(seq
, ",grpquota");
729 /* Read data from quotafile - avoid pagecache and such because we cannot afford
730 * acquiring the locks... As quota files are never truncated and quota code
731 * itself serializes the operations (and no one else should touch the files)
732 * we don't have to be afraid of races */
733 static ssize_t
jfs_quota_read(struct super_block
*sb
, int type
, char *data
,
734 size_t len
, loff_t off
)
736 struct inode
*inode
= sb_dqopt(sb
)->files
[type
];
737 sector_t blk
= off
>> sb
->s_blocksize_bits
;
739 int offset
= off
& (sb
->s_blocksize
- 1);
742 struct buffer_head tmp_bh
;
743 struct buffer_head
*bh
;
744 loff_t i_size
= i_size_read(inode
);
748 if (off
+len
> i_size
)
752 tocopy
= sb
->s_blocksize
- offset
< toread
?
753 sb
->s_blocksize
- offset
: toread
;
756 tmp_bh
.b_size
= i_blocksize(inode
);
757 err
= jfs_get_block(inode
, blk
, &tmp_bh
, 0);
760 if (!buffer_mapped(&tmp_bh
)) /* A hole? */
761 memset(data
, 0, tocopy
);
763 bh
= sb_bread(sb
, tmp_bh
.b_blocknr
);
766 memcpy(data
, bh
->b_data
+offset
, tocopy
);
777 /* Write to quotafile */
778 static ssize_t
jfs_quota_write(struct super_block
*sb
, int type
,
779 const char *data
, size_t len
, loff_t off
)
781 struct inode
*inode
= sb_dqopt(sb
)->files
[type
];
782 sector_t blk
= off
>> sb
->s_blocksize_bits
;
784 int offset
= off
& (sb
->s_blocksize
- 1);
786 size_t towrite
= len
;
787 struct buffer_head tmp_bh
;
788 struct buffer_head
*bh
;
791 while (towrite
> 0) {
792 tocopy
= sb
->s_blocksize
- offset
< towrite
?
793 sb
->s_blocksize
- offset
: towrite
;
796 tmp_bh
.b_size
= i_blocksize(inode
);
797 err
= jfs_get_block(inode
, blk
, &tmp_bh
, 1);
800 if (offset
|| tocopy
!= sb
->s_blocksize
)
801 bh
= sb_bread(sb
, tmp_bh
.b_blocknr
);
803 bh
= sb_getblk(sb
, tmp_bh
.b_blocknr
);
809 memcpy(bh
->b_data
+offset
, data
, tocopy
);
810 flush_dcache_page(bh
->b_page
);
811 set_buffer_uptodate(bh
);
812 mark_buffer_dirty(bh
);
821 if (len
== towrite
) {
825 if (inode
->i_size
< off
+len
-towrite
)
826 i_size_write(inode
, off
+len
-towrite
);
827 inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
828 mark_inode_dirty(inode
);
830 return len
- towrite
;
833 static struct dquot
**jfs_get_dquots(struct inode
*inode
)
835 return JFS_IP(inode
)->i_dquot
;
838 static int jfs_quota_on(struct super_block
*sb
, int type
, int format_id
,
839 const struct path
*path
)
844 err
= dquot_quota_on(sb
, type
, format_id
, path
);
848 inode
= d_inode(path
->dentry
);
850 JFS_IP(inode
)->mode2
|= JFS_NOATIME_FL
| JFS_IMMUTABLE_FL
;
851 inode_set_flags(inode
, S_NOATIME
| S_IMMUTABLE
,
852 S_NOATIME
| S_IMMUTABLE
);
854 mark_inode_dirty(inode
);
859 static int jfs_quota_off(struct super_block
*sb
, int type
)
861 struct inode
*inode
= sb_dqopt(sb
)->files
[type
];
864 if (!inode
|| !igrab(inode
))
867 err
= dquot_quota_off(sb
, type
);
872 JFS_IP(inode
)->mode2
&= ~(JFS_NOATIME_FL
| JFS_IMMUTABLE_FL
);
873 inode_set_flags(inode
, 0, S_NOATIME
| S_IMMUTABLE
);
875 mark_inode_dirty(inode
);
880 return dquot_quota_off(sb
, type
);
884 static const struct super_operations jfs_super_operations
= {
885 .alloc_inode
= jfs_alloc_inode
,
886 .free_inode
= jfs_free_inode
,
887 .dirty_inode
= jfs_dirty_inode
,
888 .write_inode
= jfs_write_inode
,
889 .evict_inode
= jfs_evict_inode
,
890 .put_super
= jfs_put_super
,
891 .sync_fs
= jfs_sync_fs
,
892 .freeze_fs
= jfs_freeze
,
893 .unfreeze_fs
= jfs_unfreeze
,
894 .statfs
= jfs_statfs
,
895 .remount_fs
= jfs_remount
,
896 .show_options
= jfs_show_options
,
898 .quota_read
= jfs_quota_read
,
899 .quota_write
= jfs_quota_write
,
900 .get_dquots
= jfs_get_dquots
,
904 static const struct export_operations jfs_export_operations
= {
905 .fh_to_dentry
= jfs_fh_to_dentry
,
906 .fh_to_parent
= jfs_fh_to_parent
,
907 .get_parent
= jfs_get_parent
,
910 static struct file_system_type jfs_fs_type
= {
911 .owner
= THIS_MODULE
,
913 .mount
= jfs_do_mount
,
914 .kill_sb
= kill_block_super
,
915 .fs_flags
= FS_REQUIRES_DEV
,
917 MODULE_ALIAS_FS("jfs");
919 static void init_once(void *foo
)
921 struct jfs_inode_info
*jfs_ip
= (struct jfs_inode_info
*) foo
;
923 memset(jfs_ip
, 0, sizeof(struct jfs_inode_info
));
924 INIT_LIST_HEAD(&jfs_ip
->anon_inode_list
);
925 init_rwsem(&jfs_ip
->rdwrlock
);
926 mutex_init(&jfs_ip
->commit_mutex
);
927 init_rwsem(&jfs_ip
->xattr_sem
);
928 spin_lock_init(&jfs_ip
->ag_lock
);
929 jfs_ip
->active_ag
= -1;
930 inode_init_once(&jfs_ip
->vfs_inode
);
933 static int __init
init_jfs_fs(void)
939 kmem_cache_create_usercopy("jfs_ip", sizeof(struct jfs_inode_info
),
940 0, SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
|SLAB_ACCOUNT
,
941 offsetof(struct jfs_inode_info
, i_inline
), IDATASIZE
,
943 if (jfs_inode_cachep
== NULL
)
947 * Metapage initialization
949 rc
= metapage_init();
951 jfs_err("metapage_init failed w/rc = %d", rc
);
956 * Transaction Manager initialization
960 jfs_err("txInit failed w/rc = %d", rc
);
965 * I/O completion thread (endio)
967 jfsIOthread
= kthread_run(jfsIOWait
, NULL
, "jfsIO");
968 if (IS_ERR(jfsIOthread
)) {
969 rc
= PTR_ERR(jfsIOthread
);
970 jfs_err("init_jfs_fs: fork failed w/rc = %d", rc
);
974 if (commit_threads
< 1)
975 commit_threads
= num_online_cpus();
976 if (commit_threads
> MAX_COMMIT_THREADS
)
977 commit_threads
= MAX_COMMIT_THREADS
;
979 for (i
= 0; i
< commit_threads
; i
++) {
980 jfsCommitThread
[i
] = kthread_run(jfs_lazycommit
, NULL
,
982 if (IS_ERR(jfsCommitThread
[i
])) {
983 rc
= PTR_ERR(jfsCommitThread
[i
]);
984 jfs_err("init_jfs_fs: fork failed w/rc = %d", rc
);
986 goto kill_committask
;
990 jfsSyncThread
= kthread_run(jfs_sync
, NULL
, "jfsSync");
991 if (IS_ERR(jfsSyncThread
)) {
992 rc
= PTR_ERR(jfsSyncThread
);
993 jfs_err("init_jfs_fs: fork failed w/rc = %d", rc
);
994 goto kill_committask
;
1001 rc
= register_filesystem(&jfs_fs_type
);
1008 kthread_stop(jfsSyncThread
);
1010 for (i
= 0; i
< commit_threads
; i
++)
1011 kthread_stop(jfsCommitThread
[i
]);
1012 kthread_stop(jfsIOthread
);
1018 kmem_cache_destroy(jfs_inode_cachep
);
1022 static void __exit
exit_jfs_fs(void)
1026 jfs_info("exit_jfs_fs called");
1031 kthread_stop(jfsIOthread
);
1032 for (i
= 0; i
< commit_threads
; i
++)
1033 kthread_stop(jfsCommitThread
[i
]);
1034 kthread_stop(jfsSyncThread
);
1038 unregister_filesystem(&jfs_fs_type
);
1041 * Make sure all delayed rcu free inodes are flushed before we
1045 kmem_cache_destroy(jfs_inode_cachep
);
1048 module_init(init_jfs_fs
)
1049 module_exit(exit_jfs_fs
)