quota: move unmount handling into the filesystem
[linux-3.10.git] / fs / jfs / super.c
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 <asm/uaccess.h>
35 #include <linux/seq_file.h>
36 #include <linux/smp_lock.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
48 MODULE_DESCRIPTION("The Journaled Filesystem (JFS)");
49 MODULE_AUTHOR("Steve Best/Dave Kleikamp/Barry Arndt, IBM");
50 MODULE_LICENSE("GPL");
51
52 static struct kmem_cache * jfs_inode_cachep;
53
54 static const struct super_operations jfs_super_operations;
55 static const struct export_operations jfs_export_operations;
56 static struct file_system_type jfs_fs_type;
57
58 #define MAX_COMMIT_THREADS 64
59 static int commit_threads = 0;
60 module_param(commit_threads, int, 0);
61 MODULE_PARM_DESC(commit_threads, "Number of commit threads");
62
63 static struct task_struct *jfsCommitThread[MAX_COMMIT_THREADS];
64 struct task_struct *jfsIOthread;
65 struct task_struct *jfsSyncThread;
66
67 #ifdef CONFIG_JFS_DEBUG
68 int jfsloglevel = JFS_LOGLEVEL_WARN;
69 module_param(jfsloglevel, int, 0644);
70 MODULE_PARM_DESC(jfsloglevel, "Specify JFS loglevel (0, 1 or 2)");
71 #endif
72
73 static void jfs_handle_error(struct super_block *sb)
74 {
75         struct jfs_sb_info *sbi = JFS_SBI(sb);
76
77         if (sb->s_flags & MS_RDONLY)
78                 return;
79
80         updateSuper(sb, FM_DIRTY);
81
82         if (sbi->flag & JFS_ERR_PANIC)
83                 panic("JFS (device %s): panic forced after error\n",
84                         sb->s_id);
85         else if (sbi->flag & JFS_ERR_REMOUNT_RO) {
86                 jfs_err("ERROR: (device %s): remounting filesystem "
87                         "as read-only\n",
88                         sb->s_id);
89                 sb->s_flags |= MS_RDONLY;
90         }
91
92         /* nothing is done for continue beyond marking the superblock dirty */
93 }
94
95 void jfs_error(struct super_block *sb, const char * function, ...)
96 {
97         static char error_buf[256];
98         va_list args;
99
100         va_start(args, function);
101         vsnprintf(error_buf, sizeof(error_buf), function, args);
102         va_end(args);
103
104         printk(KERN_ERR "ERROR: (device %s): %s\n", sb->s_id, error_buf);
105
106         jfs_handle_error(sb);
107 }
108
109 static struct inode *jfs_alloc_inode(struct super_block *sb)
110 {
111         struct jfs_inode_info *jfs_inode;
112
113         jfs_inode = kmem_cache_alloc(jfs_inode_cachep, GFP_NOFS);
114         if (!jfs_inode)
115                 return NULL;
116         return &jfs_inode->vfs_inode;
117 }
118
119 static void jfs_destroy_inode(struct inode *inode)
120 {
121         struct jfs_inode_info *ji = JFS_IP(inode);
122
123         BUG_ON(!list_empty(&ji->anon_inode_list));
124
125         spin_lock_irq(&ji->ag_lock);
126         if (ji->active_ag != -1) {
127                 struct bmap *bmap = JFS_SBI(inode->i_sb)->bmap;
128                 atomic_dec(&bmap->db_active[ji->active_ag]);
129                 ji->active_ag = -1;
130         }
131         spin_unlock_irq(&ji->ag_lock);
132         kmem_cache_free(jfs_inode_cachep, ji);
133 }
134
135 static void jfs_clear_inode(struct inode *inode)
136 {
137         dquot_drop(inode);
138 }
139
140 static int jfs_statfs(struct dentry *dentry, struct kstatfs *buf)
141 {
142         struct jfs_sb_info *sbi = JFS_SBI(dentry->d_sb);
143         s64 maxinodes;
144         struct inomap *imap = JFS_IP(sbi->ipimap)->i_imap;
145
146         jfs_info("In jfs_statfs");
147         buf->f_type = JFS_SUPER_MAGIC;
148         buf->f_bsize = sbi->bsize;
149         buf->f_blocks = sbi->bmap->db_mapsize;
150         buf->f_bfree = sbi->bmap->db_nfree;
151         buf->f_bavail = sbi->bmap->db_nfree;
152         /*
153          * If we really return the number of allocated & free inodes, some
154          * applications will fail because they won't see enough free inodes.
155          * We'll try to calculate some guess as to how may inodes we can
156          * really allocate
157          *
158          * buf->f_files = atomic_read(&imap->im_numinos);
159          * buf->f_ffree = atomic_read(&imap->im_numfree);
160          */
161         maxinodes = min((s64) atomic_read(&imap->im_numinos) +
162                         ((sbi->bmap->db_nfree >> imap->im_l2nbperiext)
163                          << L2INOSPEREXT), (s64) 0xffffffffLL);
164         buf->f_files = maxinodes;
165         buf->f_ffree = maxinodes - (atomic_read(&imap->im_numinos) -
166                                     atomic_read(&imap->im_numfree));
167         buf->f_fsid.val[0] = (u32)crc32_le(0, sbi->uuid, sizeof(sbi->uuid)/2);
168         buf->f_fsid.val[1] = (u32)crc32_le(0, sbi->uuid + sizeof(sbi->uuid)/2,
169                                         sizeof(sbi->uuid)/2);
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
182         dquot_disable(sb, -1, DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
183
184         lock_kernel();
185
186         rc = jfs_umount(sb);
187         if (rc)
188                 jfs_err("jfs_umount failed with return code %d", rc);
189
190         unload_nls(sbi->nls_tab);
191
192         truncate_inode_pages(sbi->direct_inode->i_mapping, 0);
193         iput(sbi->direct_inode);
194
195         kfree(sbi);
196
197         unlock_kernel();
198 }
199
200 enum {
201         Opt_integrity, Opt_nointegrity, Opt_iocharset, Opt_resize,
202         Opt_resize_nosize, Opt_errors, Opt_ignore, Opt_err, Opt_quota,
203         Opt_usrquota, Opt_grpquota, Opt_uid, Opt_gid, Opt_umask
204 };
205
206 static const match_table_t tokens = {
207         {Opt_integrity, "integrity"},
208         {Opt_nointegrity, "nointegrity"},
209         {Opt_iocharset, "iocharset=%s"},
210         {Opt_resize, "resize=%u"},
211         {Opt_resize_nosize, "resize"},
212         {Opt_errors, "errors=%s"},
213         {Opt_ignore, "noquota"},
214         {Opt_ignore, "quota"},
215         {Opt_usrquota, "usrquota"},
216         {Opt_grpquota, "grpquota"},
217         {Opt_uid, "uid=%u"},
218         {Opt_gid, "gid=%u"},
219         {Opt_umask, "umask=%u"},
220         {Opt_err, NULL}
221 };
222
223 static int parse_options(char *options, struct super_block *sb, s64 *newLVSize,
224                          int *flag)
225 {
226         void *nls_map = (void *)-1;     /* -1: no change;  NULL: none */
227         char *p;
228         struct jfs_sb_info *sbi = JFS_SBI(sb);
229
230         *newLVSize = 0;
231
232         if (!options)
233                 return 1;
234
235         while ((p = strsep(&options, ",")) != NULL) {
236                 substring_t args[MAX_OPT_ARGS];
237                 int token;
238                 if (!*p)
239                         continue;
240
241                 token = match_token(p, tokens, args);
242                 switch (token) {
243                 case Opt_integrity:
244                         *flag &= ~JFS_NOINTEGRITY;
245                         break;
246                 case Opt_nointegrity:
247                         *flag |= JFS_NOINTEGRITY;
248                         break;
249                 case Opt_ignore:
250                         /* Silently ignore the quota options */
251                         /* Don't do anything ;-) */
252                         break;
253                 case Opt_iocharset:
254                         if (nls_map && nls_map != (void *) -1)
255                                 unload_nls(nls_map);
256                         if (!strcmp(args[0].from, "none"))
257                                 nls_map = NULL;
258                         else {
259                                 nls_map = load_nls(args[0].from);
260                                 if (!nls_map) {
261                                         printk(KERN_ERR
262                                                "JFS: charset not found\n");
263                                         goto cleanup;
264                                 }
265                         }
266                         break;
267                 case Opt_resize:
268                 {
269                         char *resize = args[0].from;
270                         *newLVSize = simple_strtoull(resize, &resize, 0);
271                         break;
272                 }
273                 case Opt_resize_nosize:
274                 {
275                         *newLVSize = sb->s_bdev->bd_inode->i_size >>
276                                 sb->s_blocksize_bits;
277                         if (*newLVSize == 0)
278                                 printk(KERN_ERR
279                                        "JFS: Cannot determine volume size\n");
280                         break;
281                 }
282                 case Opt_errors:
283                 {
284                         char *errors = args[0].from;
285                         if (!errors || !*errors)
286                                 goto cleanup;
287                         if (!strcmp(errors, "continue")) {
288                                 *flag &= ~JFS_ERR_REMOUNT_RO;
289                                 *flag &= ~JFS_ERR_PANIC;
290                                 *flag |= JFS_ERR_CONTINUE;
291                         } else if (!strcmp(errors, "remount-ro")) {
292                                 *flag &= ~JFS_ERR_CONTINUE;
293                                 *flag &= ~JFS_ERR_PANIC;
294                                 *flag |= JFS_ERR_REMOUNT_RO;
295                         } else if (!strcmp(errors, "panic")) {
296                                 *flag &= ~JFS_ERR_CONTINUE;
297                                 *flag &= ~JFS_ERR_REMOUNT_RO;
298                                 *flag |= JFS_ERR_PANIC;
299                         } else {
300                                 printk(KERN_ERR
301                                        "JFS: %s is an invalid error handler\n",
302                                        errors);
303                                 goto cleanup;
304                         }
305                         break;
306                 }
307
308 #ifdef CONFIG_QUOTA
309                 case Opt_quota:
310                 case Opt_usrquota:
311                         *flag |= JFS_USRQUOTA;
312                         break;
313                 case Opt_grpquota:
314                         *flag |= JFS_GRPQUOTA;
315                         break;
316 #else
317                 case Opt_usrquota:
318                 case Opt_grpquota:
319                 case Opt_quota:
320                         printk(KERN_ERR
321                                "JFS: quota operations not supported\n");
322                         break;
323 #endif
324                 case Opt_uid:
325                 {
326                         char *uid = args[0].from;
327                         sbi->uid = simple_strtoul(uid, &uid, 0);
328                         break;
329                 }
330                 case Opt_gid:
331                 {
332                         char *gid = args[0].from;
333                         sbi->gid = simple_strtoul(gid, &gid, 0);
334                         break;
335                 }
336                 case Opt_umask:
337                 {
338                         char *umask = args[0].from;
339                         sbi->umask = simple_strtoul(umask, &umask, 8);
340                         if (sbi->umask & ~0777) {
341                                 printk(KERN_ERR
342                                        "JFS: Invalid value of umask\n");
343                                 goto cleanup;
344                         }
345                         break;
346                 }
347                 default:
348                         printk("jfs: Unrecognized mount option \"%s\" "
349                                         " or missing value\n", p);
350                         goto cleanup;
351                 }
352         }
353
354         if (nls_map != (void *) -1) {
355                 /* Discard old (if remount) */
356                 unload_nls(sbi->nls_tab);
357                 sbi->nls_tab = nls_map;
358         }
359         return 1;
360
361 cleanup:
362         if (nls_map && nls_map != (void *) -1)
363                 unload_nls(nls_map);
364         return 0;
365 }
366
367 static int jfs_remount(struct super_block *sb, int *flags, char *data)
368 {
369         s64 newLVSize = 0;
370         int rc = 0;
371         int flag = JFS_SBI(sb)->flag;
372         int ret;
373
374         if (!parse_options(data, sb, &newLVSize, &flag)) {
375                 return -EINVAL;
376         }
377         lock_kernel();
378         if (newLVSize) {
379                 if (sb->s_flags & MS_RDONLY) {
380                         printk(KERN_ERR
381                   "JFS: resize requires volume to be mounted read-write\n");
382                         unlock_kernel();
383                         return -EROFS;
384                 }
385                 rc = jfs_extendfs(sb, newLVSize, 0);
386                 if (rc) {
387                         unlock_kernel();
388                         return rc;
389                 }
390         }
391
392         if ((sb->s_flags & MS_RDONLY) && !(*flags & MS_RDONLY)) {
393                 /*
394                  * Invalidate any previously read metadata.  fsck may have
395                  * changed the on-disk data since we mounted r/o
396                  */
397                 truncate_inode_pages(JFS_SBI(sb)->direct_inode->i_mapping, 0);
398
399                 JFS_SBI(sb)->flag = flag;
400                 ret = jfs_mount_rw(sb, 1);
401
402                 /* mark the fs r/w for quota activity */
403                 sb->s_flags &= ~MS_RDONLY;
404
405                 unlock_kernel();
406                 dquot_resume(sb, -1);
407                 return ret;
408         }
409         if ((!(sb->s_flags & MS_RDONLY)) && (*flags & MS_RDONLY)) {
410                 rc = dquot_suspend(sb, -1);
411                 if (rc < 0) {
412                         unlock_kernel();
413                         return rc;
414                 }
415                 rc = jfs_umount_rw(sb);
416                 JFS_SBI(sb)->flag = flag;
417                 unlock_kernel();
418                 return rc;
419         }
420         if ((JFS_SBI(sb)->flag & JFS_NOINTEGRITY) != (flag & JFS_NOINTEGRITY))
421                 if (!(sb->s_flags & MS_RDONLY)) {
422                         rc = jfs_umount_rw(sb);
423                         if (rc) {
424                                 unlock_kernel();
425                                 return rc;
426                         }
427                         JFS_SBI(sb)->flag = flag;
428                         ret = jfs_mount_rw(sb, 1);
429                         unlock_kernel();
430                         return ret;
431                 }
432         JFS_SBI(sb)->flag = flag;
433
434         unlock_kernel();
435         return 0;
436 }
437
438 static int jfs_fill_super(struct super_block *sb, void *data, int silent)
439 {
440         struct jfs_sb_info *sbi;
441         struct inode *inode;
442         int rc;
443         s64 newLVSize = 0;
444         int flag, ret = -EINVAL;
445
446         jfs_info("In jfs_read_super: s_flags=0x%lx", sb->s_flags);
447
448         if (!new_valid_dev(sb->s_bdev->bd_dev))
449                 return -EOVERFLOW;
450
451         sbi = kzalloc(sizeof (struct jfs_sb_info), GFP_KERNEL);
452         if (!sbi)
453                 return -ENOMEM;
454         sb->s_fs_info = sbi;
455         sbi->sb = sb;
456         sbi->uid = sbi->gid = sbi->umask = -1;
457
458         /* initialize the mount flag and determine the default error handler */
459         flag = JFS_ERR_REMOUNT_RO;
460
461         if (!parse_options((char *) data, sb, &newLVSize, &flag))
462                 goto out_kfree;
463         sbi->flag = flag;
464
465 #ifdef CONFIG_JFS_POSIX_ACL
466         sb->s_flags |= MS_POSIXACL;
467 #endif
468
469         if (newLVSize) {
470                 printk(KERN_ERR "resize option for remount only\n");
471                 goto out_kfree;
472         }
473
474         /*
475          * Initialize blocksize to 4K.
476          */
477         sb_set_blocksize(sb, PSIZE);
478
479         /*
480          * Set method vectors.
481          */
482         sb->s_op = &jfs_super_operations;
483         sb->s_export_op = &jfs_export_operations;
484
485         /*
486          * Initialize direct-mapping inode/address-space
487          */
488         inode = new_inode(sb);
489         if (inode == NULL) {
490                 ret = -ENOMEM;
491                 goto out_unload;
492         }
493         inode->i_ino = 0;
494         inode->i_nlink = 1;
495         inode->i_size = sb->s_bdev->bd_inode->i_size;
496         inode->i_mapping->a_ops = &jfs_metapage_aops;
497         insert_inode_hash(inode);
498         mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
499
500         sbi->direct_inode = inode;
501
502         rc = jfs_mount(sb);
503         if (rc) {
504                 if (!silent) {
505                         jfs_err("jfs_mount failed w/return code = %d", rc);
506                 }
507                 goto out_mount_failed;
508         }
509         if (sb->s_flags & MS_RDONLY)
510                 sbi->log = NULL;
511         else {
512                 rc = jfs_mount_rw(sb, 0);
513                 if (rc) {
514                         if (!silent) {
515                                 jfs_err("jfs_mount_rw failed, return code = %d",
516                                         rc);
517                         }
518                         goto out_no_rw;
519                 }
520         }
521
522         sb->s_magic = JFS_SUPER_MAGIC;
523
524         inode = jfs_iget(sb, ROOT_I);
525         if (IS_ERR(inode)) {
526                 ret = PTR_ERR(inode);
527                 goto out_no_rw;
528         }
529         sb->s_root = d_alloc_root(inode);
530         if (!sb->s_root)
531                 goto out_no_root;
532
533         if (sbi->mntflag & JFS_OS2)
534                 sb->s_root->d_op = &jfs_ci_dentry_operations;
535
536         /* logical blocks are represented by 40 bits in pxd_t, etc. */
537         sb->s_maxbytes = ((u64) sb->s_blocksize) << 40;
538 #if BITS_PER_LONG == 32
539         /*
540          * Page cache is indexed by long.
541          * I would use MAX_LFS_FILESIZE, but it's only half as big
542          */
543         sb->s_maxbytes = min(((u64) PAGE_CACHE_SIZE << 32) - 1, (u64)sb->s_maxbytes);
544 #endif
545         sb->s_time_gran = 1;
546         return 0;
547
548 out_no_root:
549         jfs_err("jfs_read_super: get root dentry failed");
550         iput(inode);
551
552 out_no_rw:
553         rc = jfs_umount(sb);
554         if (rc) {
555                 jfs_err("jfs_umount failed with return code %d", rc);
556         }
557 out_mount_failed:
558         filemap_write_and_wait(sbi->direct_inode->i_mapping);
559         truncate_inode_pages(sbi->direct_inode->i_mapping, 0);
560         make_bad_inode(sbi->direct_inode);
561         iput(sbi->direct_inode);
562         sbi->direct_inode = NULL;
563 out_unload:
564         if (sbi->nls_tab)
565                 unload_nls(sbi->nls_tab);
566 out_kfree:
567         kfree(sbi);
568         return ret;
569 }
570
571 static int jfs_freeze(struct super_block *sb)
572 {
573         struct jfs_sb_info *sbi = JFS_SBI(sb);
574         struct jfs_log *log = sbi->log;
575
576         if (!(sb->s_flags & MS_RDONLY)) {
577                 txQuiesce(sb);
578                 lmLogShutdown(log);
579                 updateSuper(sb, FM_CLEAN);
580         }
581         return 0;
582 }
583
584 static int jfs_unfreeze(struct super_block *sb)
585 {
586         struct jfs_sb_info *sbi = JFS_SBI(sb);
587         struct jfs_log *log = sbi->log;
588         int rc = 0;
589
590         if (!(sb->s_flags & MS_RDONLY)) {
591                 updateSuper(sb, FM_MOUNT);
592                 if ((rc = lmLogInit(log)))
593                         jfs_err("jfs_unlock failed with return code %d", rc);
594                 else
595                         txResume(sb);
596         }
597         return 0;
598 }
599
600 static int jfs_get_sb(struct file_system_type *fs_type,
601         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
602 {
603         return get_sb_bdev(fs_type, flags, dev_name, data, jfs_fill_super,
604                            mnt);
605 }
606
607 static int jfs_sync_fs(struct super_block *sb, int wait)
608 {
609         struct jfs_log *log = JFS_SBI(sb)->log;
610
611         /* log == NULL indicates read-only mount */
612         if (log) {
613                 jfs_flush_journal(log, wait);
614                 jfs_syncpt(log, 0);
615         }
616
617         return 0;
618 }
619
620 static int jfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
621 {
622         struct jfs_sb_info *sbi = JFS_SBI(vfs->mnt_sb);
623
624         if (sbi->uid != -1)
625                 seq_printf(seq, ",uid=%d", sbi->uid);
626         if (sbi->gid != -1)
627                 seq_printf(seq, ",gid=%d", sbi->gid);
628         if (sbi->umask != -1)
629                 seq_printf(seq, ",umask=%03o", sbi->umask);
630         if (sbi->flag & JFS_NOINTEGRITY)
631                 seq_puts(seq, ",nointegrity");
632         if (sbi->nls_tab)
633                 seq_printf(seq, ",iocharset=%s", sbi->nls_tab->charset);
634         if (sbi->flag & JFS_ERR_CONTINUE)
635                 seq_printf(seq, ",errors=continue");
636         if (sbi->flag & JFS_ERR_PANIC)
637                 seq_printf(seq, ",errors=panic");
638
639 #ifdef CONFIG_QUOTA
640         if (sbi->flag & JFS_USRQUOTA)
641                 seq_puts(seq, ",usrquota");
642
643         if (sbi->flag & JFS_GRPQUOTA)
644                 seq_puts(seq, ",grpquota");
645 #endif
646
647         return 0;
648 }
649
650 #ifdef CONFIG_QUOTA
651
652 /* Read data from quotafile - avoid pagecache and such because we cannot afford
653  * acquiring the locks... As quota files are never truncated and quota code
654  * itself serializes the operations (and noone else should touch the files)
655  * we don't have to be afraid of races */
656 static ssize_t jfs_quota_read(struct super_block *sb, int type, char *data,
657                               size_t len, loff_t off)
658 {
659         struct inode *inode = sb_dqopt(sb)->files[type];
660         sector_t blk = off >> sb->s_blocksize_bits;
661         int err = 0;
662         int offset = off & (sb->s_blocksize - 1);
663         int tocopy;
664         size_t toread;
665         struct buffer_head tmp_bh;
666         struct buffer_head *bh;
667         loff_t i_size = i_size_read(inode);
668
669         if (off > i_size)
670                 return 0;
671         if (off+len > i_size)
672                 len = i_size-off;
673         toread = len;
674         while (toread > 0) {
675                 tocopy = sb->s_blocksize - offset < toread ?
676                                 sb->s_blocksize - offset : toread;
677
678                 tmp_bh.b_state = 0;
679                 tmp_bh.b_size = 1 << inode->i_blkbits;
680                 err = jfs_get_block(inode, blk, &tmp_bh, 0);
681                 if (err)
682                         return err;
683                 if (!buffer_mapped(&tmp_bh))    /* A hole? */
684                         memset(data, 0, tocopy);
685                 else {
686                         bh = sb_bread(sb, tmp_bh.b_blocknr);
687                         if (!bh)
688                                 return -EIO;
689                         memcpy(data, bh->b_data+offset, tocopy);
690                         brelse(bh);
691                 }
692                 offset = 0;
693                 toread -= tocopy;
694                 data += tocopy;
695                 blk++;
696         }
697         return len;
698 }
699
700 /* Write to quotafile */
701 static ssize_t jfs_quota_write(struct super_block *sb, int type,
702                                const char *data, size_t len, loff_t off)
703 {
704         struct inode *inode = sb_dqopt(sb)->files[type];
705         sector_t blk = off >> sb->s_blocksize_bits;
706         int err = 0;
707         int offset = off & (sb->s_blocksize - 1);
708         int tocopy;
709         size_t towrite = len;
710         struct buffer_head tmp_bh;
711         struct buffer_head *bh;
712
713         mutex_lock(&inode->i_mutex);
714         while (towrite > 0) {
715                 tocopy = sb->s_blocksize - offset < towrite ?
716                                 sb->s_blocksize - offset : towrite;
717
718                 tmp_bh.b_state = 0;
719                 tmp_bh.b_size = 1 << inode->i_blkbits;
720                 err = jfs_get_block(inode, blk, &tmp_bh, 1);
721                 if (err)
722                         goto out;
723                 if (offset || tocopy != sb->s_blocksize)
724                         bh = sb_bread(sb, tmp_bh.b_blocknr);
725                 else
726                         bh = sb_getblk(sb, tmp_bh.b_blocknr);
727                 if (!bh) {
728                         err = -EIO;
729                         goto out;
730                 }
731                 lock_buffer(bh);
732                 memcpy(bh->b_data+offset, data, tocopy);
733                 flush_dcache_page(bh->b_page);
734                 set_buffer_uptodate(bh);
735                 mark_buffer_dirty(bh);
736                 unlock_buffer(bh);
737                 brelse(bh);
738                 offset = 0;
739                 towrite -= tocopy;
740                 data += tocopy;
741                 blk++;
742         }
743 out:
744         if (len == towrite) {
745                 mutex_unlock(&inode->i_mutex);
746                 return err;
747         }
748         if (inode->i_size < off+len-towrite)
749                 i_size_write(inode, off+len-towrite);
750         inode->i_version++;
751         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
752         mark_inode_dirty(inode);
753         mutex_unlock(&inode->i_mutex);
754         return len - towrite;
755 }
756
757 #endif
758
759 static const struct super_operations jfs_super_operations = {
760         .alloc_inode    = jfs_alloc_inode,
761         .destroy_inode  = jfs_destroy_inode,
762         .dirty_inode    = jfs_dirty_inode,
763         .write_inode    = jfs_write_inode,
764         .delete_inode   = jfs_delete_inode,
765         .clear_inode    = jfs_clear_inode,
766         .put_super      = jfs_put_super,
767         .sync_fs        = jfs_sync_fs,
768         .freeze_fs      = jfs_freeze,
769         .unfreeze_fs    = jfs_unfreeze,
770         .statfs         = jfs_statfs,
771         .remount_fs     = jfs_remount,
772         .show_options   = jfs_show_options,
773 #ifdef CONFIG_QUOTA
774         .quota_read     = jfs_quota_read,
775         .quota_write    = jfs_quota_write,
776 #endif
777 };
778
779 static const struct export_operations jfs_export_operations = {
780         .fh_to_dentry   = jfs_fh_to_dentry,
781         .fh_to_parent   = jfs_fh_to_parent,
782         .get_parent     = jfs_get_parent,
783 };
784
785 static struct file_system_type jfs_fs_type = {
786         .owner          = THIS_MODULE,
787         .name           = "jfs",
788         .get_sb         = jfs_get_sb,
789         .kill_sb        = kill_block_super,
790         .fs_flags       = FS_REQUIRES_DEV,
791 };
792
793 static void init_once(void *foo)
794 {
795         struct jfs_inode_info *jfs_ip = (struct jfs_inode_info *) foo;
796
797         memset(jfs_ip, 0, sizeof(struct jfs_inode_info));
798         INIT_LIST_HEAD(&jfs_ip->anon_inode_list);
799         init_rwsem(&jfs_ip->rdwrlock);
800         mutex_init(&jfs_ip->commit_mutex);
801         init_rwsem(&jfs_ip->xattr_sem);
802         spin_lock_init(&jfs_ip->ag_lock);
803         jfs_ip->active_ag = -1;
804         inode_init_once(&jfs_ip->vfs_inode);
805 }
806
807 static int __init init_jfs_fs(void)
808 {
809         int i;
810         int rc;
811
812         jfs_inode_cachep =
813             kmem_cache_create("jfs_ip", sizeof(struct jfs_inode_info), 0,
814                             SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
815                             init_once);
816         if (jfs_inode_cachep == NULL)
817                 return -ENOMEM;
818
819         /*
820          * Metapage initialization
821          */
822         rc = metapage_init();
823         if (rc) {
824                 jfs_err("metapage_init failed w/rc = %d", rc);
825                 goto free_slab;
826         }
827
828         /*
829          * Transaction Manager initialization
830          */
831         rc = txInit();
832         if (rc) {
833                 jfs_err("txInit failed w/rc = %d", rc);
834                 goto free_metapage;
835         }
836
837         /*
838          * I/O completion thread (endio)
839          */
840         jfsIOthread = kthread_run(jfsIOWait, NULL, "jfsIO");
841         if (IS_ERR(jfsIOthread)) {
842                 rc = PTR_ERR(jfsIOthread);
843                 jfs_err("init_jfs_fs: fork failed w/rc = %d", rc);
844                 goto end_txmngr;
845         }
846
847         if (commit_threads < 1)
848                 commit_threads = num_online_cpus();
849         if (commit_threads > MAX_COMMIT_THREADS)
850                 commit_threads = MAX_COMMIT_THREADS;
851
852         for (i = 0; i < commit_threads; i++) {
853                 jfsCommitThread[i] = kthread_run(jfs_lazycommit, NULL, "jfsCommit");
854                 if (IS_ERR(jfsCommitThread[i])) {
855                         rc = PTR_ERR(jfsCommitThread[i]);
856                         jfs_err("init_jfs_fs: fork failed w/rc = %d", rc);
857                         commit_threads = i;
858                         goto kill_committask;
859                 }
860         }
861
862         jfsSyncThread = kthread_run(jfs_sync, NULL, "jfsSync");
863         if (IS_ERR(jfsSyncThread)) {
864                 rc = PTR_ERR(jfsSyncThread);
865                 jfs_err("init_jfs_fs: fork failed w/rc = %d", rc);
866                 goto kill_committask;
867         }
868
869 #ifdef PROC_FS_JFS
870         jfs_proc_init();
871 #endif
872
873         return register_filesystem(&jfs_fs_type);
874
875 kill_committask:
876         for (i = 0; i < commit_threads; i++)
877                 kthread_stop(jfsCommitThread[i]);
878         kthread_stop(jfsIOthread);
879 end_txmngr:
880         txExit();
881 free_metapage:
882         metapage_exit();
883 free_slab:
884         kmem_cache_destroy(jfs_inode_cachep);
885         return rc;
886 }
887
888 static void __exit exit_jfs_fs(void)
889 {
890         int i;
891
892         jfs_info("exit_jfs_fs called");
893
894         txExit();
895         metapage_exit();
896
897         kthread_stop(jfsIOthread);
898         for (i = 0; i < commit_threads; i++)
899                 kthread_stop(jfsCommitThread[i]);
900         kthread_stop(jfsSyncThread);
901 #ifdef PROC_FS_JFS
902         jfs_proc_clean();
903 #endif
904         unregister_filesystem(&jfs_fs_type);
905         kmem_cache_destroy(jfs_inode_cachep);
906 }
907
908 module_init(init_jfs_fs)
909 module_exit(exit_jfs_fs)