sbshc: acpi_device_class "smbus_host_controller" too long
[linux-2.6.git] / fs / nilfs2 / super.c
1 /*
2  * super.c - NILFS module and super block management.
3  *
4  * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  * Written by Ryusuke Konishi <ryusuke@osrg.net>
21  */
22 /*
23  *  linux/fs/ext2/super.c
24  *
25  * Copyright (C) 1992, 1993, 1994, 1995
26  * Remy Card (card@masi.ibp.fr)
27  * Laboratoire MASI - Institut Blaise Pascal
28  * Universite Pierre et Marie Curie (Paris VI)
29  *
30  *  from
31  *
32  *  linux/fs/minix/inode.c
33  *
34  *  Copyright (C) 1991, 1992  Linus Torvalds
35  *
36  *  Big-endian to little-endian byte-swapping/bitmaps by
37  *        David S. Miller (davem@caip.rutgers.edu), 1995
38  */
39
40 #include <linux/module.h>
41 #include <linux/string.h>
42 #include <linux/slab.h>
43 #include <linux/init.h>
44 #include <linux/blkdev.h>
45 #include <linux/parser.h>
46 #include <linux/random.h>
47 #include <linux/crc32.h>
48 #include <linux/smp_lock.h>
49 #include <linux/vfs.h>
50 #include <linux/writeback.h>
51 #include <linux/kobject.h>
52 #include <linux/exportfs.h>
53 #include <linux/seq_file.h>
54 #include <linux/mount.h>
55 #include "nilfs.h"
56 #include "mdt.h"
57 #include "alloc.h"
58 #include "page.h"
59 #include "cpfile.h"
60 #include "ifile.h"
61 #include "dat.h"
62 #include "segment.h"
63 #include "segbuf.h"
64
65 MODULE_AUTHOR("NTT Corp.");
66 MODULE_DESCRIPTION("A New Implementation of the Log-structured Filesystem "
67                    "(NILFS)");
68 MODULE_LICENSE("GPL");
69
70 static int nilfs_remount(struct super_block *sb, int *flags, char *data);
71
72 /**
73  * nilfs_error() - report failure condition on a filesystem
74  *
75  * nilfs_error() sets an ERROR_FS flag on the superblock as well as
76  * reporting an error message.  It should be called when NILFS detects
77  * incoherences or defects of meta data on disk.  As for sustainable
78  * errors such as a single-shot I/O error, nilfs_warning() or the printk()
79  * function should be used instead.
80  *
81  * The segment constructor must not call this function because it can
82  * kill itself.
83  */
84 void nilfs_error(struct super_block *sb, const char *function,
85                  const char *fmt, ...)
86 {
87         struct nilfs_sb_info *sbi = NILFS_SB(sb);
88         va_list args;
89
90         va_start(args, fmt);
91         printk(KERN_CRIT "NILFS error (device %s): %s: ", sb->s_id, function);
92         vprintk(fmt, args);
93         printk("\n");
94         va_end(args);
95
96         if (!(sb->s_flags & MS_RDONLY)) {
97                 struct the_nilfs *nilfs = sbi->s_nilfs;
98
99                 down_write(&nilfs->ns_sem);
100                 if (!(nilfs->ns_mount_state & NILFS_ERROR_FS)) {
101                         nilfs->ns_mount_state |= NILFS_ERROR_FS;
102                         nilfs->ns_sbp[0]->s_state |=
103                                 cpu_to_le16(NILFS_ERROR_FS);
104                         nilfs_commit_super(sbi, 1);
105                 }
106                 up_write(&nilfs->ns_sem);
107
108                 if (nilfs_test_opt(sbi, ERRORS_RO)) {
109                         printk(KERN_CRIT "Remounting filesystem read-only\n");
110                         sb->s_flags |= MS_RDONLY;
111                 }
112         }
113
114         if (nilfs_test_opt(sbi, ERRORS_PANIC))
115                 panic("NILFS (device %s): panic forced after error\n",
116                       sb->s_id);
117 }
118
119 void nilfs_warning(struct super_block *sb, const char *function,
120                    const char *fmt, ...)
121 {
122         va_list args;
123
124         va_start(args, fmt);
125         printk(KERN_WARNING "NILFS warning (device %s): %s: ",
126                sb->s_id, function);
127         vprintk(fmt, args);
128         printk("\n");
129         va_end(args);
130 }
131
132 static struct kmem_cache *nilfs_inode_cachep;
133
134 struct inode *nilfs_alloc_inode_common(struct the_nilfs *nilfs)
135 {
136         struct nilfs_inode_info *ii;
137
138         ii = kmem_cache_alloc(nilfs_inode_cachep, GFP_NOFS);
139         if (!ii)
140                 return NULL;
141         ii->i_bh = NULL;
142         ii->i_state = 0;
143         ii->vfs_inode.i_version = 1;
144         nilfs_btnode_cache_init(&ii->i_btnode_cache, nilfs->ns_bdi);
145         return &ii->vfs_inode;
146 }
147
148 struct inode *nilfs_alloc_inode(struct super_block *sb)
149 {
150         return nilfs_alloc_inode_common(NILFS_SB(sb)->s_nilfs);
151 }
152
153 void nilfs_destroy_inode(struct inode *inode)
154 {
155         kmem_cache_free(nilfs_inode_cachep, NILFS_I(inode));
156 }
157
158 static void init_once(void *obj)
159 {
160         struct nilfs_inode_info *ii = obj;
161
162         INIT_LIST_HEAD(&ii->i_dirty);
163 #ifdef CONFIG_NILFS_XATTR
164         init_rwsem(&ii->xattr_sem);
165 #endif
166         nilfs_btnode_cache_init_once(&ii->i_btnode_cache);
167         ii->i_bmap = (struct nilfs_bmap *)&ii->i_bmap_union;
168         inode_init_once(&ii->vfs_inode);
169 }
170
171 static int nilfs_init_inode_cache(void)
172 {
173         nilfs_inode_cachep = kmem_cache_create("nilfs2_inode_cache",
174                                                sizeof(struct nilfs_inode_info),
175                                                0, SLAB_RECLAIM_ACCOUNT,
176                                                init_once);
177
178         return (nilfs_inode_cachep == NULL) ? -ENOMEM : 0;
179 }
180
181 static inline void nilfs_destroy_inode_cache(void)
182 {
183         kmem_cache_destroy(nilfs_inode_cachep);
184 }
185
186 static void nilfs_clear_inode(struct inode *inode)
187 {
188         struct nilfs_inode_info *ii = NILFS_I(inode);
189
190         /*
191          * Free resources allocated in nilfs_read_inode(), here.
192          */
193         BUG_ON(!list_empty(&ii->i_dirty));
194         brelse(ii->i_bh);
195         ii->i_bh = NULL;
196
197         if (test_bit(NILFS_I_BMAP, &ii->i_state))
198                 nilfs_bmap_clear(ii->i_bmap);
199
200         nilfs_btnode_cache_clear(&ii->i_btnode_cache);
201 }
202
203 static int nilfs_sync_super(struct nilfs_sb_info *sbi, int dupsb)
204 {
205         struct the_nilfs *nilfs = sbi->s_nilfs;
206         int err;
207         int barrier_done = 0;
208
209         if (nilfs_test_opt(sbi, BARRIER)) {
210                 set_buffer_ordered(nilfs->ns_sbh[0]);
211                 barrier_done = 1;
212         }
213  retry:
214         set_buffer_dirty(nilfs->ns_sbh[0]);
215         err = sync_dirty_buffer(nilfs->ns_sbh[0]);
216         if (err == -EOPNOTSUPP && barrier_done) {
217                 nilfs_warning(sbi->s_super, __func__,
218                               "barrier-based sync failed. "
219                               "disabling barriers\n");
220                 nilfs_clear_opt(sbi, BARRIER);
221                 barrier_done = 0;
222                 clear_buffer_ordered(nilfs->ns_sbh[0]);
223                 goto retry;
224         }
225         if (unlikely(err)) {
226                 printk(KERN_ERR
227                        "NILFS: unable to write superblock (err=%d)\n", err);
228                 if (err == -EIO && nilfs->ns_sbh[1]) {
229                         nilfs_fall_back_super_block(nilfs);
230                         goto retry;
231                 }
232         } else {
233                 struct nilfs_super_block *sbp = nilfs->ns_sbp[0];
234
235                 /*
236                  * The latest segment becomes trailable from the position
237                  * written in superblock.
238                  */
239                 clear_nilfs_discontinued(nilfs);
240
241                 /* update GC protection for recent segments */
242                 if (nilfs->ns_sbh[1]) {
243                         sbp = NULL;
244                         if (dupsb) {
245                                 set_buffer_dirty(nilfs->ns_sbh[1]);
246                                 if (!sync_dirty_buffer(nilfs->ns_sbh[1]))
247                                         sbp = nilfs->ns_sbp[1];
248                         }
249                 }
250                 if (sbp) {
251                         spin_lock(&nilfs->ns_last_segment_lock);
252                         nilfs->ns_prot_seq = le64_to_cpu(sbp->s_last_seq);
253                         spin_unlock(&nilfs->ns_last_segment_lock);
254                 }
255         }
256
257         return err;
258 }
259
260 int nilfs_commit_super(struct nilfs_sb_info *sbi, int dupsb)
261 {
262         struct the_nilfs *nilfs = sbi->s_nilfs;
263         struct nilfs_super_block **sbp = nilfs->ns_sbp;
264         sector_t nfreeblocks;
265         time_t t;
266         int err;
267
268         /* nilfs->sem must be locked by the caller. */
269         if (sbp[0]->s_magic != NILFS_SUPER_MAGIC) {
270                 if (sbp[1] && sbp[1]->s_magic == NILFS_SUPER_MAGIC)
271                         nilfs_swap_super_block(nilfs);
272                 else {
273                         printk(KERN_CRIT "NILFS: superblock broke on dev %s\n",
274                                sbi->s_super->s_id);
275                         return -EIO;
276                 }
277         }
278         err = nilfs_count_free_blocks(nilfs, &nfreeblocks);
279         if (unlikely(err)) {
280                 printk(KERN_ERR "NILFS: failed to count free blocks\n");
281                 return err;
282         }
283         spin_lock(&nilfs->ns_last_segment_lock);
284         sbp[0]->s_last_seq = cpu_to_le64(nilfs->ns_last_seq);
285         sbp[0]->s_last_pseg = cpu_to_le64(nilfs->ns_last_pseg);
286         sbp[0]->s_last_cno = cpu_to_le64(nilfs->ns_last_cno);
287         spin_unlock(&nilfs->ns_last_segment_lock);
288
289         t = get_seconds();
290         nilfs->ns_sbwtime[0] = t;
291         sbp[0]->s_free_blocks_count = cpu_to_le64(nfreeblocks);
292         sbp[0]->s_wtime = cpu_to_le64(t);
293         sbp[0]->s_sum = 0;
294         sbp[0]->s_sum = cpu_to_le32(crc32_le(nilfs->ns_crc_seed,
295                                              (unsigned char *)sbp[0],
296                                              nilfs->ns_sbsize));
297         if (dupsb && sbp[1]) {
298                 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize);
299                 nilfs->ns_sbwtime[1] = t;
300         }
301         clear_nilfs_sb_dirty(nilfs);
302         return nilfs_sync_super(sbi, dupsb);
303 }
304
305 static void nilfs_put_super(struct super_block *sb)
306 {
307         struct nilfs_sb_info *sbi = NILFS_SB(sb);
308         struct the_nilfs *nilfs = sbi->s_nilfs;
309
310         lock_kernel();
311
312         nilfs_detach_segment_constructor(sbi);
313
314         if (!(sb->s_flags & MS_RDONLY)) {
315                 down_write(&nilfs->ns_sem);
316                 nilfs->ns_sbp[0]->s_state = cpu_to_le16(nilfs->ns_mount_state);
317                 nilfs_commit_super(sbi, 1);
318                 up_write(&nilfs->ns_sem);
319         }
320         down_write(&nilfs->ns_super_sem);
321         if (nilfs->ns_current == sbi)
322                 nilfs->ns_current = NULL;
323         up_write(&nilfs->ns_super_sem);
324
325         nilfs_detach_checkpoint(sbi);
326         put_nilfs(sbi->s_nilfs);
327         sbi->s_super = NULL;
328         sb->s_fs_info = NULL;
329         nilfs_put_sbinfo(sbi);
330
331         unlock_kernel();
332 }
333
334 static int nilfs_sync_fs(struct super_block *sb, int wait)
335 {
336         struct nilfs_sb_info *sbi = NILFS_SB(sb);
337         struct the_nilfs *nilfs = sbi->s_nilfs;
338         int err = 0;
339
340         /* This function is called when super block should be written back */
341         if (wait)
342                 err = nilfs_construct_segment(sb);
343
344         down_write(&nilfs->ns_sem);
345         if (nilfs_sb_dirty(nilfs))
346                 nilfs_commit_super(sbi, 1);
347         up_write(&nilfs->ns_sem);
348
349         return err;
350 }
351
352 int nilfs_attach_checkpoint(struct nilfs_sb_info *sbi, __u64 cno)
353 {
354         struct the_nilfs *nilfs = sbi->s_nilfs;
355         struct nilfs_checkpoint *raw_cp;
356         struct buffer_head *bh_cp;
357         int err;
358
359         down_write(&nilfs->ns_super_sem);
360         list_add(&sbi->s_list, &nilfs->ns_supers);
361         up_write(&nilfs->ns_super_sem);
362
363         sbi->s_ifile = nilfs_ifile_new(sbi, nilfs->ns_inode_size);
364         if (!sbi->s_ifile)
365                 return -ENOMEM;
366
367         down_read(&nilfs->ns_segctor_sem);
368         err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, cno, 0, &raw_cp,
369                                           &bh_cp);
370         up_read(&nilfs->ns_segctor_sem);
371         if (unlikely(err)) {
372                 if (err == -ENOENT || err == -EINVAL) {
373                         printk(KERN_ERR
374                                "NILFS: Invalid checkpoint "
375                                "(checkpoint number=%llu)\n",
376                                (unsigned long long)cno);
377                         err = -EINVAL;
378                 }
379                 goto failed;
380         }
381         err = nilfs_read_inode_common(sbi->s_ifile, &raw_cp->cp_ifile_inode);
382         if (unlikely(err))
383                 goto failed_bh;
384         atomic_set(&sbi->s_inodes_count, le64_to_cpu(raw_cp->cp_inodes_count));
385         atomic_set(&sbi->s_blocks_count, le64_to_cpu(raw_cp->cp_blocks_count));
386
387         nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp);
388         return 0;
389
390  failed_bh:
391         nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp);
392  failed:
393         nilfs_mdt_destroy(sbi->s_ifile);
394         sbi->s_ifile = NULL;
395
396         down_write(&nilfs->ns_super_sem);
397         list_del_init(&sbi->s_list);
398         up_write(&nilfs->ns_super_sem);
399
400         return err;
401 }
402
403 void nilfs_detach_checkpoint(struct nilfs_sb_info *sbi)
404 {
405         struct the_nilfs *nilfs = sbi->s_nilfs;
406
407         nilfs_mdt_destroy(sbi->s_ifile);
408         sbi->s_ifile = NULL;
409         down_write(&nilfs->ns_super_sem);
410         list_del_init(&sbi->s_list);
411         up_write(&nilfs->ns_super_sem);
412 }
413
414 static int nilfs_statfs(struct dentry *dentry, struct kstatfs *buf)
415 {
416         struct super_block *sb = dentry->d_sb;
417         struct nilfs_sb_info *sbi = NILFS_SB(sb);
418         struct the_nilfs *nilfs = sbi->s_nilfs;
419         u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
420         unsigned long long blocks;
421         unsigned long overhead;
422         unsigned long nrsvblocks;
423         sector_t nfreeblocks;
424         int err;
425
426         /*
427          * Compute all of the segment blocks
428          *
429          * The blocks before first segment and after last segment
430          * are excluded.
431          */
432         blocks = nilfs->ns_blocks_per_segment * nilfs->ns_nsegments
433                 - nilfs->ns_first_data_block;
434         nrsvblocks = nilfs->ns_nrsvsegs * nilfs->ns_blocks_per_segment;
435
436         /*
437          * Compute the overhead
438          *
439          * When distributing meta data blocks outside segment structure,
440          * We must count them as the overhead.
441          */
442         overhead = 0;
443
444         err = nilfs_count_free_blocks(nilfs, &nfreeblocks);
445         if (unlikely(err))
446                 return err;
447
448         buf->f_type = NILFS_SUPER_MAGIC;
449         buf->f_bsize = sb->s_blocksize;
450         buf->f_blocks = blocks - overhead;
451         buf->f_bfree = nfreeblocks;
452         buf->f_bavail = (buf->f_bfree >= nrsvblocks) ?
453                 (buf->f_bfree - nrsvblocks) : 0;
454         buf->f_files = atomic_read(&sbi->s_inodes_count);
455         buf->f_ffree = 0; /* nilfs_count_free_inodes(sb); */
456         buf->f_namelen = NILFS_NAME_LEN;
457         buf->f_fsid.val[0] = (u32)id;
458         buf->f_fsid.val[1] = (u32)(id >> 32);
459
460         return 0;
461 }
462
463 static int nilfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
464 {
465         struct super_block *sb = vfs->mnt_sb;
466         struct nilfs_sb_info *sbi = NILFS_SB(sb);
467
468         if (!nilfs_test_opt(sbi, BARRIER))
469                 seq_printf(seq, ",nobarrier");
470         if (nilfs_test_opt(sbi, SNAPSHOT))
471                 seq_printf(seq, ",cp=%llu",
472                            (unsigned long long int)sbi->s_snapshot_cno);
473         if (nilfs_test_opt(sbi, ERRORS_RO))
474                 seq_printf(seq, ",errors=remount-ro");
475         if (nilfs_test_opt(sbi, ERRORS_PANIC))
476                 seq_printf(seq, ",errors=panic");
477         if (nilfs_test_opt(sbi, STRICT_ORDER))
478                 seq_printf(seq, ",order=strict");
479         if (nilfs_test_opt(sbi, NORECOVERY))
480                 seq_printf(seq, ",norecovery");
481         if (nilfs_test_opt(sbi, DISCARD))
482                 seq_printf(seq, ",discard");
483
484         return 0;
485 }
486
487 static const struct super_operations nilfs_sops = {
488         .alloc_inode    = nilfs_alloc_inode,
489         .destroy_inode  = nilfs_destroy_inode,
490         .dirty_inode    = nilfs_dirty_inode,
491         /* .write_inode    = nilfs_write_inode, */
492         /* .put_inode      = nilfs_put_inode, */
493         /* .drop_inode    = nilfs_drop_inode, */
494         .delete_inode   = nilfs_delete_inode,
495         .put_super      = nilfs_put_super,
496         /* .write_super    = nilfs_write_super, */
497         .sync_fs        = nilfs_sync_fs,
498         /* .write_super_lockfs */
499         /* .unlockfs */
500         .statfs         = nilfs_statfs,
501         .remount_fs     = nilfs_remount,
502         .clear_inode    = nilfs_clear_inode,
503         /* .umount_begin */
504         .show_options = nilfs_show_options
505 };
506
507 static struct inode *
508 nilfs_nfs_get_inode(struct super_block *sb, u64 ino, u32 generation)
509 {
510         struct inode *inode;
511
512         if (ino < NILFS_FIRST_INO(sb) && ino != NILFS_ROOT_INO &&
513             ino != NILFS_SKETCH_INO)
514                 return ERR_PTR(-ESTALE);
515
516         inode = nilfs_iget(sb, ino);
517         if (IS_ERR(inode))
518                 return ERR_CAST(inode);
519         if (generation && inode->i_generation != generation) {
520                 iput(inode);
521                 return ERR_PTR(-ESTALE);
522         }
523
524         return inode;
525 }
526
527 static struct dentry *
528 nilfs_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len,
529                    int fh_type)
530 {
531         return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
532                                     nilfs_nfs_get_inode);
533 }
534
535 static struct dentry *
536 nilfs_fh_to_parent(struct super_block *sb, struct fid *fid, int fh_len,
537                    int fh_type)
538 {
539         return generic_fh_to_parent(sb, fid, fh_len, fh_type,
540                                     nilfs_nfs_get_inode);
541 }
542
543 static const struct export_operations nilfs_export_ops = {
544         .fh_to_dentry = nilfs_fh_to_dentry,
545         .fh_to_parent = nilfs_fh_to_parent,
546         .get_parent = nilfs_get_parent,
547 };
548
549 enum {
550         Opt_err_cont, Opt_err_panic, Opt_err_ro,
551         Opt_nobarrier, Opt_snapshot, Opt_order, Opt_norecovery,
552         Opt_discard, Opt_err,
553 };
554
555 static match_table_t tokens = {
556         {Opt_err_cont, "errors=continue"},
557         {Opt_err_panic, "errors=panic"},
558         {Opt_err_ro, "errors=remount-ro"},
559         {Opt_nobarrier, "nobarrier"},
560         {Opt_snapshot, "cp=%u"},
561         {Opt_order, "order=%s"},
562         {Opt_norecovery, "norecovery"},
563         {Opt_discard, "discard"},
564         {Opt_err, NULL}
565 };
566
567 static int parse_options(char *options, struct super_block *sb)
568 {
569         struct nilfs_sb_info *sbi = NILFS_SB(sb);
570         char *p;
571         substring_t args[MAX_OPT_ARGS];
572         int option;
573
574         if (!options)
575                 return 1;
576
577         while ((p = strsep(&options, ",")) != NULL) {
578                 int token;
579                 if (!*p)
580                         continue;
581
582                 token = match_token(p, tokens, args);
583                 switch (token) {
584                 case Opt_nobarrier:
585                         nilfs_clear_opt(sbi, BARRIER);
586                         break;
587                 case Opt_order:
588                         if (strcmp(args[0].from, "relaxed") == 0)
589                                 /* Ordered data semantics */
590                                 nilfs_clear_opt(sbi, STRICT_ORDER);
591                         else if (strcmp(args[0].from, "strict") == 0)
592                                 /* Strict in-order semantics */
593                                 nilfs_set_opt(sbi, STRICT_ORDER);
594                         else
595                                 return 0;
596                         break;
597                 case Opt_err_panic:
598                         nilfs_write_opt(sbi, ERROR_MODE, ERRORS_PANIC);
599                         break;
600                 case Opt_err_ro:
601                         nilfs_write_opt(sbi, ERROR_MODE, ERRORS_RO);
602                         break;
603                 case Opt_err_cont:
604                         nilfs_write_opt(sbi, ERROR_MODE, ERRORS_CONT);
605                         break;
606                 case Opt_snapshot:
607                         if (match_int(&args[0], &option) || option <= 0)
608                                 return 0;
609                         if (!(sb->s_flags & MS_RDONLY))
610                                 return 0;
611                         sbi->s_snapshot_cno = option;
612                         nilfs_set_opt(sbi, SNAPSHOT);
613                         break;
614                 case Opt_norecovery:
615                         nilfs_set_opt(sbi, NORECOVERY);
616                         break;
617                 case Opt_discard:
618                         nilfs_set_opt(sbi, DISCARD);
619                         break;
620                 default:
621                         printk(KERN_ERR
622                                "NILFS: Unrecognized mount option \"%s\"\n", p);
623                         return 0;
624                 }
625         }
626         return 1;
627 }
628
629 static inline void
630 nilfs_set_default_options(struct nilfs_sb_info *sbi,
631                           struct nilfs_super_block *sbp)
632 {
633         sbi->s_mount_opt =
634                 NILFS_MOUNT_ERRORS_CONT | NILFS_MOUNT_BARRIER;
635 }
636
637 static int nilfs_setup_super(struct nilfs_sb_info *sbi)
638 {
639         struct the_nilfs *nilfs = sbi->s_nilfs;
640         struct nilfs_super_block *sbp = nilfs->ns_sbp[0];
641         int max_mnt_count = le16_to_cpu(sbp->s_max_mnt_count);
642         int mnt_count = le16_to_cpu(sbp->s_mnt_count);
643
644         /* nilfs->sem must be locked by the caller. */
645         if (nilfs->ns_mount_state & NILFS_ERROR_FS) {
646                 printk(KERN_WARNING
647                        "NILFS warning: mounting fs with errors\n");
648 #if 0
649         } else if (max_mnt_count >= 0 && mnt_count >= max_mnt_count) {
650                 printk(KERN_WARNING
651                        "NILFS warning: maximal mount count reached\n");
652 #endif
653         }
654         if (!max_mnt_count)
655                 sbp->s_max_mnt_count = cpu_to_le16(NILFS_DFL_MAX_MNT_COUNT);
656
657         sbp->s_mnt_count = cpu_to_le16(mnt_count + 1);
658         sbp->s_state = cpu_to_le16(le16_to_cpu(sbp->s_state) & ~NILFS_VALID_FS);
659         sbp->s_mtime = cpu_to_le64(get_seconds());
660         return nilfs_commit_super(sbi, 1);
661 }
662
663 struct nilfs_super_block *nilfs_read_super_block(struct super_block *sb,
664                                                  u64 pos, int blocksize,
665                                                  struct buffer_head **pbh)
666 {
667         unsigned long long sb_index = pos;
668         unsigned long offset;
669
670         offset = do_div(sb_index, blocksize);
671         *pbh = sb_bread(sb, sb_index);
672         if (!*pbh)
673                 return NULL;
674         return (struct nilfs_super_block *)((char *)(*pbh)->b_data + offset);
675 }
676
677 int nilfs_store_magic_and_option(struct super_block *sb,
678                                  struct nilfs_super_block *sbp,
679                                  char *data)
680 {
681         struct nilfs_sb_info *sbi = NILFS_SB(sb);
682
683         sb->s_magic = le16_to_cpu(sbp->s_magic);
684
685         /* FS independent flags */
686 #ifdef NILFS_ATIME_DISABLE
687         sb->s_flags |= MS_NOATIME;
688 #endif
689
690         nilfs_set_default_options(sbi, sbp);
691
692         sbi->s_resuid = le16_to_cpu(sbp->s_def_resuid);
693         sbi->s_resgid = le16_to_cpu(sbp->s_def_resgid);
694         sbi->s_interval = le32_to_cpu(sbp->s_c_interval);
695         sbi->s_watermark = le32_to_cpu(sbp->s_c_block_max);
696
697         return !parse_options(data, sb) ? -EINVAL : 0 ;
698 }
699
700 /**
701  * nilfs_fill_super() - initialize a super block instance
702  * @sb: super_block
703  * @data: mount options
704  * @silent: silent mode flag
705  * @nilfs: the_nilfs struct
706  *
707  * This function is called exclusively by nilfs->ns_mount_mutex.
708  * So, the recovery process is protected from other simultaneous mounts.
709  */
710 static int
711 nilfs_fill_super(struct super_block *sb, void *data, int silent,
712                  struct the_nilfs *nilfs)
713 {
714         struct nilfs_sb_info *sbi;
715         struct inode *root;
716         __u64 cno;
717         int err;
718
719         sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
720         if (!sbi)
721                 return -ENOMEM;
722
723         sb->s_fs_info = sbi;
724
725         get_nilfs(nilfs);
726         sbi->s_nilfs = nilfs;
727         sbi->s_super = sb;
728         atomic_set(&sbi->s_count, 1);
729
730         err = init_nilfs(nilfs, sbi, (char *)data);
731         if (err)
732                 goto failed_sbi;
733
734         spin_lock_init(&sbi->s_inode_lock);
735         INIT_LIST_HEAD(&sbi->s_dirty_files);
736         INIT_LIST_HEAD(&sbi->s_list);
737
738         /*
739          * Following initialization is overlapped because
740          * nilfs_sb_info structure has been cleared at the beginning.
741          * But we reserve them to keep our interest and make ready
742          * for the future change.
743          */
744         get_random_bytes(&sbi->s_next_generation,
745                          sizeof(sbi->s_next_generation));
746         spin_lock_init(&sbi->s_next_gen_lock);
747
748         sb->s_op = &nilfs_sops;
749         sb->s_export_op = &nilfs_export_ops;
750         sb->s_root = NULL;
751         sb->s_time_gran = 1;
752         sb->s_bdi = nilfs->ns_bdi;
753
754         err = load_nilfs(nilfs, sbi);
755         if (err)
756                 goto failed_sbi;
757
758         cno = nilfs_last_cno(nilfs);
759
760         if (sb->s_flags & MS_RDONLY) {
761                 if (nilfs_test_opt(sbi, SNAPSHOT)) {
762                         down_read(&nilfs->ns_segctor_sem);
763                         err = nilfs_cpfile_is_snapshot(nilfs->ns_cpfile,
764                                                        sbi->s_snapshot_cno);
765                         up_read(&nilfs->ns_segctor_sem);
766                         if (err < 0) {
767                                 if (err == -ENOENT)
768                                         err = -EINVAL;
769                                 goto failed_sbi;
770                         }
771                         if (!err) {
772                                 printk(KERN_ERR
773                                        "NILFS: The specified checkpoint is "
774                                        "not a snapshot "
775                                        "(checkpoint number=%llu).\n",
776                                        (unsigned long long)sbi->s_snapshot_cno);
777                                 err = -EINVAL;
778                                 goto failed_sbi;
779                         }
780                         cno = sbi->s_snapshot_cno;
781                 } else
782                         /* Read-only mount */
783                         sbi->s_snapshot_cno = cno;
784         }
785
786         err = nilfs_attach_checkpoint(sbi, cno);
787         if (err) {
788                 printk(KERN_ERR "NILFS: error loading a checkpoint"
789                        " (checkpoint number=%llu).\n", (unsigned long long)cno);
790                 goto failed_sbi;
791         }
792
793         if (!(sb->s_flags & MS_RDONLY)) {
794                 err = nilfs_attach_segment_constructor(sbi);
795                 if (err)
796                         goto failed_checkpoint;
797         }
798
799         root = nilfs_iget(sb, NILFS_ROOT_INO);
800         if (IS_ERR(root)) {
801                 printk(KERN_ERR "NILFS: get root inode failed\n");
802                 err = PTR_ERR(root);
803                 goto failed_segctor;
804         }
805         if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
806                 iput(root);
807                 printk(KERN_ERR "NILFS: corrupt root inode.\n");
808                 err = -EINVAL;
809                 goto failed_segctor;
810         }
811         sb->s_root = d_alloc_root(root);
812         if (!sb->s_root) {
813                 iput(root);
814                 printk(KERN_ERR "NILFS: get root dentry failed\n");
815                 err = -ENOMEM;
816                 goto failed_segctor;
817         }
818
819         if (!(sb->s_flags & MS_RDONLY)) {
820                 down_write(&nilfs->ns_sem);
821                 nilfs_setup_super(sbi);
822                 up_write(&nilfs->ns_sem);
823         }
824
825         down_write(&nilfs->ns_super_sem);
826         if (!nilfs_test_opt(sbi, SNAPSHOT))
827                 nilfs->ns_current = sbi;
828         up_write(&nilfs->ns_super_sem);
829
830         return 0;
831
832  failed_segctor:
833         nilfs_detach_segment_constructor(sbi);
834
835  failed_checkpoint:
836         nilfs_detach_checkpoint(sbi);
837
838  failed_sbi:
839         put_nilfs(nilfs);
840         sb->s_fs_info = NULL;
841         nilfs_put_sbinfo(sbi);
842         return err;
843 }
844
845 static int nilfs_remount(struct super_block *sb, int *flags, char *data)
846 {
847         struct nilfs_sb_info *sbi = NILFS_SB(sb);
848         struct nilfs_super_block *sbp;
849         struct the_nilfs *nilfs = sbi->s_nilfs;
850         unsigned long old_sb_flags;
851         struct nilfs_mount_options old_opts;
852         int err;
853
854         lock_kernel();
855
856         down_write(&nilfs->ns_super_sem);
857         old_sb_flags = sb->s_flags;
858         old_opts.mount_opt = sbi->s_mount_opt;
859         old_opts.snapshot_cno = sbi->s_snapshot_cno;
860
861         if (!parse_options(data, sb)) {
862                 err = -EINVAL;
863                 goto restore_opts;
864         }
865         sb->s_flags = (sb->s_flags & ~MS_POSIXACL);
866
867         if ((*flags & MS_RDONLY) &&
868             sbi->s_snapshot_cno != old_opts.snapshot_cno) {
869                 printk(KERN_WARNING "NILFS (device %s): couldn't "
870                        "remount to a different snapshot.\n",
871                        sb->s_id);
872                 err = -EINVAL;
873                 goto restore_opts;
874         }
875
876         if (!nilfs_valid_fs(nilfs)) {
877                 printk(KERN_WARNING "NILFS (device %s): couldn't "
878                        "remount because the filesystem is in an "
879                        "incomplete recovery state.\n", sb->s_id);
880                 err = -EINVAL;
881                 goto restore_opts;
882         }
883
884         if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
885                 goto out;
886         if (*flags & MS_RDONLY) {
887                 /* Shutting down the segment constructor */
888                 nilfs_detach_segment_constructor(sbi);
889                 sb->s_flags |= MS_RDONLY;
890
891                 sbi->s_snapshot_cno = nilfs_last_cno(nilfs);
892                 /* nilfs_set_opt(sbi, SNAPSHOT); */
893
894                 /*
895                  * Remounting a valid RW partition RDONLY, so set
896                  * the RDONLY flag and then mark the partition as valid again.
897                  */
898                 down_write(&nilfs->ns_sem);
899                 sbp = nilfs->ns_sbp[0];
900                 if (!(sbp->s_state & le16_to_cpu(NILFS_VALID_FS)) &&
901                     (nilfs->ns_mount_state & NILFS_VALID_FS))
902                         sbp->s_state = cpu_to_le16(nilfs->ns_mount_state);
903                 sbp->s_mtime = cpu_to_le64(get_seconds());
904                 nilfs_commit_super(sbi, 1);
905                 up_write(&nilfs->ns_sem);
906         } else {
907                 /*
908                  * Mounting a RDONLY partition read-write, so reread and
909                  * store the current valid flag.  (It may have been changed
910                  * by fsck since we originally mounted the partition.)
911                  */
912                 if (nilfs->ns_current && nilfs->ns_current != sbi) {
913                         printk(KERN_WARNING "NILFS (device %s): couldn't "
914                                "remount because an RW-mount exists.\n",
915                                sb->s_id);
916                         err = -EBUSY;
917                         goto restore_opts;
918                 }
919                 if (sbi->s_snapshot_cno != nilfs_last_cno(nilfs)) {
920                         printk(KERN_WARNING "NILFS (device %s): couldn't "
921                                "remount because the current RO-mount is not "
922                                "the latest one.\n",
923                                sb->s_id);
924                         err = -EINVAL;
925                         goto restore_opts;
926                 }
927                 sb->s_flags &= ~MS_RDONLY;
928                 nilfs_clear_opt(sbi, SNAPSHOT);
929                 sbi->s_snapshot_cno = 0;
930
931                 err = nilfs_attach_segment_constructor(sbi);
932                 if (err)
933                         goto restore_opts;
934
935                 down_write(&nilfs->ns_sem);
936                 nilfs_setup_super(sbi);
937                 up_write(&nilfs->ns_sem);
938
939                 nilfs->ns_current = sbi;
940         }
941  out:
942         up_write(&nilfs->ns_super_sem);
943         unlock_kernel();
944         return 0;
945
946  restore_opts:
947         sb->s_flags = old_sb_flags;
948         sbi->s_mount_opt = old_opts.mount_opt;
949         sbi->s_snapshot_cno = old_opts.snapshot_cno;
950         up_write(&nilfs->ns_super_sem);
951         unlock_kernel();
952         return err;
953 }
954
955 struct nilfs_super_data {
956         struct block_device *bdev;
957         struct nilfs_sb_info *sbi;
958         __u64 cno;
959         int flags;
960 };
961
962 /**
963  * nilfs_identify - pre-read mount options needed to identify mount instance
964  * @data: mount options
965  * @sd: nilfs_super_data
966  */
967 static int nilfs_identify(char *data, struct nilfs_super_data *sd)
968 {
969         char *p, *options = data;
970         substring_t args[MAX_OPT_ARGS];
971         int option, token;
972         int ret = 0;
973
974         do {
975                 p = strsep(&options, ",");
976                 if (p != NULL && *p) {
977                         token = match_token(p, tokens, args);
978                         if (token == Opt_snapshot) {
979                                 if (!(sd->flags & MS_RDONLY))
980                                         ret++;
981                                 else {
982                                         ret = match_int(&args[0], &option);
983                                         if (!ret) {
984                                                 if (option > 0)
985                                                         sd->cno = option;
986                                                 else
987                                                         ret++;
988                                         }
989                                 }
990                         }
991                         if (ret)
992                                 printk(KERN_ERR
993                                        "NILFS: invalid mount option: %s\n", p);
994                 }
995                 if (!options)
996                         break;
997                 BUG_ON(options == data);
998                 *(options - 1) = ',';
999         } while (!ret);
1000         return ret;
1001 }
1002
1003 static int nilfs_set_bdev_super(struct super_block *s, void *data)
1004 {
1005         struct nilfs_super_data *sd = data;
1006
1007         s->s_bdev = sd->bdev;
1008         s->s_dev = s->s_bdev->bd_dev;
1009         return 0;
1010 }
1011
1012 static int nilfs_test_bdev_super(struct super_block *s, void *data)
1013 {
1014         struct nilfs_super_data *sd = data;
1015
1016         return sd->sbi && s->s_fs_info == (void *)sd->sbi;
1017 }
1018
1019 static int
1020 nilfs_get_sb(struct file_system_type *fs_type, int flags,
1021              const char *dev_name, void *data, struct vfsmount *mnt)
1022 {
1023         struct nilfs_super_data sd;
1024         struct super_block *s;
1025         struct the_nilfs *nilfs;
1026         int err, need_to_close = 1;
1027
1028         sd.bdev = open_bdev_exclusive(dev_name, flags, fs_type);
1029         if (IS_ERR(sd.bdev))
1030                 return PTR_ERR(sd.bdev);
1031
1032         /*
1033          * To get mount instance using sget() vfs-routine, NILFS needs
1034          * much more information than normal filesystems to identify mount
1035          * instance.  For snapshot mounts, not only a mount type (ro-mount
1036          * or rw-mount) but also a checkpoint number is required.
1037          */
1038         sd.cno = 0;
1039         sd.flags = flags;
1040         if (nilfs_identify((char *)data, &sd)) {
1041                 err = -EINVAL;
1042                 goto failed;
1043         }
1044
1045         nilfs = find_or_create_nilfs(sd.bdev);
1046         if (!nilfs) {
1047                 err = -ENOMEM;
1048                 goto failed;
1049         }
1050
1051         mutex_lock(&nilfs->ns_mount_mutex);
1052
1053         if (!sd.cno) {
1054                 /*
1055                  * Check if an exclusive mount exists or not.
1056                  * Snapshot mounts coexist with a current mount
1057                  * (i.e. rw-mount or ro-mount), whereas rw-mount and
1058                  * ro-mount are mutually exclusive.
1059                  */
1060                 down_read(&nilfs->ns_super_sem);
1061                 if (nilfs->ns_current &&
1062                     ((nilfs->ns_current->s_super->s_flags ^ flags)
1063                      & MS_RDONLY)) {
1064                         up_read(&nilfs->ns_super_sem);
1065                         err = -EBUSY;
1066                         goto failed_unlock;
1067                 }
1068                 up_read(&nilfs->ns_super_sem);
1069         }
1070
1071         /*
1072          * Find existing nilfs_sb_info struct
1073          */
1074         sd.sbi = nilfs_find_sbinfo(nilfs, !(flags & MS_RDONLY), sd.cno);
1075
1076         /*
1077          * Get super block instance holding the nilfs_sb_info struct.
1078          * A new instance is allocated if no existing mount is present or
1079          * existing instance has been unmounted.
1080          */
1081         s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, &sd);
1082         if (sd.sbi)
1083                 nilfs_put_sbinfo(sd.sbi);
1084
1085         if (IS_ERR(s)) {
1086                 err = PTR_ERR(s);
1087                 goto failed_unlock;
1088         }
1089
1090         if (!s->s_root) {
1091                 char b[BDEVNAME_SIZE];
1092
1093                 /* New superblock instance created */
1094                 s->s_flags = flags;
1095                 strlcpy(s->s_id, bdevname(sd.bdev, b), sizeof(s->s_id));
1096                 sb_set_blocksize(s, block_size(sd.bdev));
1097
1098                 err = nilfs_fill_super(s, data, flags & MS_VERBOSE, nilfs);
1099                 if (err)
1100                         goto cancel_new;
1101
1102                 s->s_flags |= MS_ACTIVE;
1103                 need_to_close = 0;
1104         }
1105
1106         mutex_unlock(&nilfs->ns_mount_mutex);
1107         put_nilfs(nilfs);
1108         if (need_to_close)
1109                 close_bdev_exclusive(sd.bdev, flags);
1110         simple_set_mnt(mnt, s);
1111         return 0;
1112
1113  failed_unlock:
1114         mutex_unlock(&nilfs->ns_mount_mutex);
1115         put_nilfs(nilfs);
1116  failed:
1117         close_bdev_exclusive(sd.bdev, flags);
1118
1119         return err;
1120
1121  cancel_new:
1122         /* Abandoning the newly allocated superblock */
1123         mutex_unlock(&nilfs->ns_mount_mutex);
1124         put_nilfs(nilfs);
1125         deactivate_locked_super(s);
1126         /*
1127          * deactivate_super() invokes close_bdev_exclusive().
1128          * We must finish all post-cleaning before this call;
1129          * put_nilfs() needs the block device.
1130          */
1131         return err;
1132 }
1133
1134 struct file_system_type nilfs_fs_type = {
1135         .owner    = THIS_MODULE,
1136         .name     = "nilfs2",
1137         .get_sb   = nilfs_get_sb,
1138         .kill_sb  = kill_block_super,
1139         .fs_flags = FS_REQUIRES_DEV,
1140 };
1141
1142 static int __init init_nilfs_fs(void)
1143 {
1144         int err;
1145
1146         err = nilfs_init_inode_cache();
1147         if (err)
1148                 goto failed;
1149
1150         err = nilfs_init_transaction_cache();
1151         if (err)
1152                 goto failed_inode_cache;
1153
1154         err = nilfs_init_segbuf_cache();
1155         if (err)
1156                 goto failed_transaction_cache;
1157
1158         err = nilfs_btree_path_cache_init();
1159         if (err)
1160                 goto failed_segbuf_cache;
1161
1162         err = register_filesystem(&nilfs_fs_type);
1163         if (err)
1164                 goto failed_btree_path_cache;
1165
1166         return 0;
1167
1168  failed_btree_path_cache:
1169         nilfs_btree_path_cache_destroy();
1170
1171  failed_segbuf_cache:
1172         nilfs_destroy_segbuf_cache();
1173
1174  failed_transaction_cache:
1175         nilfs_destroy_transaction_cache();
1176
1177  failed_inode_cache:
1178         nilfs_destroy_inode_cache();
1179
1180  failed:
1181         return err;
1182 }
1183
1184 static void __exit exit_nilfs_fs(void)
1185 {
1186         nilfs_destroy_segbuf_cache();
1187         nilfs_destroy_transaction_cache();
1188         nilfs_destroy_inode_cache();
1189         nilfs_btree_path_cache_destroy();
1190         unregister_filesystem(&nilfs_fs_type);
1191 }
1192
1193 module_init(init_nilfs_fs)
1194 module_exit(exit_nilfs_fs)