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/module.h>
22 #include <linux/parser.h>
23 #include <linux/completion.h>
24 #include <linux/vfs.h>
25 #include <linux/quotaops.h>
26 #include <linux/mount.h>
27 #include <linux/moduleparam.h>
28 #include <linux/kthread.h>
29 #include <linux/posix_acl.h>
30 #include <linux/buffer_head.h>
31 #include <linux/exportfs.h>
32 #include <linux/crc32.h>
33 #include <linux/slab.h>
34 #include <linux/uaccess.h>
35 #include <linux/seq_file.h>
36 #include <linux/blkdev.h>
37 
38 #include "jfs_incore.h"
39 #include "jfs_filsys.h"
40 #include "jfs_inode.h"
41 #include "jfs_metapage.h"
42 #include "jfs_superblock.h"
43 #include "jfs_dmap.h"
44 #include "jfs_imap.h"
45 #include "jfs_acl.h"
46 #include "jfs_debug.h"
47 #include "jfs_xattr.h"
48 #include "jfs_dinode.h"
49 
50 MODULE_DESCRIPTION("The Journaled Filesystem (JFS)");
51 MODULE_AUTHOR("Steve Best/Dave Kleikamp/Barry Arndt, IBM");
52 MODULE_LICENSE("GPL");
53 
54 static struct kmem_cache *jfs_inode_cachep;
55 
56 static const struct super_operations jfs_super_operations;
57 static const struct export_operations jfs_export_operations;
58 static struct file_system_type jfs_fs_type;
59 
60 #define MAX_COMMIT_THREADS 64
61 static int commit_threads;
62 module_param(commit_threads, int, 0);
63 MODULE_PARM_DESC(commit_threads, "Number of commit threads");
64 
65 static struct task_struct *jfsCommitThread[MAX_COMMIT_THREADS];
66 struct task_struct *jfsIOthread;
67 struct task_struct *jfsSyncThread;
68 
69 #ifdef CONFIG_JFS_DEBUG
70 int jfsloglevel = JFS_LOGLEVEL_WARN;
71 module_param(jfsloglevel, int, 0644);
72 MODULE_PARM_DESC(jfsloglevel, "Specify JFS loglevel (0, 1 or 2)");
73 #endif
74 
jfs_handle_error(struct super_block * sb)75 static void jfs_handle_error(struct super_block *sb)
76 {
77 	struct jfs_sb_info *sbi = JFS_SBI(sb);
78 
79 	if (sb_rdonly(sb))
80 		return;
81 
82 	updateSuper(sb, FM_DIRTY);
83 
84 	if (sbi->flag & JFS_ERR_PANIC)
85 		panic("JFS (device %s): panic forced after error\n",
86 			sb->s_id);
87 	else if (sbi->flag & JFS_ERR_REMOUNT_RO) {
88 		jfs_err("ERROR: (device %s): remounting filesystem as read-only",
89 			sb->s_id);
90 		sb->s_flags |= SB_RDONLY;
91 	}
92 
93 	/* nothing is done for continue beyond marking the superblock dirty */
94 }
95 
jfs_error(struct super_block * sb,const char * fmt,...)96 void jfs_error(struct super_block *sb, const char *fmt, ...)
97 {
98 	struct va_format vaf;
99 	va_list args;
100 
101 	va_start(args, fmt);
102 
103 	vaf.fmt = fmt;
104 	vaf.va = &args;
105 
106 	pr_err("ERROR: (device %s): %ps: %pV\n",
107 	       sb->s_id, __builtin_return_address(0), &vaf);
108 
109 	va_end(args);
110 
111 	jfs_handle_error(sb);
112 }
113 
jfs_alloc_inode(struct super_block * sb)114 static struct inode *jfs_alloc_inode(struct super_block *sb)
115 {
116 	struct jfs_inode_info *jfs_inode;
117 
118 	jfs_inode = kmem_cache_alloc(jfs_inode_cachep, GFP_NOFS);
119 	if (!jfs_inode)
120 		return NULL;
121 #ifdef CONFIG_QUOTA
122 	memset(&jfs_inode->i_dquot, 0, sizeof(jfs_inode->i_dquot));
123 #endif
124 	return &jfs_inode->vfs_inode;
125 }
126 
jfs_i_callback(struct rcu_head * head)127 static void jfs_i_callback(struct rcu_head *head)
128 {
129 	struct inode *inode = container_of(head, struct inode, i_rcu);
130 	struct jfs_inode_info *ji = JFS_IP(inode);
131 	kmem_cache_free(jfs_inode_cachep, ji);
132 }
133 
jfs_destroy_inode(struct inode * inode)134 static void jfs_destroy_inode(struct inode *inode)
135 {
136 	struct jfs_inode_info *ji = JFS_IP(inode);
137 
138 	BUG_ON(!list_empty(&ji->anon_inode_list));
139 
140 	spin_lock_irq(&ji->ag_lock);
141 	if (ji->active_ag != -1) {
142 		struct bmap *bmap = JFS_SBI(inode->i_sb)->bmap;
143 		atomic_dec(&bmap->db_active[ji->active_ag]);
144 		ji->active_ag = -1;
145 	}
146 	spin_unlock_irq(&ji->ag_lock);
147 	call_rcu(&inode->i_rcu, jfs_i_callback);
148 }
149 
jfs_statfs(struct dentry * dentry,struct kstatfs * buf)150 static int jfs_statfs(struct dentry *dentry, struct kstatfs *buf)
151 {
152 	struct jfs_sb_info *sbi = JFS_SBI(dentry->d_sb);
153 	s64 maxinodes;
154 	struct inomap *imap = JFS_IP(sbi->ipimap)->i_imap;
155 
156 	jfs_info("In jfs_statfs");
157 	buf->f_type = JFS_SUPER_MAGIC;
158 	buf->f_bsize = sbi->bsize;
159 	buf->f_blocks = sbi->bmap->db_mapsize;
160 	buf->f_bfree = sbi->bmap->db_nfree;
161 	buf->f_bavail = sbi->bmap->db_nfree;
162 	/*
163 	 * If we really return the number of allocated & free inodes, some
164 	 * applications will fail because they won't see enough free inodes.
165 	 * We'll try to calculate some guess as to how many inodes we can
166 	 * really allocate
167 	 *
168 	 * buf->f_files = atomic_read(&imap->im_numinos);
169 	 * buf->f_ffree = atomic_read(&imap->im_numfree);
170 	 */
171 	maxinodes = min((s64) atomic_read(&imap->im_numinos) +
172 			((sbi->bmap->db_nfree >> imap->im_l2nbperiext)
173 			 << L2INOSPEREXT), (s64) 0xffffffffLL);
174 	buf->f_files = maxinodes;
175 	buf->f_ffree = maxinodes - (atomic_read(&imap->im_numinos) -
176 				    atomic_read(&imap->im_numfree));
177 	buf->f_fsid.val[0] = (u32)crc32_le(0, sbi->uuid, sizeof(sbi->uuid)/2);
178 	buf->f_fsid.val[1] = (u32)crc32_le(0, sbi->uuid + sizeof(sbi->uuid)/2,
179 					sizeof(sbi->uuid)/2);
180 
181 	buf->f_namelen = JFS_NAME_MAX;
182 	return 0;
183 }
184 
185 #ifdef CONFIG_QUOTA
186 static int jfs_quota_off(struct super_block *sb, int type);
187 static int jfs_quota_on(struct super_block *sb, int type, int format_id,
188 			const struct path *path);
189 
jfs_quota_off_umount(struct super_block * sb)190 static void jfs_quota_off_umount(struct super_block *sb)
191 {
192 	int type;
193 
194 	for (type = 0; type < MAXQUOTAS; type++)
195 		jfs_quota_off(sb, type);
196 }
197 
198 static const struct quotactl_ops jfs_quotactl_ops = {
199 	.quota_on	= jfs_quota_on,
200 	.quota_off	= jfs_quota_off,
201 	.quota_sync	= dquot_quota_sync,
202 	.get_state	= dquot_get_state,
203 	.set_info	= dquot_set_dqinfo,
204 	.get_dqblk	= dquot_get_dqblk,
205 	.set_dqblk	= dquot_set_dqblk,
206 	.get_nextdqblk	= dquot_get_next_dqblk,
207 };
208 #else
jfs_quota_off_umount(struct super_block * sb)209 static inline void jfs_quota_off_umount(struct super_block *sb)
210 {
211 }
212 #endif
213 
jfs_put_super(struct super_block * sb)214 static void jfs_put_super(struct super_block *sb)
215 {
216 	struct jfs_sb_info *sbi = JFS_SBI(sb);
217 	int rc;
218 
219 	jfs_info("In jfs_put_super");
220 
221 	jfs_quota_off_umount(sb);
222 
223 	rc = jfs_umount(sb);
224 	if (rc)
225 		jfs_err("jfs_umount failed with return code %d", rc);
226 
227 	unload_nls(sbi->nls_tab);
228 
229 	truncate_inode_pages(sbi->direct_inode->i_mapping, 0);
230 	iput(sbi->direct_inode);
231 
232 	kfree(sbi);
233 }
234 
235 enum {
236 	Opt_integrity, Opt_nointegrity, Opt_iocharset, Opt_resize,
237 	Opt_resize_nosize, Opt_errors, Opt_ignore, Opt_err, Opt_quota,
238 	Opt_usrquota, Opt_grpquota, Opt_uid, Opt_gid, Opt_umask,
239 	Opt_discard, Opt_nodiscard, Opt_discard_minblk
240 };
241 
242 static const match_table_t tokens = {
243 	{Opt_integrity, "integrity"},
244 	{Opt_nointegrity, "nointegrity"},
245 	{Opt_iocharset, "iocharset=%s"},
246 	{Opt_resize, "resize=%u"},
247 	{Opt_resize_nosize, "resize"},
248 	{Opt_errors, "errors=%s"},
249 	{Opt_ignore, "noquota"},
250 	{Opt_ignore, "quota"},
251 	{Opt_usrquota, "usrquota"},
252 	{Opt_grpquota, "grpquota"},
253 	{Opt_uid, "uid=%u"},
254 	{Opt_gid, "gid=%u"},
255 	{Opt_umask, "umask=%u"},
256 	{Opt_discard, "discard"},
257 	{Opt_nodiscard, "nodiscard"},
258 	{Opt_discard_minblk, "discard=%u"},
259 	{Opt_err, NULL}
260 };
261 
parse_options(char * options,struct super_block * sb,s64 * newLVSize,int * flag)262 static int parse_options(char *options, struct super_block *sb, s64 *newLVSize,
263 			 int *flag)
264 {
265 	void *nls_map = (void *)-1;	/* -1: no change;  NULL: none */
266 	char *p;
267 	struct jfs_sb_info *sbi = JFS_SBI(sb);
268 
269 	*newLVSize = 0;
270 
271 	if (!options)
272 		return 1;
273 
274 	while ((p = strsep(&options, ",")) != NULL) {
275 		substring_t args[MAX_OPT_ARGS];
276 		int token;
277 		if (!*p)
278 			continue;
279 
280 		token = match_token(p, tokens, args);
281 		switch (token) {
282 		case Opt_integrity:
283 			*flag &= ~JFS_NOINTEGRITY;
284 			break;
285 		case Opt_nointegrity:
286 			*flag |= JFS_NOINTEGRITY;
287 			break;
288 		case Opt_ignore:
289 			/* Silently ignore the quota options */
290 			/* Don't do anything ;-) */
291 			break;
292 		case Opt_iocharset:
293 			if (nls_map && nls_map != (void *) -1)
294 				unload_nls(nls_map);
295 			if (!strcmp(args[0].from, "none"))
296 				nls_map = NULL;
297 			else {
298 				nls_map = load_nls(args[0].from);
299 				if (!nls_map) {
300 					pr_err("JFS: charset not found\n");
301 					goto cleanup;
302 				}
303 			}
304 			break;
305 		case Opt_resize:
306 		{
307 			char *resize = args[0].from;
308 			int rc = kstrtoll(resize, 0, newLVSize);
309 
310 			if (rc)
311 				goto cleanup;
312 			break;
313 		}
314 		case Opt_resize_nosize:
315 		{
316 			*newLVSize = i_size_read(sb->s_bdev->bd_inode) >>
317 				sb->s_blocksize_bits;
318 			if (*newLVSize == 0)
319 				pr_err("JFS: Cannot determine volume size\n");
320 			break;
321 		}
322 		case Opt_errors:
323 		{
324 			char *errors = args[0].from;
325 			if (!errors || !*errors)
326 				goto cleanup;
327 			if (!strcmp(errors, "continue")) {
328 				*flag &= ~JFS_ERR_REMOUNT_RO;
329 				*flag &= ~JFS_ERR_PANIC;
330 				*flag |= JFS_ERR_CONTINUE;
331 			} else if (!strcmp(errors, "remount-ro")) {
332 				*flag &= ~JFS_ERR_CONTINUE;
333 				*flag &= ~JFS_ERR_PANIC;
334 				*flag |= JFS_ERR_REMOUNT_RO;
335 			} else if (!strcmp(errors, "panic")) {
336 				*flag &= ~JFS_ERR_CONTINUE;
337 				*flag &= ~JFS_ERR_REMOUNT_RO;
338 				*flag |= JFS_ERR_PANIC;
339 			} else {
340 				pr_err("JFS: %s is an invalid error handler\n",
341 				       errors);
342 				goto cleanup;
343 			}
344 			break;
345 		}
346 
347 #ifdef CONFIG_QUOTA
348 		case Opt_quota:
349 		case Opt_usrquota:
350 			*flag |= JFS_USRQUOTA;
351 			break;
352 		case Opt_grpquota:
353 			*flag |= JFS_GRPQUOTA;
354 			break;
355 #else
356 		case Opt_usrquota:
357 		case Opt_grpquota:
358 		case Opt_quota:
359 			pr_err("JFS: quota operations not supported\n");
360 			break;
361 #endif
362 		case Opt_uid:
363 		{
364 			char *uid = args[0].from;
365 			uid_t val;
366 			int rc = kstrtouint(uid, 0, &val);
367 
368 			if (rc)
369 				goto cleanup;
370 			sbi->uid = make_kuid(current_user_ns(), val);
371 			if (!uid_valid(sbi->uid))
372 				goto cleanup;
373 			break;
374 		}
375 
376 		case Opt_gid:
377 		{
378 			char *gid = args[0].from;
379 			gid_t val;
380 			int rc = kstrtouint(gid, 0, &val);
381 
382 			if (rc)
383 				goto cleanup;
384 			sbi->gid = make_kgid(current_user_ns(), val);
385 			if (!gid_valid(sbi->gid))
386 				goto cleanup;
387 			break;
388 		}
389 
390 		case Opt_umask:
391 		{
392 			char *umask = args[0].from;
393 			int rc = kstrtouint(umask, 8, &sbi->umask);
394 
395 			if (rc)
396 				goto cleanup;
397 			if (sbi->umask & ~0777) {
398 				pr_err("JFS: Invalid value of umask\n");
399 				goto cleanup;
400 			}
401 			break;
402 		}
403 
404 		case Opt_discard:
405 		{
406 			struct request_queue *q = bdev_get_queue(sb->s_bdev);
407 			/* if set to 1, even copying files will cause
408 			 * trimming :O
409 			 * -> user has more control over the online trimming
410 			 */
411 			sbi->minblks_trim = 64;
412 			if (blk_queue_discard(q))
413 				*flag |= JFS_DISCARD;
414 			else
415 				pr_err("JFS: discard option not supported on device\n");
416 			break;
417 		}
418 
419 		case Opt_nodiscard:
420 			*flag &= ~JFS_DISCARD;
421 			break;
422 
423 		case Opt_discard_minblk:
424 		{
425 			struct request_queue *q = bdev_get_queue(sb->s_bdev);
426 			char *minblks_trim = args[0].from;
427 			int rc;
428 			if (blk_queue_discard(q)) {
429 				*flag |= JFS_DISCARD;
430 				rc = kstrtouint(minblks_trim, 0,
431 						&sbi->minblks_trim);
432 				if (rc)
433 					goto cleanup;
434 			} else
435 				pr_err("JFS: discard option not supported on device\n");
436 			break;
437 		}
438 
439 		default:
440 			printk("jfs: Unrecognized mount option \"%s\" or missing value\n",
441 			       p);
442 			goto cleanup;
443 		}
444 	}
445 
446 	if (nls_map != (void *) -1) {
447 		/* Discard old (if remount) */
448 		unload_nls(sbi->nls_tab);
449 		sbi->nls_tab = nls_map;
450 	}
451 	return 1;
452 
453 cleanup:
454 	if (nls_map && nls_map != (void *) -1)
455 		unload_nls(nls_map);
456 	return 0;
457 }
458 
jfs_remount(struct super_block * sb,int * flags,char * data)459 static int jfs_remount(struct super_block *sb, int *flags, char *data)
460 {
461 	s64 newLVSize = 0;
462 	int rc = 0;
463 	int flag = JFS_SBI(sb)->flag;
464 	int ret;
465 
466 	sync_filesystem(sb);
467 	if (!parse_options(data, sb, &newLVSize, &flag))
468 		return -EINVAL;
469 
470 	if (newLVSize) {
471 		if (sb_rdonly(sb)) {
472 			pr_err("JFS: resize requires volume to be mounted read-write\n");
473 			return -EROFS;
474 		}
475 		rc = jfs_extendfs(sb, newLVSize, 0);
476 		if (rc)
477 			return rc;
478 	}
479 
480 	if (sb_rdonly(sb) && !(*flags & SB_RDONLY)) {
481 		/*
482 		 * Invalidate any previously read metadata.  fsck may have
483 		 * changed the on-disk data since we mounted r/o
484 		 */
485 		truncate_inode_pages(JFS_SBI(sb)->direct_inode->i_mapping, 0);
486 
487 		JFS_SBI(sb)->flag = flag;
488 		ret = jfs_mount_rw(sb, 1);
489 
490 		/* mark the fs r/w for quota activity */
491 		sb->s_flags &= ~SB_RDONLY;
492 
493 		dquot_resume(sb, -1);
494 		return ret;
495 	}
496 	if (!sb_rdonly(sb) && (*flags & SB_RDONLY)) {
497 		rc = dquot_suspend(sb, -1);
498 		if (rc < 0)
499 			return rc;
500 		rc = jfs_umount_rw(sb);
501 		JFS_SBI(sb)->flag = flag;
502 		return rc;
503 	}
504 	if ((JFS_SBI(sb)->flag & JFS_NOINTEGRITY) != (flag & JFS_NOINTEGRITY))
505 		if (!sb_rdonly(sb)) {
506 			rc = jfs_umount_rw(sb);
507 			if (rc)
508 				return rc;
509 
510 			JFS_SBI(sb)->flag = flag;
511 			ret = jfs_mount_rw(sb, 1);
512 			return ret;
513 		}
514 	JFS_SBI(sb)->flag = flag;
515 
516 	return 0;
517 }
518 
jfs_fill_super(struct super_block * sb,void * data,int silent)519 static int jfs_fill_super(struct super_block *sb, void *data, int silent)
520 {
521 	struct jfs_sb_info *sbi;
522 	struct inode *inode;
523 	int rc;
524 	s64 newLVSize = 0;
525 	int flag, ret = -EINVAL;
526 
527 	jfs_info("In jfs_read_super: s_flags=0x%lx", sb->s_flags);
528 
529 	sbi = kzalloc(sizeof(struct jfs_sb_info), GFP_KERNEL);
530 	if (!sbi)
531 		return -ENOMEM;
532 
533 	sb->s_fs_info = sbi;
534 	sb->s_max_links = JFS_LINK_MAX;
535 	sbi->sb = sb;
536 	sbi->uid = INVALID_UID;
537 	sbi->gid = INVALID_GID;
538 	sbi->umask = -1;
539 
540 	/* initialize the mount flag and determine the default error handler */
541 	flag = JFS_ERR_REMOUNT_RO;
542 
543 	if (!parse_options((char *) data, sb, &newLVSize, &flag))
544 		goto out_kfree;
545 	sbi->flag = flag;
546 
547 #ifdef CONFIG_JFS_POSIX_ACL
548 	sb->s_flags |= SB_POSIXACL;
549 #endif
550 
551 	if (newLVSize) {
552 		pr_err("resize option for remount only\n");
553 		goto out_kfree;
554 	}
555 
556 	/*
557 	 * Initialize blocksize to 4K.
558 	 */
559 	sb_set_blocksize(sb, PSIZE);
560 
561 	/*
562 	 * Set method vectors.
563 	 */
564 	sb->s_op = &jfs_super_operations;
565 	sb->s_export_op = &jfs_export_operations;
566 	sb->s_xattr = jfs_xattr_handlers;
567 #ifdef CONFIG_QUOTA
568 	sb->dq_op = &dquot_operations;
569 	sb->s_qcop = &jfs_quotactl_ops;
570 	sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;
571 #endif
572 
573 	/*
574 	 * Initialize direct-mapping inode/address-space
575 	 */
576 	inode = new_inode(sb);
577 	if (inode == NULL) {
578 		ret = -ENOMEM;
579 		goto out_unload;
580 	}
581 	inode->i_ino = 0;
582 	inode->i_size = i_size_read(sb->s_bdev->bd_inode);
583 	inode->i_mapping->a_ops = &jfs_metapage_aops;
584 	inode_fake_hash(inode);
585 	mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
586 
587 	sbi->direct_inode = inode;
588 
589 	rc = jfs_mount(sb);
590 	if (rc) {
591 		if (!silent)
592 			jfs_err("jfs_mount failed w/return code = %d", rc);
593 		goto out_mount_failed;
594 	}
595 	if (sb_rdonly(sb))
596 		sbi->log = NULL;
597 	else {
598 		rc = jfs_mount_rw(sb, 0);
599 		if (rc) {
600 			if (!silent) {
601 				jfs_err("jfs_mount_rw failed, return code = %d",
602 					rc);
603 			}
604 			goto out_no_rw;
605 		}
606 	}
607 
608 	sb->s_magic = JFS_SUPER_MAGIC;
609 
610 	if (sbi->mntflag & JFS_OS2)
611 		sb->s_d_op = &jfs_ci_dentry_operations;
612 
613 	inode = jfs_iget(sb, ROOT_I);
614 	if (IS_ERR(inode)) {
615 		ret = PTR_ERR(inode);
616 		goto out_no_rw;
617 	}
618 	sb->s_root = d_make_root(inode);
619 	if (!sb->s_root)
620 		goto out_no_root;
621 
622 	/* logical blocks are represented by 40 bits in pxd_t, etc.
623 	 * and page cache is indexed by long
624 	 */
625 	sb->s_maxbytes = min(((loff_t)sb->s_blocksize) << 40, MAX_LFS_FILESIZE);
626 	sb->s_time_gran = 1;
627 	return 0;
628 
629 out_no_root:
630 	jfs_err("jfs_read_super: get root dentry failed");
631 
632 out_no_rw:
633 	rc = jfs_umount(sb);
634 	if (rc)
635 		jfs_err("jfs_umount failed with return code %d", rc);
636 out_mount_failed:
637 	filemap_write_and_wait(sbi->direct_inode->i_mapping);
638 	truncate_inode_pages(sbi->direct_inode->i_mapping, 0);
639 	make_bad_inode(sbi->direct_inode);
640 	iput(sbi->direct_inode);
641 	sbi->direct_inode = NULL;
642 out_unload:
643 	unload_nls(sbi->nls_tab);
644 out_kfree:
645 	kfree(sbi);
646 	return ret;
647 }
648 
jfs_freeze(struct super_block * sb)649 static int jfs_freeze(struct super_block *sb)
650 {
651 	struct jfs_sb_info *sbi = JFS_SBI(sb);
652 	struct jfs_log *log = sbi->log;
653 	int rc = 0;
654 
655 	if (!sb_rdonly(sb)) {
656 		txQuiesce(sb);
657 		rc = lmLogShutdown(log);
658 		if (rc) {
659 			jfs_error(sb, "lmLogShutdown failed\n");
660 
661 			/* let operations fail rather than hang */
662 			txResume(sb);
663 
664 			return rc;
665 		}
666 		rc = updateSuper(sb, FM_CLEAN);
667 		if (rc) {
668 			jfs_err("jfs_freeze: updateSuper failed");
669 			/*
670 			 * Don't fail here. Everything succeeded except
671 			 * marking the superblock clean, so there's really
672 			 * no harm in leaving it frozen for now.
673 			 */
674 		}
675 	}
676 	return 0;
677 }
678 
jfs_unfreeze(struct super_block * sb)679 static int jfs_unfreeze(struct super_block *sb)
680 {
681 	struct jfs_sb_info *sbi = JFS_SBI(sb);
682 	struct jfs_log *log = sbi->log;
683 	int rc = 0;
684 
685 	if (!sb_rdonly(sb)) {
686 		rc = updateSuper(sb, FM_MOUNT);
687 		if (rc) {
688 			jfs_error(sb, "updateSuper failed\n");
689 			goto out;
690 		}
691 		rc = lmLogInit(log);
692 		if (rc)
693 			jfs_error(sb, "lmLogInit failed\n");
694 out:
695 		txResume(sb);
696 	}
697 	return rc;
698 }
699 
jfs_do_mount(struct file_system_type * fs_type,int flags,const char * dev_name,void * data)700 static struct dentry *jfs_do_mount(struct file_system_type *fs_type,
701 	int flags, const char *dev_name, void *data)
702 {
703 	return mount_bdev(fs_type, flags, dev_name, data, jfs_fill_super);
704 }
705 
jfs_sync_fs(struct super_block * sb,int wait)706 static int jfs_sync_fs(struct super_block *sb, int wait)
707 {
708 	struct jfs_log *log = JFS_SBI(sb)->log;
709 
710 	/* log == NULL indicates read-only mount */
711 	if (log) {
712 		/*
713 		 * Write quota structures to quota file, sync_blockdev() will
714 		 * write them to disk later
715 		 */
716 		dquot_writeback_dquots(sb, -1);
717 		jfs_flush_journal(log, wait);
718 		jfs_syncpt(log, 0);
719 	}
720 
721 	return 0;
722 }
723 
jfs_show_options(struct seq_file * seq,struct dentry * root)724 static int jfs_show_options(struct seq_file *seq, struct dentry *root)
725 {
726 	struct jfs_sb_info *sbi = JFS_SBI(root->d_sb);
727 
728 	if (uid_valid(sbi->uid))
729 		seq_printf(seq, ",uid=%d", from_kuid(&init_user_ns, sbi->uid));
730 	if (gid_valid(sbi->gid))
731 		seq_printf(seq, ",gid=%d", from_kgid(&init_user_ns, sbi->gid));
732 	if (sbi->umask != -1)
733 		seq_printf(seq, ",umask=%03o", sbi->umask);
734 	if (sbi->flag & JFS_NOINTEGRITY)
735 		seq_puts(seq, ",nointegrity");
736 	if (sbi->flag & JFS_DISCARD)
737 		seq_printf(seq, ",discard=%u", sbi->minblks_trim);
738 	if (sbi->nls_tab)
739 		seq_printf(seq, ",iocharset=%s", sbi->nls_tab->charset);
740 	if (sbi->flag & JFS_ERR_CONTINUE)
741 		seq_printf(seq, ",errors=continue");
742 	if (sbi->flag & JFS_ERR_PANIC)
743 		seq_printf(seq, ",errors=panic");
744 
745 #ifdef CONFIG_QUOTA
746 	if (sbi->flag & JFS_USRQUOTA)
747 		seq_puts(seq, ",usrquota");
748 
749 	if (sbi->flag & JFS_GRPQUOTA)
750 		seq_puts(seq, ",grpquota");
751 #endif
752 
753 	return 0;
754 }
755 
756 #ifdef CONFIG_QUOTA
757 
758 /* Read data from quotafile - avoid pagecache and such because we cannot afford
759  * acquiring the locks... As quota files are never truncated and quota code
760  * itself serializes the operations (and no one else should touch the files)
761  * we don't have to be afraid of races */
jfs_quota_read(struct super_block * sb,int type,char * data,size_t len,loff_t off)762 static ssize_t jfs_quota_read(struct super_block *sb, int type, char *data,
763 			      size_t len, loff_t off)
764 {
765 	struct inode *inode = sb_dqopt(sb)->files[type];
766 	sector_t blk = off >> sb->s_blocksize_bits;
767 	int err = 0;
768 	int offset = off & (sb->s_blocksize - 1);
769 	int tocopy;
770 	size_t toread;
771 	struct buffer_head tmp_bh;
772 	struct buffer_head *bh;
773 	loff_t i_size = i_size_read(inode);
774 
775 	if (off > i_size)
776 		return 0;
777 	if (off+len > i_size)
778 		len = i_size-off;
779 	toread = len;
780 	while (toread > 0) {
781 		tocopy = sb->s_blocksize - offset < toread ?
782 				sb->s_blocksize - offset : toread;
783 
784 		tmp_bh.b_state = 0;
785 		tmp_bh.b_size = i_blocksize(inode);
786 		err = jfs_get_block(inode, blk, &tmp_bh, 0);
787 		if (err)
788 			return err;
789 		if (!buffer_mapped(&tmp_bh))	/* A hole? */
790 			memset(data, 0, tocopy);
791 		else {
792 			bh = sb_bread(sb, tmp_bh.b_blocknr);
793 			if (!bh)
794 				return -EIO;
795 			memcpy(data, bh->b_data+offset, tocopy);
796 			brelse(bh);
797 		}
798 		offset = 0;
799 		toread -= tocopy;
800 		data += tocopy;
801 		blk++;
802 	}
803 	return len;
804 }
805 
806 /* Write to quotafile */
jfs_quota_write(struct super_block * sb,int type,const char * data,size_t len,loff_t off)807 static ssize_t jfs_quota_write(struct super_block *sb, int type,
808 			       const char *data, size_t len, loff_t off)
809 {
810 	struct inode *inode = sb_dqopt(sb)->files[type];
811 	sector_t blk = off >> sb->s_blocksize_bits;
812 	int err = 0;
813 	int offset = off & (sb->s_blocksize - 1);
814 	int tocopy;
815 	size_t towrite = len;
816 	struct buffer_head tmp_bh;
817 	struct buffer_head *bh;
818 
819 	inode_lock(inode);
820 	while (towrite > 0) {
821 		tocopy = sb->s_blocksize - offset < towrite ?
822 				sb->s_blocksize - offset : towrite;
823 
824 		tmp_bh.b_state = 0;
825 		tmp_bh.b_size = i_blocksize(inode);
826 		err = jfs_get_block(inode, blk, &tmp_bh, 1);
827 		if (err)
828 			goto out;
829 		if (offset || tocopy != sb->s_blocksize)
830 			bh = sb_bread(sb, tmp_bh.b_blocknr);
831 		else
832 			bh = sb_getblk(sb, tmp_bh.b_blocknr);
833 		if (!bh) {
834 			err = -EIO;
835 			goto out;
836 		}
837 		lock_buffer(bh);
838 		memcpy(bh->b_data+offset, data, tocopy);
839 		flush_dcache_page(bh->b_page);
840 		set_buffer_uptodate(bh);
841 		mark_buffer_dirty(bh);
842 		unlock_buffer(bh);
843 		brelse(bh);
844 		offset = 0;
845 		towrite -= tocopy;
846 		data += tocopy;
847 		blk++;
848 	}
849 out:
850 	if (len == towrite) {
851 		inode_unlock(inode);
852 		return err;
853 	}
854 	if (inode->i_size < off+len-towrite)
855 		i_size_write(inode, off+len-towrite);
856 	inode->i_mtime = inode->i_ctime = current_time(inode);
857 	mark_inode_dirty(inode);
858 	inode_unlock(inode);
859 	return len - towrite;
860 }
861 
jfs_get_dquots(struct inode * inode)862 static struct dquot **jfs_get_dquots(struct inode *inode)
863 {
864 	return JFS_IP(inode)->i_dquot;
865 }
866 
jfs_quota_on(struct super_block * sb,int type,int format_id,const struct path * path)867 static int jfs_quota_on(struct super_block *sb, int type, int format_id,
868 			const struct path *path)
869 {
870 	int err;
871 	struct inode *inode;
872 
873 	err = dquot_quota_on(sb, type, format_id, path);
874 	if (err)
875 		return err;
876 
877 	inode = d_inode(path->dentry);
878 	inode_lock(inode);
879 	JFS_IP(inode)->mode2 |= JFS_NOATIME_FL | JFS_IMMUTABLE_FL;
880 	inode_set_flags(inode, S_NOATIME | S_IMMUTABLE,
881 			S_NOATIME | S_IMMUTABLE);
882 	inode_unlock(inode);
883 	mark_inode_dirty(inode);
884 
885 	return 0;
886 }
887 
jfs_quota_off(struct super_block * sb,int type)888 static int jfs_quota_off(struct super_block *sb, int type)
889 {
890 	struct inode *inode = sb_dqopt(sb)->files[type];
891 	int err;
892 
893 	if (!inode || !igrab(inode))
894 		goto out;
895 
896 	err = dquot_quota_off(sb, type);
897 	if (err)
898 		goto out_put;
899 
900 	inode_lock(inode);
901 	JFS_IP(inode)->mode2 &= ~(JFS_NOATIME_FL | JFS_IMMUTABLE_FL);
902 	inode_set_flags(inode, 0, S_NOATIME | S_IMMUTABLE);
903 	inode_unlock(inode);
904 	mark_inode_dirty(inode);
905 out_put:
906 	iput(inode);
907 	return err;
908 out:
909 	return dquot_quota_off(sb, type);
910 }
911 #endif
912 
913 static const struct super_operations jfs_super_operations = {
914 	.alloc_inode	= jfs_alloc_inode,
915 	.destroy_inode	= jfs_destroy_inode,
916 	.dirty_inode	= jfs_dirty_inode,
917 	.write_inode	= jfs_write_inode,
918 	.evict_inode	= jfs_evict_inode,
919 	.put_super	= jfs_put_super,
920 	.sync_fs	= jfs_sync_fs,
921 	.freeze_fs	= jfs_freeze,
922 	.unfreeze_fs	= jfs_unfreeze,
923 	.statfs		= jfs_statfs,
924 	.remount_fs	= jfs_remount,
925 	.show_options	= jfs_show_options,
926 #ifdef CONFIG_QUOTA
927 	.quota_read	= jfs_quota_read,
928 	.quota_write	= jfs_quota_write,
929 	.get_dquots	= jfs_get_dquots,
930 #endif
931 };
932 
933 static const struct export_operations jfs_export_operations = {
934 	.fh_to_dentry	= jfs_fh_to_dentry,
935 	.fh_to_parent	= jfs_fh_to_parent,
936 	.get_parent	= jfs_get_parent,
937 };
938 
939 static struct file_system_type jfs_fs_type = {
940 	.owner		= THIS_MODULE,
941 	.name		= "jfs",
942 	.mount		= jfs_do_mount,
943 	.kill_sb	= kill_block_super,
944 	.fs_flags	= FS_REQUIRES_DEV,
945 };
946 MODULE_ALIAS_FS("jfs");
947 
init_once(void * foo)948 static void init_once(void *foo)
949 {
950 	struct jfs_inode_info *jfs_ip = (struct jfs_inode_info *) foo;
951 
952 	memset(jfs_ip, 0, sizeof(struct jfs_inode_info));
953 	INIT_LIST_HEAD(&jfs_ip->anon_inode_list);
954 	init_rwsem(&jfs_ip->rdwrlock);
955 	mutex_init(&jfs_ip->commit_mutex);
956 	init_rwsem(&jfs_ip->xattr_sem);
957 	spin_lock_init(&jfs_ip->ag_lock);
958 	jfs_ip->active_ag = -1;
959 	inode_init_once(&jfs_ip->vfs_inode);
960 }
961 
init_jfs_fs(void)962 static int __init init_jfs_fs(void)
963 {
964 	int i;
965 	int rc;
966 
967 	jfs_inode_cachep =
968 	    kmem_cache_create_usercopy("jfs_ip", sizeof(struct jfs_inode_info),
969 			0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|SLAB_ACCOUNT,
970 			offsetof(struct jfs_inode_info, i_inline), IDATASIZE,
971 			init_once);
972 	if (jfs_inode_cachep == NULL)
973 		return -ENOMEM;
974 
975 	/*
976 	 * Metapage initialization
977 	 */
978 	rc = metapage_init();
979 	if (rc) {
980 		jfs_err("metapage_init failed w/rc = %d", rc);
981 		goto free_slab;
982 	}
983 
984 	/*
985 	 * Transaction Manager initialization
986 	 */
987 	rc = txInit();
988 	if (rc) {
989 		jfs_err("txInit failed w/rc = %d", rc);
990 		goto free_metapage;
991 	}
992 
993 	/*
994 	 * I/O completion thread (endio)
995 	 */
996 	jfsIOthread = kthread_run(jfsIOWait, NULL, "jfsIO");
997 	if (IS_ERR(jfsIOthread)) {
998 		rc = PTR_ERR(jfsIOthread);
999 		jfs_err("init_jfs_fs: fork failed w/rc = %d", rc);
1000 		goto end_txmngr;
1001 	}
1002 
1003 	if (commit_threads < 1)
1004 		commit_threads = num_online_cpus();
1005 	if (commit_threads > MAX_COMMIT_THREADS)
1006 		commit_threads = MAX_COMMIT_THREADS;
1007 
1008 	for (i = 0; i < commit_threads; i++) {
1009 		jfsCommitThread[i] = kthread_run(jfs_lazycommit, NULL,
1010 						 "jfsCommit");
1011 		if (IS_ERR(jfsCommitThread[i])) {
1012 			rc = PTR_ERR(jfsCommitThread[i]);
1013 			jfs_err("init_jfs_fs: fork failed w/rc = %d", rc);
1014 			commit_threads = i;
1015 			goto kill_committask;
1016 		}
1017 	}
1018 
1019 	jfsSyncThread = kthread_run(jfs_sync, NULL, "jfsSync");
1020 	if (IS_ERR(jfsSyncThread)) {
1021 		rc = PTR_ERR(jfsSyncThread);
1022 		jfs_err("init_jfs_fs: fork failed w/rc = %d", rc);
1023 		goto kill_committask;
1024 	}
1025 
1026 #ifdef PROC_FS_JFS
1027 	jfs_proc_init();
1028 #endif
1029 
1030 	rc = register_filesystem(&jfs_fs_type);
1031 	if (!rc)
1032 		return 0;
1033 
1034 #ifdef PROC_FS_JFS
1035 	jfs_proc_clean();
1036 #endif
1037 	kthread_stop(jfsSyncThread);
1038 kill_committask:
1039 	for (i = 0; i < commit_threads; i++)
1040 		kthread_stop(jfsCommitThread[i]);
1041 	kthread_stop(jfsIOthread);
1042 end_txmngr:
1043 	txExit();
1044 free_metapage:
1045 	metapage_exit();
1046 free_slab:
1047 	kmem_cache_destroy(jfs_inode_cachep);
1048 	return rc;
1049 }
1050 
exit_jfs_fs(void)1051 static void __exit exit_jfs_fs(void)
1052 {
1053 	int i;
1054 
1055 	jfs_info("exit_jfs_fs called");
1056 
1057 	txExit();
1058 	metapage_exit();
1059 
1060 	kthread_stop(jfsIOthread);
1061 	for (i = 0; i < commit_threads; i++)
1062 		kthread_stop(jfsCommitThread[i]);
1063 	kthread_stop(jfsSyncThread);
1064 #ifdef PROC_FS_JFS
1065 	jfs_proc_clean();
1066 #endif
1067 	unregister_filesystem(&jfs_fs_type);
1068 
1069 	/*
1070 	 * Make sure all delayed rcu free inodes are flushed before we
1071 	 * destroy cache.
1072 	 */
1073 	rcu_barrier();
1074 	kmem_cache_destroy(jfs_inode_cachep);
1075 }
1076 
1077 module_init(init_jfs_fs)
1078 module_exit(exit_jfs_fs)
1079