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         ZPL_ENTER(zfsvfs);
 189
 190         char *fsname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
 191         dmu_objset_name(zfsvfs->z_os, fsname);
 192
 193         for (int i = 0; fsname[i] != 0; i++) {
 194                 /*
 195                  * Spaces in the dataset name must be converted to their
 196                  * octal escape sequence for getmntent(3) to correctly
 197                  * parse then fsname portion of /proc/self/mounts.
 198                  */
 199                 if (fsname[i] == ' ') {
 200                         seq_puts(seq, "\\040");
 201                 } else {
 202                         seq_putc(seq, fsname[i]);
 203                 }
 204         }
 205
 206         kmem_free(fsname, ZFS_MAX_DATASET_NAME_LEN);
 207
 208         ZPL_EXIT(zfsvfs);
 209
 210         return (0);
 211 }
 212
 213 static int
 214 zpl_show_devname(struct seq_file *seq, struct dentry *root)
 215 {
 216         return (__zpl_show_devname(seq, root->d_sb->s_fs_info));
 217 }
 218
 219 static int
 220 __zpl_show_options(struct seq_file *seq, zfsvfs_t *zfsvfs)
 221 {
 222         seq_printf(seq, ",%s",
 223             zfsvfs->z_flags & ZSB_XATTR ? "xattr" : "noxattr");
 224
 225 #ifdef CONFIG_FS_POSIX_ACL
 226         switch (zfsvfs->z_acl_type) {
 227         case ZFS_ACLTYPE_POSIX:
 228                 seq_puts(seq, ",posixacl");
 229                 break;
 230         default:
 231                 seq_puts(seq, ",noacl");
 232                 break;
 233         }
 234 #endif /* CONFIG_FS_POSIX_ACL */
 235
 236         return (0);
 237 }
 238
 239 static int
 240 zpl_show_options(struct seq_file *seq, struct dentry *root)
 241 {
 242         return (__zpl_show_options(seq, root->d_sb->s_fs_info));
 243 }
 244
 245 static int
 246 zpl_fill_super(struct super_block *sb, void *data, int silent)
 247 {
 248         zfs_mnt_t *zm = (zfs_mnt_t *)data;
 249         fstrans_cookie_t cookie;
 250         int error;
 251
 252         cookie = spl_fstrans_mark();
 253         error = -zfs_domount(sb, zm, silent);
 254         spl_fstrans_unmark(cookie);
 255         ASSERT3S(error, <=, 0);
 256
 257         return (error);
 258 }
 259
 260 static int
 261 zpl_test_super(struct super_block *s, void *data)
 262 {
 263         zfsvfs_t *zfsvfs = s->s_fs_info;
 264         objset_t *os = data;
 265
 266         if (zfsvfs == NULL)
 267                 return (0);
 268
 269         return (os == zfsvfs->z_os);
 270 }
 271
 272 static struct super_block *
 273 zpl_mount_impl(struct file_system_type *fs_type, int flags, zfs_mnt_t *zm)
 274 {
 275         struct super_block *s;
 276         objset_t *os;
 277         int err;
 278
 279         err = dmu_objset_hold(zm->mnt_osname, FTAG, &os);
 280         if (err)
 281                 return (ERR_PTR(-err));
 282
 283         /*
 284          * The dsl pool lock must be released prior to calling sget().
 285          * It is possible sget() may block on the lock in grab_super()
 286          * while deactivate_super() holds that same lock and waits for
 287          * a txg sync.  If the dsl_pool lock is held over sget()
 288          * this can prevent the pool sync and cause a deadlock.
 289          */
 290         dsl_dataset_long_hold(dmu_objset_ds(os), FTAG);
 291         dsl_pool_rele(dmu_objset_pool(os), FTAG);
 292
 293         s = sget(fs_type, zpl_test_super, set_anon_super, flags, os);
 294
 295         dsl_dataset_long_rele(dmu_objset_ds(os), FTAG);
 296         dsl_dataset_rele(dmu_objset_ds(os), FTAG);
 297
 298         if (IS_ERR(s))
 299                 return (ERR_CAST(s));
 300
 301         if (s->s_root == NULL) {
 302                 err = zpl_fill_super(s, zm, flags & SB_SILENT ? 1 : 0);
 303                 if (err) {
 304                         deactivate_locked_super(s);
 305                         return (ERR_PTR(err));
 306                 }
 307                 s->s_flags |= SB_ACTIVE;
 308         } else if ((flags ^ s->s_flags) & SB_RDONLY) {
 309                 deactivate_locked_super(s);
 310                 return (ERR_PTR(-EBUSY));
 311         }
 312
 313         return (s);
 314 }
 315
 316 static struct dentry *
 317 zpl_mount(struct file_system_type *fs_type, int flags,
 318     const char *osname, void *data)
 319 {
 320         zfs_mnt_t zm = { .mnt_osname = osname, .mnt_data = data };
 321
 322         struct super_block *sb = zpl_mount_impl(fs_type, flags, &zm);
 323         if (IS_ERR(sb))
 324                 return (ERR_CAST(sb));
 325
 326         return (dget(sb->s_root));
 327 }
 328
 329 static void
 330 zpl_kill_sb(struct super_block *sb)
 331 {
 332         zfs_preumount(sb);
 333         kill_anon_super(sb);
 334 }
 335
 336 void
 337 zpl_prune_sb(int64_t nr_to_scan, void *arg)
 338 {
 339         struct super_block *sb = (struct super_block *)arg;
 340         int objects = 0;
 341
 342         (void) -zfs_prune(sb, nr_to_scan, &objects);
 343 }
 344
 345 const struct super_operations zpl_super_operations = {
 346         .alloc_inode            = zpl_inode_alloc,
 347         .destroy_inode          = zpl_inode_destroy,
 348         .dirty_inode            = zpl_dirty_inode,
 349         .write_inode            = NULL,
 350         .evict_inode            = zpl_evict_inode,
 351         .put_super              = zpl_put_super,
 352         .sync_fs                = zpl_sync_fs,
 353         .statfs                 = zpl_statfs,
 354         .remount_fs             = zpl_remount_fs,
 355         .show_devname           = zpl_show_devname,
 356         .show_options           = zpl_show_options,
 357         .show_stats             = NULL,
 358 };
 359
 360 struct file_system_type zpl_fs_type = {
 361         .owner                  = THIS_MODULE,
 362         .name                   = ZFS_DRIVER,
 363         .mount                  = zpl_mount,
 364         .kill_sb                = zpl_kill_sb,
 365 };