xref: /openbmc/linux/fs/jfs/super.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
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/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>
31 
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"
37 #include "jfs_dmap.h"
38 #include "jfs_imap.h"
39 #include "jfs_acl.h"
40 #include "jfs_debug.h"
41 
42 MODULE_DESCRIPTION("The Journaled Filesystem (JFS)");
43 MODULE_AUTHOR("Steve Best/Dave Kleikamp/Barry Arndt, IBM");
44 MODULE_LICENSE("GPL");
45 
46 static kmem_cache_t * jfs_inode_cachep;
47 
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;
51 
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");
56 
57 int jfs_stop_threads;
58 static pid_t jfsIOthread;
59 static pid_t jfsCommitThread[MAX_COMMIT_THREADS];
60 static pid_t jfsSyncThread;
61 DECLARE_COMPLETION(jfsIOwait);
62 
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)");
67 #endif
68 
69 static void jfs_handle_error(struct super_block *sb)
70 {
71 	struct jfs_sb_info *sbi = JFS_SBI(sb);
72 
73 	if (sb->s_flags & MS_RDONLY)
74 		return;
75 
76 	updateSuper(sb, FM_DIRTY);
77 
78 	if (sbi->flag & JFS_ERR_PANIC)
79 		panic("JFS (device %s): panic forced after error\n",
80 			sb->s_id);
81 	else if (sbi->flag & JFS_ERR_REMOUNT_RO) {
82 		jfs_err("ERROR: (device %s): remounting filesystem "
83 			"as read-only\n",
84 			sb->s_id);
85 		sb->s_flags |= MS_RDONLY;
86 	}
87 
88 	/* nothing is done for continue beyond marking the superblock dirty */
89 }
90 
91 void jfs_error(struct super_block *sb, const char * function, ...)
92 {
93 	static char error_buf[256];
94 	va_list args;
95 
96 	va_start(args, function);
97 	vsprintf(error_buf, function, args);
98 	va_end(args);
99 
100 	printk(KERN_ERR "ERROR: (device %s): %s\n", sb->s_id, error_buf);
101 
102 	jfs_handle_error(sb);
103 }
104 
105 static struct inode *jfs_alloc_inode(struct super_block *sb)
106 {
107 	struct jfs_inode_info *jfs_inode;
108 
109 	jfs_inode = kmem_cache_alloc(jfs_inode_cachep, GFP_NOFS);
110 	if (!jfs_inode)
111 		return NULL;
112 	return &jfs_inode->vfs_inode;
113 }
114 
115 static void jfs_destroy_inode(struct inode *inode)
116 {
117 	struct jfs_inode_info *ji = JFS_IP(inode);
118 
119 	BUG_ON(!list_empty(&ji->anon_inode_list));
120 
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]);
125 		ji->active_ag = -1;
126 	}
127 	spin_unlock_irq(&ji->ag_lock);
128 
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;
133 	}
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;
137 	}
138 #endif
139 
140 	kmem_cache_free(jfs_inode_cachep, ji);
141 }
142 
143 static int jfs_statfs(struct super_block *sb, struct kstatfs *buf)
144 {
145 	struct jfs_sb_info *sbi = JFS_SBI(sb);
146 	s64 maxinodes;
147 	struct inomap *imap = JFS_IP(sbi->ipimap)->i_imap;
148 
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;
155 	/*
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
159 	 * really allocate
160 	 *
161 	 * buf->f_files = atomic_read(&imap->im_numinos);
162 	 * buf->f_ffree = atomic_read(&imap->im_numfree);
163 	 */
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));
170 
171 	buf->f_namelen = JFS_NAME_MAX;
172 	return 0;
173 }
174 
175 static void jfs_put_super(struct super_block *sb)
176 {
177 	struct jfs_sb_info *sbi = JFS_SBI(sb);
178 	int rc;
179 
180 	jfs_info("In jfs_put_super");
181 	rc = jfs_umount(sb);
182 	if (rc)
183 		jfs_err("jfs_umount failed with return code %d", rc);
184 	if (sbi->nls_tab)
185 		unload_nls(sbi->nls_tab);
186 	sbi->nls_tab = NULL;
187 
188 	truncate_inode_pages(sbi->direct_inode->i_mapping, 0);
189 	iput(sbi->direct_inode);
190 	sbi->direct_inode = NULL;
191 
192 	kfree(sbi);
193 }
194 
195 enum {
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
199 };
200 
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"},
212 	{Opt_err, NULL}
213 };
214 
215 static int parse_options(char *options, struct super_block *sb, s64 *newLVSize,
216 			 int *flag)
217 {
218 	void *nls_map = (void *)-1;	/* -1: no change;  NULL: none */
219 	char *p;
220 	struct jfs_sb_info *sbi = JFS_SBI(sb);
221 
222 	*newLVSize = 0;
223 
224 	if (!options)
225 		return 1;
226 
227 	while ((p = strsep(&options, ",")) != NULL) {
228 		substring_t args[MAX_OPT_ARGS];
229 		int token;
230 		if (!*p)
231 			continue;
232 
233 		token = match_token(p, tokens, args);
234 		switch (token) {
235 		case Opt_integrity:
236 			*flag &= ~JFS_NOINTEGRITY;
237 			break;
238 		case Opt_nointegrity:
239 			*flag |= JFS_NOINTEGRITY;
240 			break;
241 		case Opt_ignore:
242 			/* Silently ignore the quota options */
243 			/* Don't do anything ;-) */
244 			break;
245 		case Opt_iocharset:
246 			if (nls_map && nls_map != (void *) -1)
247 				unload_nls(nls_map);
248 			if (!strcmp(args[0].from, "none"))
249 				nls_map = NULL;
250 			else {
251 				nls_map = load_nls(args[0].from);
252 				if (!nls_map) {
253 					printk(KERN_ERR
254 					       "JFS: charset not found\n");
255 					goto cleanup;
256 				}
257 			}
258 			break;
259 		case Opt_resize:
260 		{
261 			char *resize = args[0].from;
262 			*newLVSize = simple_strtoull(resize, &resize, 0);
263 			break;
264 		}
265 		case Opt_resize_nosize:
266 		{
267 			*newLVSize = sb->s_bdev->bd_inode->i_size >>
268 				sb->s_blocksize_bits;
269 			if (*newLVSize == 0)
270 				printk(KERN_ERR
271 				       "JFS: Cannot determine volume size\n");
272 			break;
273 		}
274 		case Opt_errors:
275 		{
276 			char *errors = args[0].from;
277 			if (!errors || !*errors)
278 				goto cleanup;
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;
291 			} else {
292 				printk(KERN_ERR
293 				       "JFS: %s is an invalid error handler\n",
294 				       errors);
295 				goto cleanup;
296 			}
297 			break;
298 		}
299 
300 #if defined(CONFIG_QUOTA)
301 		case Opt_quota:
302 		case Opt_usrquota:
303 			*flag |= JFS_USRQUOTA;
304 			break;
305 		case Opt_grpquota:
306 			*flag |= JFS_GRPQUOTA;
307 			break;
308 #else
309 		case Opt_usrquota:
310 		case Opt_grpquota:
311 		case Opt_quota:
312 			printk(KERN_ERR
313 			       "JFS: quota operations not supported\n");
314 			break;
315 #endif
316 
317 		default:
318 			printk("jfs: Unrecognized mount option \"%s\" "
319 					" or missing value\n", p);
320 			goto cleanup;
321 		}
322 	}
323 
324 	if (nls_map != (void *) -1) {
325 		/* Discard old (if remount) */
326 		if (sbi->nls_tab)
327 			unload_nls(sbi->nls_tab);
328 		sbi->nls_tab = nls_map;
329 	}
330 	return 1;
331 
332 cleanup:
333 	if (nls_map && nls_map != (void *) -1)
334 		unload_nls(nls_map);
335 	return 0;
336 }
337 
338 static int jfs_remount(struct super_block *sb, int *flags, char *data)
339 {
340 	s64 newLVSize = 0;
341 	int rc = 0;
342 	int flag = JFS_SBI(sb)->flag;
343 
344 	if (!parse_options(data, sb, &newLVSize, &flag)) {
345 		return -EINVAL;
346 	}
347 	if (newLVSize) {
348 		if (sb->s_flags & MS_RDONLY) {
349 			printk(KERN_ERR
350 		  "JFS: resize requires volume to be mounted read-write\n");
351 			return -EROFS;
352 		}
353 		rc = jfs_extendfs(sb, newLVSize, 0);
354 		if (rc)
355 			return rc;
356 	}
357 
358 	if ((sb->s_flags & MS_RDONLY) && !(*flags & MS_RDONLY)) {
359 		/*
360 		 * Invalidate any previously read metadata.  fsck may have
361 		 * changed the on-disk data since we mounted r/o
362 		 */
363 		truncate_inode_pages(JFS_SBI(sb)->direct_inode->i_mapping, 0);
364 
365 		JFS_SBI(sb)->flag = flag;
366 		return jfs_mount_rw(sb, 1);
367 	}
368 	if ((!(sb->s_flags & MS_RDONLY)) && (*flags & MS_RDONLY)) {
369 		rc = jfs_umount_rw(sb);
370 		JFS_SBI(sb)->flag = flag;
371 		return rc;
372 	}
373 	if ((JFS_SBI(sb)->flag & JFS_NOINTEGRITY) != (flag & JFS_NOINTEGRITY))
374 		if (!(sb->s_flags & MS_RDONLY)) {
375 			rc = jfs_umount_rw(sb);
376 			if (rc)
377 				return rc;
378 			JFS_SBI(sb)->flag = flag;
379 			return jfs_mount_rw(sb, 1);
380 		}
381 	JFS_SBI(sb)->flag = flag;
382 
383 	return 0;
384 }
385 
386 static int jfs_fill_super(struct super_block *sb, void *data, int silent)
387 {
388 	struct jfs_sb_info *sbi;
389 	struct inode *inode;
390 	int rc;
391 	s64 newLVSize = 0;
392 	int flag;
393 
394 	jfs_info("In jfs_read_super: s_flags=0x%lx", sb->s_flags);
395 
396 	if (!new_valid_dev(sb->s_bdev->bd_dev))
397 		return -EOVERFLOW;
398 
399 	sbi = kmalloc(sizeof (struct jfs_sb_info), GFP_KERNEL);
400 	if (!sbi)
401 		return -ENOSPC;
402 	memset(sbi, 0, sizeof (struct jfs_sb_info));
403 	sb->s_fs_info = sbi;
404 	sbi->sb = sb;
405 
406 	/* initialize the mount flag and determine the default error handler */
407 	flag = JFS_ERR_REMOUNT_RO;
408 
409 	if (!parse_options((char *) data, sb, &newLVSize, &flag)) {
410 		kfree(sbi);
411 		return -EINVAL;
412 	}
413 	sbi->flag = flag;
414 
415 #ifdef CONFIG_JFS_POSIX_ACL
416 	sb->s_flags |= MS_POSIXACL;
417 #endif
418 
419 	if (newLVSize) {
420 		printk(KERN_ERR "resize option for remount only\n");
421 		return -EINVAL;
422 	}
423 
424 	/*
425 	 * Initialize blocksize to 4K.
426 	 */
427 	sb_set_blocksize(sb, PSIZE);
428 
429 	/*
430 	 * Set method vectors.
431 	 */
432 	sb->s_op = &jfs_super_operations;
433 	sb->s_export_op = &jfs_export_operations;
434 
435 	/*
436 	 * Initialize direct-mapping inode/address-space
437 	 */
438 	inode = new_inode(sb);
439 	if (inode == NULL)
440 		goto out_kfree;
441 	inode->i_ino = 0;
442 	inode->i_nlink = 1;
443 	inode->i_size = sb->s_bdev->bd_inode->i_size;
444 	inode->i_mapping->a_ops = &jfs_metapage_aops;
445 	insert_inode_hash(inode);
446 	mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
447 
448 	sbi->direct_inode = inode;
449 
450 	rc = jfs_mount(sb);
451 	if (rc) {
452 		if (!silent) {
453 			jfs_err("jfs_mount failed w/return code = %d", rc);
454 		}
455 		goto out_mount_failed;
456 	}
457 	if (sb->s_flags & MS_RDONLY)
458 		sbi->log = NULL;
459 	else {
460 		rc = jfs_mount_rw(sb, 0);
461 		if (rc) {
462 			if (!silent) {
463 				jfs_err("jfs_mount_rw failed, return code = %d",
464 					rc);
465 			}
466 			goto out_no_rw;
467 		}
468 	}
469 
470 	sb->s_magic = JFS_SUPER_MAGIC;
471 
472 	inode = iget(sb, ROOT_I);
473 	if (!inode || is_bad_inode(inode))
474 		goto out_no_root;
475 	sb->s_root = d_alloc_root(inode);
476 	if (!sb->s_root)
477 		goto out_no_root;
478 
479 	if (sbi->mntflag & JFS_OS2)
480 		sb->s_root->d_op = &jfs_ci_dentry_operations;
481 
482 	/* logical blocks are represented by 40 bits in pxd_t, etc. */
483 	sb->s_maxbytes = ((u64) sb->s_blocksize) << 40;
484 #if BITS_PER_LONG == 32
485 	/*
486 	 * Page cache is indexed by long.
487 	 * I would use MAX_LFS_FILESIZE, but it's only half as big
488 	 */
489 	sb->s_maxbytes = min(((u64) PAGE_CACHE_SIZE << 32) - 1, sb->s_maxbytes);
490 #endif
491 	sb->s_time_gran = 1;
492 	return 0;
493 
494 out_no_root:
495 	jfs_err("jfs_read_super: get root inode failed");
496 	if (inode)
497 		iput(inode);
498 
499 out_no_rw:
500 	rc = jfs_umount(sb);
501 	if (rc) {
502 		jfs_err("jfs_umount failed with return code %d", rc);
503 	}
504 out_mount_failed:
505 	filemap_fdatawrite(sbi->direct_inode->i_mapping);
506 	filemap_fdatawait(sbi->direct_inode->i_mapping);
507 	truncate_inode_pages(sbi->direct_inode->i_mapping, 0);
508 	make_bad_inode(sbi->direct_inode);
509 	iput(sbi->direct_inode);
510 	sbi->direct_inode = NULL;
511 out_kfree:
512 	if (sbi->nls_tab)
513 		unload_nls(sbi->nls_tab);
514 	kfree(sbi);
515 	return -EINVAL;
516 }
517 
518 static void jfs_write_super_lockfs(struct super_block *sb)
519 {
520 	struct jfs_sb_info *sbi = JFS_SBI(sb);
521 	struct jfs_log *log = sbi->log;
522 
523 	if (!(sb->s_flags & MS_RDONLY)) {
524 		txQuiesce(sb);
525 		lmLogShutdown(log);
526 		updateSuper(sb, FM_CLEAN);
527 	}
528 }
529 
530 static void jfs_unlockfs(struct super_block *sb)
531 {
532 	struct jfs_sb_info *sbi = JFS_SBI(sb);
533 	struct jfs_log *log = sbi->log;
534 	int rc = 0;
535 
536 	if (!(sb->s_flags & MS_RDONLY)) {
537 		updateSuper(sb, FM_MOUNT);
538 		if ((rc = lmLogInit(log)))
539 			jfs_err("jfs_unlock failed with return code %d", rc);
540 		else
541 			txResume(sb);
542 	}
543 }
544 
545 static struct super_block *jfs_get_sb(struct file_system_type *fs_type,
546 	int flags, const char *dev_name, void *data)
547 {
548 	return get_sb_bdev(fs_type, flags, dev_name, data, jfs_fill_super);
549 }
550 
551 static int jfs_sync_fs(struct super_block *sb, int wait)
552 {
553 	struct jfs_log *log = JFS_SBI(sb)->log;
554 
555 	/* log == NULL indicates read-only mount */
556 	if (log) {
557 		jfs_flush_journal(log, wait);
558 		jfs_syncpt(log, 0);
559 	}
560 
561 	return 0;
562 }
563 
564 static int jfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
565 {
566 	struct jfs_sb_info *sbi = JFS_SBI(vfs->mnt_sb);
567 
568 	if (sbi->flag & JFS_NOINTEGRITY)
569 		seq_puts(seq, ",nointegrity");
570 	else
571 		seq_puts(seq, ",integrity");
572 
573 #if defined(CONFIG_QUOTA)
574 	if (sbi->flag & JFS_USRQUOTA)
575 		seq_puts(seq, ",usrquota");
576 
577 	if (sbi->flag & JFS_GRPQUOTA)
578 		seq_puts(seq, ",grpquota");
579 #endif
580 
581 	return 0;
582 }
583 
584 static struct super_operations jfs_super_operations = {
585 	.alloc_inode	= jfs_alloc_inode,
586 	.destroy_inode	= jfs_destroy_inode,
587 	.read_inode	= jfs_read_inode,
588 	.dirty_inode	= jfs_dirty_inode,
589 	.write_inode	= jfs_write_inode,
590 	.delete_inode	= jfs_delete_inode,
591 	.put_super	= jfs_put_super,
592 	.sync_fs	= jfs_sync_fs,
593 	.write_super_lockfs = jfs_write_super_lockfs,
594 	.unlockfs       = jfs_unlockfs,
595 	.statfs		= jfs_statfs,
596 	.remount_fs	= jfs_remount,
597 	.show_options	= jfs_show_options
598 };
599 
600 static struct export_operations jfs_export_operations = {
601 	.get_parent	= jfs_get_parent,
602 };
603 
604 static struct file_system_type jfs_fs_type = {
605 	.owner		= THIS_MODULE,
606 	.name		= "jfs",
607 	.get_sb		= jfs_get_sb,
608 	.kill_sb	= kill_block_super,
609 	.fs_flags	= FS_REQUIRES_DEV,
610 };
611 
612 static void init_once(void *foo, kmem_cache_t * cachep, unsigned long flags)
613 {
614 	struct jfs_inode_info *jfs_ip = (struct jfs_inode_info *) foo;
615 
616 	if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
617 	    SLAB_CTOR_CONSTRUCTOR) {
618 		memset(jfs_ip, 0, sizeof(struct jfs_inode_info));
619 		INIT_LIST_HEAD(&jfs_ip->anon_inode_list);
620 		init_rwsem(&jfs_ip->rdwrlock);
621 		init_MUTEX(&jfs_ip->commit_sem);
622 		init_rwsem(&jfs_ip->xattr_sem);
623 		spin_lock_init(&jfs_ip->ag_lock);
624 		jfs_ip->active_ag = -1;
625 #ifdef CONFIG_JFS_POSIX_ACL
626 		jfs_ip->i_acl = JFS_ACL_NOT_CACHED;
627 		jfs_ip->i_default_acl = JFS_ACL_NOT_CACHED;
628 #endif
629 		inode_init_once(&jfs_ip->vfs_inode);
630 	}
631 }
632 
633 static int __init init_jfs_fs(void)
634 {
635 	int i;
636 	int rc;
637 
638 	jfs_inode_cachep =
639 	    kmem_cache_create("jfs_ip", sizeof(struct jfs_inode_info), 0,
640 			    SLAB_RECLAIM_ACCOUNT, init_once, NULL);
641 	if (jfs_inode_cachep == NULL)
642 		return -ENOMEM;
643 
644 	/*
645 	 * Metapage initialization
646 	 */
647 	rc = metapage_init();
648 	if (rc) {
649 		jfs_err("metapage_init failed w/rc = %d", rc);
650 		goto free_slab;
651 	}
652 
653 	/*
654 	 * Transaction Manager initialization
655 	 */
656 	rc = txInit();
657 	if (rc) {
658 		jfs_err("txInit failed w/rc = %d", rc);
659 		goto free_metapage;
660 	}
661 
662 	/*
663 	 * I/O completion thread (endio)
664 	 */
665 	jfsIOthread = kernel_thread(jfsIOWait, NULL, CLONE_KERNEL);
666 	if (jfsIOthread < 0) {
667 		jfs_err("init_jfs_fs: fork failed w/rc = %d", jfsIOthread);
668 		goto end_txmngr;
669 	}
670 	wait_for_completion(&jfsIOwait);	/* Wait until thread starts */
671 
672 	if (commit_threads < 1)
673 		commit_threads = num_online_cpus();
674 	if (commit_threads > MAX_COMMIT_THREADS)
675 		commit_threads = MAX_COMMIT_THREADS;
676 
677 	for (i = 0; i < commit_threads; i++) {
678 		jfsCommitThread[i] = kernel_thread(jfs_lazycommit, NULL,
679 						   CLONE_KERNEL);
680 		if (jfsCommitThread[i] < 0) {
681 			jfs_err("init_jfs_fs: fork failed w/rc = %d",
682 				jfsCommitThread[i]);
683 			commit_threads = i;
684 			goto kill_committask;
685 		}
686 		/* Wait until thread starts */
687 		wait_for_completion(&jfsIOwait);
688 	}
689 
690 	jfsSyncThread = kernel_thread(jfs_sync, NULL, CLONE_KERNEL);
691 	if (jfsSyncThread < 0) {
692 		jfs_err("init_jfs_fs: fork failed w/rc = %d", jfsSyncThread);
693 		goto kill_committask;
694 	}
695 	wait_for_completion(&jfsIOwait);	/* Wait until thread starts */
696 
697 #ifdef PROC_FS_JFS
698 	jfs_proc_init();
699 #endif
700 
701 	return register_filesystem(&jfs_fs_type);
702 
703 kill_committask:
704 	jfs_stop_threads = 1;
705 	wake_up_all(&jfs_commit_thread_wait);
706 	for (i = 0; i < commit_threads; i++)
707 		wait_for_completion(&jfsIOwait);
708 
709 	wake_up(&jfs_IO_thread_wait);
710 	wait_for_completion(&jfsIOwait);	/* Wait for thread exit */
711 end_txmngr:
712 	txExit();
713 free_metapage:
714 	metapage_exit();
715 free_slab:
716 	kmem_cache_destroy(jfs_inode_cachep);
717 	return rc;
718 }
719 
720 static void __exit exit_jfs_fs(void)
721 {
722 	int i;
723 
724 	jfs_info("exit_jfs_fs called");
725 
726 	jfs_stop_threads = 1;
727 	txExit();
728 	metapage_exit();
729 	wake_up(&jfs_IO_thread_wait);
730 	wait_for_completion(&jfsIOwait);	/* Wait until IO thread exits */
731 	wake_up_all(&jfs_commit_thread_wait);
732 	for (i = 0; i < commit_threads; i++)
733 		wait_for_completion(&jfsIOwait);
734 	wake_up(&jfs_sync_thread_wait);
735 	wait_for_completion(&jfsIOwait);	/* Wait until Sync thread exits */
736 #ifdef PROC_FS_JFS
737 	jfs_proc_clean();
738 #endif
739 	unregister_filesystem(&jfs_fs_type);
740 	kmem_cache_destroy(jfs_inode_cachep);
741 }
742 
743 module_init(init_jfs_fs)
744 module_exit(exit_jfs_fs)
745