1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include "xfs.h"
19#include "xfs_bit.h"
20#include "xfs_log.h"
21#include "xfs_clnt.h"
22#include "xfs_inum.h"
23#include "xfs_trans.h"
24#include "xfs_sb.h"
25#include "xfs_ag.h"
26#include "xfs_dir2.h"
27#include "xfs_alloc.h"
28#include "xfs_dmapi.h"
29#include "xfs_quota.h"
30#include "xfs_mount.h"
31#include "xfs_bmap_btree.h"
32#include "xfs_alloc_btree.h"
33#include "xfs_ialloc_btree.h"
34#include "xfs_dir2_sf.h"
35#include "xfs_attr_sf.h"
36#include "xfs_dinode.h"
37#include "xfs_inode.h"
38#include "xfs_btree.h"
39#include "xfs_ialloc.h"
40#include "xfs_bmap.h"
41#include "xfs_rtalloc.h"
42#include "xfs_error.h"
43#include "xfs_itable.h"
44#include "xfs_rw.h"
45#include "xfs_acl.h"
46#include "xfs_attr.h"
47#include "xfs_buf_item.h"
48#include "xfs_utils.h"
49#include "xfs_vnodeops.h"
50#include "xfs_vfsops.h"
51#include "xfs_version.h"
52
53#include <linux/namei.h>
54#include <linux/init.h>
55#include <linux/mount.h>
56#include <linux/mempool.h>
57#include <linux/writeback.h>
58#include <linux/kthread.h>
59#include <linux/freezer.h>
60
61static struct quotactl_ops xfs_quotactl_operations;
62static struct super_operations xfs_super_operations;
63static kmem_zone_t *xfs_vnode_zone;
64static kmem_zone_t *xfs_ioend_zone;
65mempool_t *xfs_ioend_pool;
66
67STATIC struct xfs_mount_args *
68xfs_args_allocate(
69 struct super_block *sb,
70 int silent)
71{
72 struct xfs_mount_args *args;
73
74 args = kmem_zalloc(sizeof(struct xfs_mount_args), KM_SLEEP);
75 args->logbufs = args->logbufsize = -1;
76 strncpy(args->fsname, sb->s_id, MAXNAMELEN);
77
78
79 if (sb->s_flags & MS_DIRSYNC)
80 args->flags |= XFSMNT_DIRSYNC;
81 if (sb->s_flags & MS_SYNCHRONOUS)
82 args->flags |= XFSMNT_WSYNC;
83 if (silent)
84 args->flags |= XFSMNT_QUIET;
85 args->flags |= XFSMNT_32BITINODES;
86
87 return args;
88}
89
90__uint64_t
91xfs_max_file_offset(
92 unsigned int blockshift)
93{
94 unsigned int pagefactor = 1;
95 unsigned int bitshift = BITS_PER_LONG - 1;
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111#if BITS_PER_LONG == 32
112# if defined(CONFIG_LBD)
113 ASSERT(sizeof(sector_t) == 8);
114 pagefactor = PAGE_CACHE_SIZE;
115 bitshift = BITS_PER_LONG;
116# else
117 pagefactor = PAGE_CACHE_SIZE >> (PAGE_CACHE_SHIFT - blockshift);
118# endif
119#endif
120
121 return (((__uint64_t)pagefactor) << bitshift) - 1;
122}
123
124STATIC_INLINE void
125xfs_set_inodeops(
126 struct inode *inode)
127{
128 switch (inode->i_mode & S_IFMT) {
129 case S_IFREG:
130 inode->i_op = &xfs_inode_operations;
131 inode->i_fop = &xfs_file_operations;
132 inode->i_mapping->a_ops = &xfs_address_space_operations;
133 break;
134 case S_IFDIR:
135 inode->i_op = &xfs_dir_inode_operations;
136 inode->i_fop = &xfs_dir_file_operations;
137 break;
138 case S_IFLNK:
139 inode->i_op = &xfs_symlink_inode_operations;
140 if (inode->i_blocks)
141 inode->i_mapping->a_ops = &xfs_address_space_operations;
142 break;
143 default:
144 inode->i_op = &xfs_inode_operations;
145 init_special_inode(inode, inode->i_mode, inode->i_rdev);
146 break;
147 }
148}
149
150STATIC_INLINE void
151xfs_revalidate_inode(
152 xfs_mount_t *mp,
153 bhv_vnode_t *vp,
154 xfs_inode_t *ip)
155{
156 struct inode *inode = vn_to_inode(vp);
157
158 inode->i_mode = ip->i_d.di_mode;
159 inode->i_nlink = ip->i_d.di_nlink;
160 inode->i_uid = ip->i_d.di_uid;
161 inode->i_gid = ip->i_d.di_gid;
162
163 switch (inode->i_mode & S_IFMT) {
164 case S_IFBLK:
165 case S_IFCHR:
166 inode->i_rdev =
167 MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
168 sysv_minor(ip->i_df.if_u2.if_rdev));
169 break;
170 default:
171 inode->i_rdev = 0;
172 break;
173 }
174
175 inode->i_generation = ip->i_d.di_gen;
176 i_size_write(inode, ip->i_d.di_size);
177 inode->i_blocks =
178 XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);
179 inode->i_atime.tv_sec = ip->i_d.di_atime.t_sec;
180 inode->i_atime.tv_nsec = ip->i_d.di_atime.t_nsec;
181 inode->i_mtime.tv_sec = ip->i_d.di_mtime.t_sec;
182 inode->i_mtime.tv_nsec = ip->i_d.di_mtime.t_nsec;
183 inode->i_ctime.tv_sec = ip->i_d.di_ctime.t_sec;
184 inode->i_ctime.tv_nsec = ip->i_d.di_ctime.t_nsec;
185 if (ip->i_d.di_flags & XFS_DIFLAG_IMMUTABLE)
186 inode->i_flags |= S_IMMUTABLE;
187 else
188 inode->i_flags &= ~S_IMMUTABLE;
189 if (ip->i_d.di_flags & XFS_DIFLAG_APPEND)
190 inode->i_flags |= S_APPEND;
191 else
192 inode->i_flags &= ~S_APPEND;
193 if (ip->i_d.di_flags & XFS_DIFLAG_SYNC)
194 inode->i_flags |= S_SYNC;
195 else
196 inode->i_flags &= ~S_SYNC;
197 if (ip->i_d.di_flags & XFS_DIFLAG_NOATIME)
198 inode->i_flags |= S_NOATIME;
199 else
200 inode->i_flags &= ~S_NOATIME;
201 xfs_iflags_clear(ip, XFS_IMODIFIED);
202}
203
204void
205xfs_initialize_vnode(
206 struct xfs_mount *mp,
207 bhv_vnode_t *vp,
208 struct xfs_inode *ip)
209{
210 struct inode *inode = vn_to_inode(vp);
211
212 if (!ip->i_vnode) {
213 ip->i_vnode = vp;
214 inode->i_private = ip;
215 }
216
217
218
219
220
221
222
223
224 if (ip->i_d.di_mode != 0 && (inode->i_state & I_NEW)) {
225 xfs_revalidate_inode(mp, vp, ip);
226 xfs_set_inodeops(inode);
227
228 xfs_iflags_clear(ip, XFS_INEW);
229 barrier();
230
231 unlock_new_inode(inode);
232 }
233}
234
235int
236xfs_blkdev_get(
237 xfs_mount_t *mp,
238 const char *name,
239 struct block_device **bdevp)
240{
241 int error = 0;
242
243 *bdevp = open_bdev_excl(name, 0, mp);
244 if (IS_ERR(*bdevp)) {
245 error = PTR_ERR(*bdevp);
246 printk("XFS: Invalid device [%s], error=%d\n", name, error);
247 }
248
249 return -error;
250}
251
252void
253xfs_blkdev_put(
254 struct block_device *bdev)
255{
256 if (bdev)
257 close_bdev_excl(bdev);
258}
259
260
261
262
263STATIC int
264xfs_barrier_test(
265 xfs_mount_t *mp)
266{
267 xfs_buf_t *sbp = xfs_getsb(mp, 0);
268 int error;
269
270 XFS_BUF_UNDONE(sbp);
271 XFS_BUF_UNREAD(sbp);
272 XFS_BUF_UNDELAYWRITE(sbp);
273 XFS_BUF_WRITE(sbp);
274 XFS_BUF_UNASYNC(sbp);
275 XFS_BUF_ORDERED(sbp);
276
277 xfsbdstrat(mp, sbp);
278 error = xfs_iowait(sbp);
279
280
281
282
283
284
285
286 XFS_BUF_DONE(sbp);
287 XFS_BUF_ERROR(sbp, 0);
288 XFS_BUF_UNORDERED(sbp);
289
290 xfs_buf_relse(sbp);
291 return error;
292}
293
294void
295xfs_mountfs_check_barriers(xfs_mount_t *mp)
296{
297 int error;
298
299 if (mp->m_logdev_targp != mp->m_ddev_targp) {
300 xfs_fs_cmn_err(CE_NOTE, mp,
301 "Disabling barriers, not supported with external log device");
302 mp->m_flags &= ~XFS_MOUNT_BARRIER;
303 return;
304 }
305
306 if (mp->m_ddev_targp->bt_bdev->bd_disk->queue->ordered ==
307 QUEUE_ORDERED_NONE) {
308 xfs_fs_cmn_err(CE_NOTE, mp,
309 "Disabling barriers, not supported by the underlying device");
310 mp->m_flags &= ~XFS_MOUNT_BARRIER;
311 return;
312 }
313
314 if (xfs_readonly_buftarg(mp->m_ddev_targp)) {
315 xfs_fs_cmn_err(CE_NOTE, mp,
316 "Disabling barriers, underlying device is readonly");
317 mp->m_flags &= ~XFS_MOUNT_BARRIER;
318 return;
319 }
320
321 error = xfs_barrier_test(mp);
322 if (error) {
323 xfs_fs_cmn_err(CE_NOTE, mp,
324 "Disabling barriers, trial barrier write failed");
325 mp->m_flags &= ~XFS_MOUNT_BARRIER;
326 return;
327 }
328}
329
330void
331xfs_blkdev_issue_flush(
332 xfs_buftarg_t *buftarg)
333{
334 blkdev_issue_flush(buftarg->bt_bdev, NULL);
335}
336
337STATIC struct inode *
338xfs_fs_alloc_inode(
339 struct super_block *sb)
340{
341 bhv_vnode_t *vp;
342
343 vp = kmem_zone_alloc(xfs_vnode_zone, KM_SLEEP);
344 if (unlikely(!vp))
345 return NULL;
346 return vn_to_inode(vp);
347}
348
349STATIC void
350xfs_fs_destroy_inode(
351 struct inode *inode)
352{
353 kmem_zone_free(xfs_vnode_zone, vn_from_inode(inode));
354}
355
356STATIC void
357xfs_fs_inode_init_once(
358 kmem_zone_t *zonep,
359 void *vnode)
360{
361 inode_init_once(vn_to_inode((bhv_vnode_t *)vnode));
362}
363
364STATIC int
365xfs_init_zones(void)
366{
367 xfs_vnode_zone = kmem_zone_init_flags(sizeof(bhv_vnode_t), "xfs_vnode",
368 KM_ZONE_HWALIGN | KM_ZONE_RECLAIM |
369 KM_ZONE_SPREAD,
370 xfs_fs_inode_init_once);
371 if (!xfs_vnode_zone)
372 goto out;
373
374 xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
375 if (!xfs_ioend_zone)
376 goto out_destroy_vnode_zone;
377
378 xfs_ioend_pool = mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE,
379 xfs_ioend_zone);
380 if (!xfs_ioend_pool)
381 goto out_free_ioend_zone;
382 return 0;
383
384 out_free_ioend_zone:
385 kmem_zone_destroy(xfs_ioend_zone);
386 out_destroy_vnode_zone:
387 kmem_zone_destroy(xfs_vnode_zone);
388 out:
389 return -ENOMEM;
390}
391
392STATIC void
393xfs_destroy_zones(void)
394{
395 mempool_destroy(xfs_ioend_pool);
396 kmem_zone_destroy(xfs_vnode_zone);
397 kmem_zone_destroy(xfs_ioend_zone);
398}
399
400
401
402
403
404
405
406STATIC int
407xfs_fs_write_inode(
408 struct inode *inode,
409 int sync)
410{
411 int error = 0, flags = FLUSH_INODE;
412
413 vn_trace_entry(XFS_I(inode), __FUNCTION__,
414 (inst_t *)__return_address);
415 if (sync) {
416 filemap_fdatawait(inode->i_mapping);
417 flags |= FLUSH_SYNC;
418 }
419 error = xfs_inode_flush(XFS_I(inode), flags);
420
421
422
423
424 if (error)
425 mark_inode_dirty_sync(inode);
426
427 return -error;
428}
429
430STATIC void
431xfs_fs_clear_inode(
432 struct inode *inode)
433{
434 xfs_inode_t *ip = XFS_I(inode);
435
436
437
438
439
440 if (ip) {
441 vn_trace_entry(ip, __FUNCTION__, (inst_t *)__return_address);
442
443 XFS_STATS_INC(vn_rele);
444 XFS_STATS_INC(vn_remove);
445 XFS_STATS_INC(vn_reclaim);
446 XFS_STATS_DEC(vn_active);
447
448 xfs_inactive(ip);
449 xfs_iflags_clear(ip, XFS_IMODIFIED);
450 if (xfs_reclaim(ip))
451 panic("%s: cannot reclaim 0x%p\n", __FUNCTION__, inode);
452 }
453
454 ASSERT(XFS_I(inode) == NULL);
455}
456
457
458
459
460
461
462
463
464STATIC void
465xfs_syncd_queue_work(
466 struct xfs_mount *mp,
467 void *data,
468 void (*syncer)(struct xfs_mount *, void *))
469{
470 struct bhv_vfs_sync_work *work;
471
472 work = kmem_alloc(sizeof(struct bhv_vfs_sync_work), KM_SLEEP);
473 INIT_LIST_HEAD(&work->w_list);
474 work->w_syncer = syncer;
475 work->w_data = data;
476 work->w_mount = mp;
477 spin_lock(&mp->m_sync_lock);
478 list_add_tail(&work->w_list, &mp->m_sync_list);
479 spin_unlock(&mp->m_sync_lock);
480 wake_up_process(mp->m_sync_task);
481}
482
483
484
485
486
487
488
489STATIC void
490xfs_flush_inode_work(
491 struct xfs_mount *mp,
492 void *arg)
493{
494 struct inode *inode = arg;
495 filemap_flush(inode->i_mapping);
496 iput(inode);
497}
498
499void
500xfs_flush_inode(
501 xfs_inode_t *ip)
502{
503 struct inode *inode = ip->i_vnode;
504
505 igrab(inode);
506 xfs_syncd_queue_work(ip->i_mount, inode, xfs_flush_inode_work);
507 delay(msecs_to_jiffies(500));
508}
509
510
511
512
513
514STATIC void
515xfs_flush_device_work(
516 struct xfs_mount *mp,
517 void *arg)
518{
519 struct inode *inode = arg;
520 sync_blockdev(mp->m_super->s_bdev);
521 iput(inode);
522}
523
524void
525xfs_flush_device(
526 xfs_inode_t *ip)
527{
528 struct inode *inode = vn_to_inode(XFS_ITOV(ip));
529
530 igrab(inode);
531 xfs_syncd_queue_work(ip->i_mount, inode, xfs_flush_device_work);
532 delay(msecs_to_jiffies(500));
533 xfs_log_force(ip->i_mount, (xfs_lsn_t)0, XFS_LOG_FORCE|XFS_LOG_SYNC);
534}
535
536STATIC void
537xfs_sync_worker(
538 struct xfs_mount *mp,
539 void *unused)
540{
541 int error;
542
543 if (!(mp->m_flags & XFS_MOUNT_RDONLY))
544 error = xfs_sync(mp, SYNC_FSDATA | SYNC_BDFLUSH | SYNC_ATTR |
545 SYNC_REFCACHE | SYNC_SUPER);
546 mp->m_sync_seq++;
547 wake_up(&mp->m_wait_single_sync_task);
548}
549
550STATIC int
551xfssyncd(
552 void *arg)
553{
554 struct xfs_mount *mp = arg;
555 long timeleft;
556 bhv_vfs_sync_work_t *work, *n;
557 LIST_HEAD (tmp);
558
559 set_freezable();
560 timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10);
561 for (;;) {
562 timeleft = schedule_timeout_interruptible(timeleft);
563
564 try_to_freeze();
565 if (kthread_should_stop() && list_empty(&mp->m_sync_list))
566 break;
567
568 spin_lock(&mp->m_sync_lock);
569
570
571
572
573
574 if (!timeleft || list_empty(&mp->m_sync_list)) {
575 if (!timeleft)
576 timeleft = xfs_syncd_centisecs *
577 msecs_to_jiffies(10);
578 INIT_LIST_HEAD(&mp->m_sync_work.w_list);
579 list_add_tail(&mp->m_sync_work.w_list,
580 &mp->m_sync_list);
581 }
582 list_for_each_entry_safe(work, n, &mp->m_sync_list, w_list)
583 list_move(&work->w_list, &tmp);
584 spin_unlock(&mp->m_sync_lock);
585
586 list_for_each_entry_safe(work, n, &tmp, w_list) {
587 (*work->w_syncer)(mp, work->w_data);
588 list_del(&work->w_list);
589 if (work == &mp->m_sync_work)
590 continue;
591 kmem_free(work, sizeof(struct bhv_vfs_sync_work));
592 }
593 }
594
595 return 0;
596}
597
598STATIC void
599xfs_fs_put_super(
600 struct super_block *sb)
601{
602 struct xfs_mount *mp = XFS_M(sb);
603 int error;
604
605 kthread_stop(mp->m_sync_task);
606
607 xfs_sync(mp, SYNC_ATTR | SYNC_DELWRI);
608 error = xfs_unmount(mp, 0, NULL);
609 if (error)
610 printk("XFS: unmount got error=%d\n", error);
611}
612
613STATIC void
614xfs_fs_write_super(
615 struct super_block *sb)
616{
617 if (!(sb->s_flags & MS_RDONLY))
618 xfs_sync(XFS_M(sb), SYNC_FSDATA);
619 sb->s_dirt = 0;
620}
621
622STATIC int
623xfs_fs_sync_super(
624 struct super_block *sb,
625 int wait)
626{
627 struct xfs_mount *mp = XFS_M(sb);
628 int error;
629 int flags;
630
631
632
633
634
635
636
637
638
639
640
641
642
643 if (wait || unlikely(sb->s_frozen == SB_FREEZE_WRITE)) {
644
645
646
647
648
649
650
651
652 flags = SYNC_DATA_QUIESCE;
653 } else
654 flags = SYNC_FSDATA;
655
656 error = xfs_sync(mp, flags);
657 sb->s_dirt = 0;
658
659 if (unlikely(laptop_mode)) {
660 int prev_sync_seq = mp->m_sync_seq;
661
662
663
664
665
666
667 wake_up_process(mp->m_sync_task);
668
669
670
671
672
673
674 wait_event(mp->m_wait_single_sync_task,
675 mp->m_sync_seq != prev_sync_seq);
676 }
677
678 return -error;
679}
680
681STATIC int
682xfs_fs_statfs(
683 struct dentry *dentry,
684 struct kstatfs *statp)
685{
686 return -xfs_statvfs(XFS_M(dentry->d_sb), statp,
687 vn_from_inode(dentry->d_inode));
688}
689
690STATIC int
691xfs_fs_remount(
692 struct super_block *sb,
693 int *flags,
694 char *options)
695{
696 struct xfs_mount *mp = XFS_M(sb);
697 struct xfs_mount_args *args = xfs_args_allocate(sb, 0);
698 int error;
699
700 error = xfs_parseargs(mp, options, args, 1);
701 if (!error)
702 error = xfs_mntupdate(mp, flags, args);
703 kmem_free(args, sizeof(*args));
704 return -error;
705}
706
707STATIC void
708xfs_fs_lockfs(
709 struct super_block *sb)
710{
711 xfs_freeze(XFS_M(sb));
712}
713
714STATIC int
715xfs_fs_show_options(
716 struct seq_file *m,
717 struct vfsmount *mnt)
718{
719 return -xfs_showargs(XFS_M(mnt->mnt_sb), m);
720}
721
722STATIC int
723xfs_fs_quotasync(
724 struct super_block *sb,
725 int type)
726{
727 return -XFS_QM_QUOTACTL(XFS_M(sb), Q_XQUOTASYNC, 0, NULL);
728}
729
730STATIC int
731xfs_fs_getxstate(
732 struct super_block *sb,
733 struct fs_quota_stat *fqs)
734{
735 return -XFS_QM_QUOTACTL(XFS_M(sb), Q_XGETQSTAT, 0, (caddr_t)fqs);
736}
737
738STATIC int
739xfs_fs_setxstate(
740 struct super_block *sb,
741 unsigned int flags,
742 int op)
743{
744 return -XFS_QM_QUOTACTL(XFS_M(sb), op, 0, (caddr_t)&flags);
745}
746
747STATIC int
748xfs_fs_getxquota(
749 struct super_block *sb,
750 int type,
751 qid_t id,
752 struct fs_disk_quota *fdq)
753{
754 return -XFS_QM_QUOTACTL(XFS_M(sb),
755 (type == USRQUOTA) ? Q_XGETQUOTA :
756 ((type == GRPQUOTA) ? Q_XGETGQUOTA :
757 Q_XGETPQUOTA), id, (caddr_t)fdq);
758}
759
760STATIC int
761xfs_fs_setxquota(
762 struct super_block *sb,
763 int type,
764 qid_t id,
765 struct fs_disk_quota *fdq)
766{
767 return -XFS_QM_QUOTACTL(XFS_M(sb),
768 (type == USRQUOTA) ? Q_XSETQLIM :
769 ((type == GRPQUOTA) ? Q_XSETGQLIM :
770 Q_XSETPQLIM), id, (caddr_t)fdq);
771}
772
773STATIC int
774xfs_fs_fill_super(
775 struct super_block *sb,
776 void *data,
777 int silent)
778{
779 struct inode *rootvp;
780 struct xfs_mount *mp = NULL;
781 struct xfs_mount_args *args = xfs_args_allocate(sb, silent);
782 struct kstatfs statvfs;
783 int error;
784
785 mp = xfs_mount_init();
786
787 INIT_LIST_HEAD(&mp->m_sync_list);
788 spin_lock_init(&mp->m_sync_lock);
789 init_waitqueue_head(&mp->m_wait_single_sync_task);
790
791 mp->m_super = sb;
792 sb->s_fs_info = mp;
793
794 if (sb->s_flags & MS_RDONLY)
795 mp->m_flags |= XFS_MOUNT_RDONLY;
796
797 error = xfs_parseargs(mp, (char *)data, args, 0);
798 if (error)
799 goto fail_vfsop;
800
801 sb_min_blocksize(sb, BBSIZE);
802 sb->s_export_op = &xfs_export_operations;
803 sb->s_qcop = &xfs_quotactl_operations;
804 sb->s_op = &xfs_super_operations;
805
806 error = xfs_mount(mp, args, NULL);
807 if (error)
808 goto fail_vfsop;
809
810 error = xfs_statvfs(mp, &statvfs, NULL);
811 if (error)
812 goto fail_unmount;
813
814 sb->s_dirt = 1;
815 sb->s_magic = statvfs.f_type;
816 sb->s_blocksize = statvfs.f_bsize;
817 sb->s_blocksize_bits = ffs(statvfs.f_bsize) - 1;
818 sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits);
819 sb->s_time_gran = 1;
820 set_posix_acl_flag(sb);
821
822 error = xfs_root(mp, &rootvp);
823 if (error)
824 goto fail_unmount;
825
826 sb->s_root = d_alloc_root(vn_to_inode(rootvp));
827 if (!sb->s_root) {
828 error = ENOMEM;
829 goto fail_vnrele;
830 }
831 if (is_bad_inode(sb->s_root->d_inode)) {
832 error = EINVAL;
833 goto fail_vnrele;
834 }
835
836 mp->m_sync_work.w_syncer = xfs_sync_worker;
837 mp->m_sync_work.w_mount = mp;
838 mp->m_sync_task = kthread_run(xfssyncd, mp, "xfssyncd");
839 if (IS_ERR(mp->m_sync_task)) {
840 error = -PTR_ERR(mp->m_sync_task);
841 goto fail_vnrele;
842 }
843
844 vn_trace_exit(XFS_I(sb->s_root->d_inode), __FUNCTION__,
845 (inst_t *)__return_address);
846
847 kmem_free(args, sizeof(*args));
848 return 0;
849
850fail_vnrele:
851 if (sb->s_root) {
852 dput(sb->s_root);
853 sb->s_root = NULL;
854 } else {
855 VN_RELE(rootvp);
856 }
857
858fail_unmount:
859 xfs_unmount(mp, 0, NULL);
860
861fail_vfsop:
862 kmem_free(args, sizeof(*args));
863 return -error;
864}
865
866STATIC int
867xfs_fs_get_sb(
868 struct file_system_type *fs_type,
869 int flags,
870 const char *dev_name,
871 void *data,
872 struct vfsmount *mnt)
873{
874 return get_sb_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super,
875 mnt);
876}
877
878static struct super_operations xfs_super_operations = {
879 .alloc_inode = xfs_fs_alloc_inode,
880 .destroy_inode = xfs_fs_destroy_inode,
881 .write_inode = xfs_fs_write_inode,
882 .clear_inode = xfs_fs_clear_inode,
883 .put_super = xfs_fs_put_super,
884 .write_super = xfs_fs_write_super,
885 .sync_fs = xfs_fs_sync_super,
886 .write_super_lockfs = xfs_fs_lockfs,
887 .statfs = xfs_fs_statfs,
888 .remount_fs = xfs_fs_remount,
889 .show_options = xfs_fs_show_options,
890};
891
892static struct quotactl_ops xfs_quotactl_operations = {
893 .quota_sync = xfs_fs_quotasync,
894 .get_xstate = xfs_fs_getxstate,
895 .set_xstate = xfs_fs_setxstate,
896 .get_xquota = xfs_fs_getxquota,
897 .set_xquota = xfs_fs_setxquota,
898};
899
900static struct file_system_type xfs_fs_type = {
901 .owner = THIS_MODULE,
902 .name = "xfs",
903 .get_sb = xfs_fs_get_sb,
904 .kill_sb = kill_block_super,
905 .fs_flags = FS_REQUIRES_DEV,
906};
907
908
909STATIC int __init
910init_xfs_fs( void )
911{
912 int error;
913 static char message[] __initdata = KERN_INFO \
914 XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled\n";
915
916 printk(message);
917
918 ktrace_init(64);
919
920 error = xfs_init_zones();
921 if (error < 0)
922 goto undo_zones;
923
924 error = xfs_buf_init();
925 if (error < 0)
926 goto undo_buffers;
927
928 vn_init();
929 xfs_init();
930 uuid_init();
931 vfs_initquota();
932
933 error = register_filesystem(&xfs_fs_type);
934 if (error)
935 goto undo_register;
936 return 0;
937
938undo_register:
939 xfs_buf_terminate();
940
941undo_buffers:
942 xfs_destroy_zones();
943
944undo_zones:
945 return error;
946}
947
948STATIC void __exit
949exit_xfs_fs( void )
950{
951 vfs_exitquota();
952 unregister_filesystem(&xfs_fs_type);
953 xfs_cleanup();
954 xfs_buf_terminate();
955 xfs_destroy_zones();
956 ktrace_uninit();
957}
958
959module_init(init_xfs_fs);
960module_exit(exit_xfs_fs);
961
962MODULE_AUTHOR("Silicon Graphics, Inc.");
963MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");
964MODULE_LICENSE("GPL");
965