module/zfs/zpl_super.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2011, Lawrence Livermore National Security, LLC.
  23  */
  24
  25
  26 #include <sys/zfs_vfsops.h>
  27 #include <sys/zfs_vnops.h>
  28 #include <sys/zfs_znode.h>
  29 #include <sys/zpl.h>
  30
  31
  32 static struct inode *
  33 zpl_inode_alloc(struct super_block *sb)
  34 {
  35         struct inode *ip;
  36
  37         VERIFY3S(zfs_inode_alloc(sb, &ip), ==, 0);
  38         ip->i_version = 1;
  39
  40         return (ip);
  41 }
  42
  43 static void
  44 zpl_inode_destroy(struct inode *ip)
  45 {
  46         ASSERT(atomic_read(&ip->i_count) == 0);
  47         zfs_inode_destroy(ip);
  48 }
  49
  50 static void
  51 zpl_inode_delete(struct inode *ip)
  52 {
  53         loff_t oldsize = i_size_read(ip);
  54
  55         i_size_write(ip, 0);
  56         truncate_pagecache(ip, oldsize, 0);
  57         clear_inode(ip);
  58 }
  59
  60 static void
  61 zpl_evict_inode(struct inode *ip)
  62 {
  63         zfs_inactive(ip);
  64 }
  65
  66 static void
  67 zpl_put_super(struct super_block *sb)
  68 {
  69         int error;
  70
  71         error = -zfs_umount(sb);
  72         ASSERT3S(error, <=, 0);
  73 }
  74
  75 static int
  76 zpl_statfs(struct dentry *dentry, struct kstatfs *statp)
  77 {
  78         int error;
  79
  80         error = -zfs_statvfs(dentry, statp);
  81         ASSERT3S(error, <=, 0);
  82
  83         return (error);
  84 }
  85
  86 static int
  87 zpl_show_options(struct seq_file *seq, struct vfsmount *vfsp)
  88 {
  89         struct super_block *sb = vfsp->mnt_sb;
  90         zfs_sb_t *zsb = sb->s_fs_info;
  91
  92         /*
  93          * The Linux VFS automatically handles the following flags:
  94          * MNT_NOSUID, MNT_NODEV, MNT_NOEXEC, MNT_NOATIME, MNT_READONLY
  95          */
  96
  97         if (zsb->z_flags & ZSB_XATTR_USER)
  98                 seq_printf(seq, ",%s", "xattr");
  99
 100         return (0);
 101 }
 102
 103 static int
 104 zpl_fill_super(struct super_block *sb, void *data, int silent)
 105 {
 106         int error;
 107
 108         error = -zfs_domount(sb, data, silent);
 109         ASSERT3S(error, <=, 0);
 110
 111         return (error);
 112 }
 113
 114 static int
 115 zpl_get_sb(struct file_system_type *fs_type, int flags,
 116     const char *osname, void *data, struct vfsmount *mnt)
 117 {
 118         zpl_mount_data_t zmd = { osname, data, mnt };
 119
 120         return get_sb_nodev(fs_type, flags, &zmd, zpl_fill_super, mnt);
 121 }
 122
 123 static void
 124 zpl_kill_sb(struct super_block *sb)
 125 {
 126 #ifdef HAVE_SNAPSHOT
 127         zfs_sb_t *zsb = sb->s_fs_info;
 128
 129         if (zsb && dmu_objset_is_snapshot(zsb->z_os))
 130                 zfs_snap_destroy(zsb);
 131 #endif /* HAVE_SNAPSHOT */
 132
 133         kill_anon_super(sb);
 134 }
 135
 136 const struct super_operations zpl_super_operations = {
 137         .alloc_inode    = zpl_inode_alloc,
 138         .destroy_inode  = zpl_inode_destroy,
 139         .delete_inode   = zpl_inode_delete,
 140         .dirty_inode    = NULL,
 141         .write_inode    = NULL,
 142         .drop_inode     = NULL,
 143         .clear_inode    = zpl_evict_inode,
 144         .put_super      = zpl_put_super,
 145         .write_super    = NULL,
 146         .sync_fs        = NULL,
 147         .freeze_fs      = NULL,
 148         .unfreeze_fs    = NULL,
 149         .statfs         = zpl_statfs,
 150         .remount_fs     = NULL,
 151         .show_options   = zpl_show_options,
 152         .show_stats     = NULL,
 153 };
 154
 155 #if 0
 156 const struct export_operations zpl_export_operations = {
 157         .fh_to_dentry   = NULL,
 158         .fh_to_parent   = NULL,
 159         .get_parent     = NULL,
 160 };
 161 #endif
 162
 163 struct file_system_type zpl_fs_type = {
 164         .owner          = THIS_MODULE,
 165         .name           = ZFS_DRIVER,
 166         .get_sb         = zpl_get_sb,
 167         .kill_sb        = zpl_kill_sb,
 168 };