sys/contrib/openzfs/module/os/linux/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_znode.h>
  27 #include <sys/zfs_vfsops.h>
  28 #include <sys/zfs_vnops.h>
  29 #include <sys/zfs_ctldir.h>
  30 #include <sys/zpl.h>
  31
  32
  33 static struct inode *
  34 zpl_inode_alloc(struct super_block *sb)
  35 {
  36         struct inode *ip;
  37
  38         VERIFY3S(zfs_inode_alloc(sb, &ip), ==, 0);
  39         inode_set_iversion(ip, 1);
  40
  41         return (ip);
  42 }
  43
  44 static void
  45 zpl_inode_destroy(struct inode *ip)
  46 {
  47         ASSERT(atomic_read(&ip->i_count) == 0);
  48         zfs_inode_destroy(ip);
  49 }
  50
  51 /*
  52  * Called from __mark_inode_dirty() to reflect that something in the
  53  * inode has changed.  We use it to ensure the znode system attributes
  54  * are always strictly update to date with respect to the inode.
  55  */
  56 #ifdef HAVE_DIRTY_INODE_WITH_FLAGS
  57 static void
  58 zpl_dirty_inode(struct inode *ip, int flags)
  59 {
  60         fstrans_cookie_t cookie;
  61
  62         cookie = spl_fstrans_mark();
  63         zfs_dirty_inode(ip, flags);
  64         spl_fstrans_unmark(cookie);
  65 }
  66 #else
  67 static void
  68 zpl_dirty_inode(struct inode *ip)
  69 {
  70         fstrans_cookie_t cookie;
  71
  72         cookie = spl_fstrans_mark();
  73         zfs_dirty_inode(ip, 0);
  74         spl_fstrans_unmark(cookie);
  75 }
  76 #endif /* HAVE_DIRTY_INODE_WITH_FLAGS */
  77
  78 /*
  79  * When ->drop_inode() is called its return value indicates if the
  80  * inode should be evicted from the inode cache.  If the inode is
  81  * unhashed and has no links the default policy is to evict it
  82  * immediately.
  83  *
  84  * The ->evict_inode() callback must minimally truncate the inode pages,
  85  * and call clear_inode().  For 2.6.35 and later kernels this will
  86  * simply update the inode state, with the sync occurring before the
  87  * truncate in evict().  For earlier kernels clear_inode() maps to
  88  * end_writeback() which is responsible for completing all outstanding
  89  * write back.  In either case, once this is done it is safe to cleanup
  90  * any remaining inode specific data via zfs_inactive().
  91  * remaining filesystem specific data.
  92  */
  93 static void
  94 zpl_evict_inode(struct inode *ip)
  95 {
  96         fstrans_cookie_t cookie;
  97
  98         cookie = spl_fstrans_mark();
  99         truncate_setsize(ip, 0);
 100         clear_inode(ip);
 101         zfs_inactive(ip);
 102         spl_fstrans_unmark(cookie);
 103 }
 104
 105 static void
 106 zpl_put_super(struct super_block *sb)
 107 {
 108         fstrans_cookie_t cookie;
 109         int error;
 110
 111         cookie = spl_fstrans_mark();
 112         error = -zfs_umount(sb);
 113         spl_fstrans_unmark(cookie);
 114         ASSERT3S(error, <=, 0);
 115 }
 116
 117 static int
 118 zpl_sync_fs(struct super_block *sb, int wait)
 119 {
 120         fstrans_cookie_t cookie;
 121         cred_t *cr = CRED();
 122         int error;
 123
 124         crhold(cr);
 125         cookie = spl_fstrans_mark();
 126         error = -zfs_sync(sb, wait, cr);
 127         spl_fstrans_unmark(cookie);
 128         crfree(cr);
 129         ASSERT3S(error, <=, 0);
 130
 131         return (error);
 132 }
 133
 134 static int
 135 zpl_statfs(struct dentry *dentry, struct kstatfs *statp)
 136 {
 137         fstrans_cookie_t cookie;
 138         int error;
 139
 140         cookie = spl_fstrans_mark();
 141         error = -zfs_statvfs(dentry->d_inode, statp);
 142         spl_fstrans_unmark(cookie);
 143         ASSERT3S(error, <=, 0);
 144
 145         /*
 146          * If required by a 32-bit system call, dynamically scale the
 147          * block size up to 16MiB and decrease the block counts.  This
 148          * allows for a maximum size of 64EiB to be reported.  The file
 149          * counts must be artificially capped at 2^32-1.
 150          */
 151         if (unlikely(zpl_is_32bit_api())) {
 152                 while (statp->f_blocks > UINT32_MAX &&
 153                     statp->f_bsize < SPA_MAXBLOCKSIZE) {
 154                         statp->f_frsize <<= 1;
 155                         statp->f_bsize <<= 1;
 156
 157                         statp->f_blocks >>= 1;
 158                         statp->f_bfree >>= 1;
 159                         statp->f_bavail >>= 1;
 160                 }
 161
 162                 uint64_t usedobjs = statp->f_files - statp->f_ffree;
 163                 statp->f_ffree = MIN(statp->f_ffree, UINT32_MAX - usedobjs);
 164                 statp->f_files = statp->f_ffree + usedobjs;
 165         }
 166
 167         return (error);
 168 }
 169
 170 static int
 171 zpl_remount_fs(struct super_block *sb, int *flags, char *data)
 172 {
 173         zfs_mnt_t zm = { .mnt_osname = NULL, .mnt_data = data };
 174         fstrans_cookie_t cookie;
 175         int error;
 176
 177         cookie = spl_fstrans_mark();
 178         error = -zfs_remount(sb, flags, &zm);
 179         spl_fstrans_unmark(cookie);
 180         ASSERT3S(error, <=, 0);
 181
 182         return (error);
 183 }
 184
 185 static int
 186 __zpl_show_devname(struct seq_file *seq, zfsvfs_t *zfsvfs)
 187 {
 188         char *fsname;
 189
 190         ZFS_ENTER(zfsvfs);
 191         fsname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
 192         dmu_objset_name(zfsvfs->z_os, fsname);
 193         seq_puts(seq, fsname);
 194         kmem_free(fsname, ZFS_MAX_DATASET_NAME_LEN);
 195         ZFS_EXIT(zfsvfs);
 196
 197         return (0);
 198 }
 199
 200 static int
 201 zpl_show_devname(struct seq_file *seq, struct dentry *root)
 202 {
 203         return (__zpl_show_devname(seq, root->d_sb->s_fs_info));
 204 }
 205
 206 static int
 207 __zpl_show_options(struct seq_file *seq, zfsvfs_t *zfsvfs)
 208 {
 209         seq_printf(seq, ",%s",
 210             zfsvfs->z_flags & ZSB_XATTR ? "xattr" : "noxattr");
 211
 212 #ifdef CONFIG_FS_POSIX_ACL
 213         switch (zfsvfs->z_acl_type) {
 214         case ZFS_ACLTYPE_POSIX:
 215                 seq_puts(seq, ",posixacl");
 216                 break;
 217         default:
 218                 seq_puts(seq, ",noacl");
 219                 break;
 220         }
 221 #endif /* CONFIG_FS_POSIX_ACL */
 222
 223         return (0);
 224 }
 225
 226 static int
 227 zpl_show_options(struct seq_file *seq, struct dentry *root)
 228 {
 229         return (__zpl_show_options(seq, root->d_sb->s_fs_info));
 230 }
 231
 232 static int
 233 zpl_fill_super(struct super_block *sb, void *data, int silent)
 234 {
 235         zfs_mnt_t *zm = (zfs_mnt_t *)data;
 236         fstrans_cookie_t cookie;
 237         int error;
 238
 239         cookie = spl_fstrans_mark();
 240         error = -zfs_domount(sb, zm, silent);
 241         spl_fstrans_unmark(cookie);
 242         ASSERT3S(error, <=, 0);
 243
 244         return (error);
 245 }
 246
 247 static int
 248 zpl_test_super(struct super_block *s, void *data)
 249 {
 250         zfsvfs_t *zfsvfs = s->s_fs_info;
 251         objset_t *os = data;
 252
 253         if (zfsvfs == NULL)
 254                 return (0);
 255
 256         return (os == zfsvfs->z_os);
 257 }
 258
 259 static struct super_block *
 260 zpl_mount_impl(struct file_system_type *fs_type, int flags, zfs_mnt_t *zm)
 261 {
 262         struct super_block *s;
 263         objset_t *os;
 264         int err;
 265
 266         err = dmu_objset_hold(zm->mnt_osname, FTAG, &os);
 267         if (err)
 268                 return (ERR_PTR(-err));
 269
 270         /*
 271          * The dsl pool lock must be released prior to calling sget().
 272          * It is possible sget() may block on the lock in grab_super()
 273          * while deactivate_super() holds that same lock and waits for
 274          * a txg sync.  If the dsl_pool lock is held over sget()
 275          * this can prevent the pool sync and cause a deadlock.
 276          */
 277         dsl_dataset_long_hold(dmu_objset_ds(os), FTAG);
 278         dsl_pool_rele(dmu_objset_pool(os), FTAG);
 279
 280         s = sget(fs_type, zpl_test_super, set_anon_super, flags, os);
 281
 282         dsl_dataset_long_rele(dmu_objset_ds(os), FTAG);
 283         dsl_dataset_rele(dmu_objset_ds(os), FTAG);
 284
 285         if (IS_ERR(s))
 286                 return (ERR_CAST(s));
 287
 288         if (s->s_root == NULL) {
 289                 err = zpl_fill_super(s, zm, flags & SB_SILENT ? 1 : 0);
 290                 if (err) {
 291                         deactivate_locked_super(s);
 292                         return (ERR_PTR(err));
 293                 }
 294                 s->s_flags |= SB_ACTIVE;
 295         } else if ((flags ^ s->s_flags) & SB_RDONLY) {
 296                 deactivate_locked_super(s);
 297                 return (ERR_PTR(-EBUSY));
 298         }
 299
 300         return (s);
 301 }
 302
 303 static struct dentry *
 304 zpl_mount(struct file_system_type *fs_type, int flags,
 305     const char *osname, void *data)
 306 {
 307         zfs_mnt_t zm = { .mnt_osname = osname, .mnt_data = data };
 308
 309         struct super_block *sb = zpl_mount_impl(fs_type, flags, &zm);
 310         if (IS_ERR(sb))
 311                 return (ERR_CAST(sb));
 312
 313         return (dget(sb->s_root));
 314 }
 315
 316 static void
 317 zpl_kill_sb(struct super_block *sb)
 318 {
 319         zfs_preumount(sb);
 320         kill_anon_super(sb);
 321 }
 322
 323 void
 324 zpl_prune_sb(int64_t nr_to_scan, void *arg)
 325 {
 326         struct super_block *sb = (struct super_block *)arg;
 327         int objects = 0;
 328
 329         (void) -zfs_prune(sb, nr_to_scan, &objects);
 330 }
 331
 332 const struct super_operations zpl_super_operations = {
 333         .alloc_inode            = zpl_inode_alloc,
 334         .destroy_inode          = zpl_inode_destroy,
 335         .dirty_inode            = zpl_dirty_inode,
 336         .write_inode            = NULL,
 337         .evict_inode            = zpl_evict_inode,
 338         .put_super              = zpl_put_super,
 339         .sync_fs                = zpl_sync_fs,
 340         .statfs                 = zpl_statfs,
 341         .remount_fs             = zpl_remount_fs,
 342         .show_devname           = zpl_show_devname,
 343         .show_options           = zpl_show_options,
 344         .show_stats             = NULL,
 345 };
 346
 347 struct file_system_type zpl_fs_type = {
 348         .owner                  = THIS_MODULE,
 349         .name                   = ZFS_DRIVER,
 350         .mount                  = zpl_mount,
 351         .kill_sb                = zpl_kill_sb,
 352 };