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.
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.
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]
22 * Copyright (c) 2011, Lawrence Livermore National Security, LLC.
26 #include <sys/zfs_vfsops.h>
27 #include <sys/zfs_vnops.h>
28 #include <sys/zfs_znode.h>
29 #include <sys/zfs_ctldir.h>
34 zpl_inode_alloc(struct super_block *sb)
38 VERIFY3S(zfs_inode_alloc(sb, &ip), ==, 0);
45 zpl_inode_destroy(struct inode *ip)
47 ASSERT(atomic_read(&ip->i_count) == 0);
48 zfs_inode_destroy(ip);
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.
56 #ifdef HAVE_DIRTY_INODE_WITH_FLAGS
58 zpl_dirty_inode(struct inode *ip, int flags)
60 fstrans_cookie_t cookie;
62 cookie = spl_fstrans_mark();
63 zfs_dirty_inode(ip, flags);
64 spl_fstrans_unmark(cookie);
68 zpl_dirty_inode(struct inode *ip)
70 fstrans_cookie_t cookie;
72 cookie = spl_fstrans_mark();
73 zfs_dirty_inode(ip, 0);
74 spl_fstrans_unmark(cookie);
76 #endif /* HAVE_DIRTY_INODE_WITH_FLAGS */
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
84 * Prior to 2.6.36 this eviction was accomplished by the vfs calling
85 * ->delete_inode(). It was ->delete_inode()'s responsibility to
86 * truncate the inode pages and call clear_inode(). The call to
87 * clear_inode() synchronously invalidates all the buffers and
88 * calls ->clear_inode(). It was ->clear_inode()'s responsibility
89 * to cleanup and filesystem specific data before freeing the inode.
91 * This elaborate mechanism was replaced by ->evict_inode() which
92 * does the job of both ->delete_inode() and ->clear_inode(). It
93 * will be called exactly once, and when it returns the inode must
94 * be in a state where it can simply be freed.i
96 * The ->evict_inode() callback must minimally truncate the inode pages,
97 * and call clear_inode(). For 2.6.35 and later kernels this will
98 * simply update the inode state, with the sync occurring before the
99 * truncate in evict(). For earlier kernels clear_inode() maps to
100 * end_writeback() which is responsible for completing all outstanding
101 * write back. In either case, once this is done it is safe to cleanup
102 * any remaining inode specific data via zfs_inactive().
103 * remaining filesystem specific data.
105 #ifdef HAVE_EVICT_INODE
107 zpl_evict_inode(struct inode *ip)
109 fstrans_cookie_t cookie;
111 cookie = spl_fstrans_mark();
112 truncate_setsize(ip, 0);
115 spl_fstrans_unmark(cookie);
121 zpl_drop_inode(struct inode *ip)
123 generic_delete_inode(ip);
127 zpl_clear_inode(struct inode *ip)
129 fstrans_cookie_t cookie;
131 cookie = spl_fstrans_mark();
133 spl_fstrans_unmark(cookie);
137 zpl_inode_delete(struct inode *ip)
139 truncate_setsize(ip, 0);
142 #endif /* HAVE_EVICT_INODE */
145 zpl_put_super(struct super_block *sb)
147 fstrans_cookie_t cookie;
150 cookie = spl_fstrans_mark();
151 error = -zfs_umount(sb);
152 spl_fstrans_unmark(cookie);
153 ASSERT3S(error, <=, 0);
157 zpl_sync_fs(struct super_block *sb, int wait)
159 fstrans_cookie_t cookie;
164 cookie = spl_fstrans_mark();
165 error = -zfs_sync(sb, wait, cr);
166 spl_fstrans_unmark(cookie);
168 ASSERT3S(error, <=, 0);
174 zpl_statfs(struct dentry *dentry, struct kstatfs *statp)
176 fstrans_cookie_t cookie;
179 cookie = spl_fstrans_mark();
180 error = -zfs_statvfs(dentry, statp);
181 spl_fstrans_unmark(cookie);
182 ASSERT3S(error, <=, 0);
210 static const match_table_t zpl_tokens = {
211 { TOKEN_RO, MNTOPT_RO },
212 { TOKEN_RW, MNTOPT_RW },
213 { TOKEN_SETUID, MNTOPT_SETUID },
214 { TOKEN_NOSETUID, MNTOPT_NOSETUID },
215 { TOKEN_EXEC, MNTOPT_EXEC },
216 { TOKEN_NOEXEC, MNTOPT_NOEXEC },
217 { TOKEN_DEVICES, MNTOPT_DEVICES },
218 { TOKEN_NODEVICES, MNTOPT_NODEVICES },
219 { TOKEN_DIRXATTR, MNTOPT_DIRXATTR },
220 { TOKEN_SAXATTR, MNTOPT_SAXATTR },
221 { TOKEN_XATTR, MNTOPT_XATTR },
222 { TOKEN_NOXATTR, MNTOPT_NOXATTR },
223 { TOKEN_ATIME, MNTOPT_ATIME },
224 { TOKEN_NOATIME, MNTOPT_NOATIME },
225 { TOKEN_RELATIME, MNTOPT_RELATIME },
226 { TOKEN_NORELATIME, MNTOPT_NORELATIME },
227 { TOKEN_NBMAND, MNTOPT_NBMAND },
228 { TOKEN_NONBMAND, MNTOPT_NONBMAND },
229 { TOKEN_MNTPOINT, MNTOPT_MNTPOINT "=%s" },
230 { TOKEN_LAST, NULL },
234 zpl_parse_option(char *option, int token, substring_t *args, zfs_mntopts_t *zmo)
238 zmo->z_readonly = B_TRUE;
239 zmo->z_do_readonly = B_TRUE;
242 zmo->z_readonly = B_FALSE;
243 zmo->z_do_readonly = B_TRUE;
246 zmo->z_setuid = B_TRUE;
247 zmo->z_do_setuid = B_TRUE;
250 zmo->z_setuid = B_FALSE;
251 zmo->z_do_setuid = B_TRUE;
254 zmo->z_exec = B_TRUE;
255 zmo->z_do_exec = B_TRUE;
258 zmo->z_exec = B_FALSE;
259 zmo->z_do_exec = B_TRUE;
262 zmo->z_devices = B_TRUE;
263 zmo->z_do_devices = B_TRUE;
265 case TOKEN_NODEVICES:
266 zmo->z_devices = B_FALSE;
267 zmo->z_do_devices = B_TRUE;
270 zmo->z_xattr = ZFS_XATTR_DIR;
271 zmo->z_do_xattr = B_TRUE;
274 zmo->z_xattr = ZFS_XATTR_SA;
275 zmo->z_do_xattr = B_TRUE;
278 zmo->z_xattr = ZFS_XATTR_DIR;
279 zmo->z_do_xattr = B_TRUE;
282 zmo->z_xattr = ZFS_XATTR_OFF;
283 zmo->z_do_xattr = B_TRUE;
286 zmo->z_atime = B_TRUE;
287 zmo->z_do_atime = B_TRUE;
290 zmo->z_atime = B_FALSE;
291 zmo->z_do_atime = B_TRUE;
294 zmo->z_relatime = B_TRUE;
295 zmo->z_do_relatime = B_TRUE;
297 case TOKEN_NORELATIME:
298 zmo->z_relatime = B_FALSE;
299 zmo->z_do_relatime = B_TRUE;
302 zmo->z_nbmand = B_TRUE;
303 zmo->z_do_nbmand = B_TRUE;
306 zmo->z_nbmand = B_FALSE;
307 zmo->z_do_nbmand = B_TRUE;
310 zmo->z_mntpoint = match_strdup(&args[0]);
311 if (zmo->z_mntpoint == NULL)
323 * Parse the mntopts string storing the results in provided zmo argument.
324 * If an error occurs the zmo argument will not be modified. The caller
325 * needs to set isremount when recycling an existing zfs_mntopts_t.
328 zpl_parse_options(char *osname, char *mntopts, zfs_mntopts_t *zmo,
331 zfs_mntopts_t *tmp_zmo;
334 tmp_zmo = zfs_mntopts_alloc();
335 tmp_zmo->z_osname = strdup(osname);
338 substring_t args[MAX_OPT_ARGS];
339 char *tmp_mntopts, *p;
342 tmp_mntopts = strdup(mntopts);
344 while ((p = strsep(&tmp_mntopts, ",")) != NULL) {
348 args[0].to = args[0].from = NULL;
349 token = match_token(p, zpl_tokens, args);
350 error = zpl_parse_option(p, token, args, tmp_zmo);
352 zfs_mntopts_free(tmp_zmo);
353 strfree(tmp_mntopts);
358 strfree(tmp_mntopts);
361 if (isremount == B_TRUE) {
363 strfree(zmo->z_osname);
366 strfree(zmo->z_mntpoint);
368 ASSERT3P(zmo->z_osname, ==, NULL);
369 ASSERT3P(zmo->z_mntpoint, ==, NULL);
372 memcpy(zmo, tmp_zmo, sizeof (zfs_mntopts_t));
373 kmem_free(tmp_zmo, sizeof (zfs_mntopts_t));
379 zpl_remount_fs(struct super_block *sb, int *flags, char *data)
381 zfs_sb_t *zsb = sb->s_fs_info;
382 fstrans_cookie_t cookie;
385 error = zpl_parse_options(zsb->z_mntopts->z_osname, data,
386 zsb->z_mntopts, B_TRUE);
390 cookie = spl_fstrans_mark();
391 error = -zfs_remount(sb, flags, zsb->z_mntopts);
392 spl_fstrans_unmark(cookie);
393 ASSERT3S(error, <=, 0);
399 __zpl_show_options(struct seq_file *seq, zfs_sb_t *zsb)
401 seq_printf(seq, ",%s", zsb->z_flags & ZSB_XATTR ? "xattr" : "noxattr");
403 #ifdef CONFIG_FS_POSIX_ACL
404 switch (zsb->z_acl_type) {
405 case ZFS_ACLTYPE_POSIXACL:
406 seq_puts(seq, ",posixacl");
409 seq_puts(seq, ",noacl");
412 #endif /* CONFIG_FS_POSIX_ACL */
417 #ifdef HAVE_SHOW_OPTIONS_WITH_DENTRY
419 zpl_show_options(struct seq_file *seq, struct dentry *root)
421 return (__zpl_show_options(seq, root->d_sb->s_fs_info));
425 zpl_show_options(struct seq_file *seq, struct vfsmount *vfsp)
427 return (__zpl_show_options(seq, vfsp->mnt_sb->s_fs_info));
429 #endif /* HAVE_SHOW_OPTIONS_WITH_DENTRY */
432 zpl_fill_super(struct super_block *sb, void *data, int silent)
434 zfs_mntopts_t *zmo = (zfs_mntopts_t *)data;
435 fstrans_cookie_t cookie;
438 cookie = spl_fstrans_mark();
439 error = -zfs_domount(sb, zmo, silent);
440 spl_fstrans_unmark(cookie);
441 ASSERT3S(error, <=, 0);
446 #ifdef HAVE_MOUNT_NODEV
447 static struct dentry *
448 zpl_mount(struct file_system_type *fs_type, int flags,
449 const char *osname, void *data)
451 zfs_mntopts_t *zmo = zfs_mntopts_alloc();
454 error = zpl_parse_options((char *)osname, (char *)data, zmo, B_FALSE);
456 zfs_mntopts_free(zmo);
457 return (ERR_PTR(error));
460 return (mount_nodev(fs_type, flags, zmo, zpl_fill_super));
464 zpl_get_sb(struct file_system_type *fs_type, int flags,
465 const char *osname, void *data, struct vfsmount *mnt)
467 zfs_mntopts_t *zmo = zfs_mntopts_alloc();
470 error = zpl_parse_options((char *)osname, (char *)data, zmo, B_FALSE);
472 zfs_mntopts_free(zmo);
476 return (get_sb_nodev(fs_type, flags, zmo, zpl_fill_super, mnt));
478 #endif /* HAVE_MOUNT_NODEV */
481 zpl_kill_sb(struct super_block *sb)
486 #ifdef HAVE_S_INSTANCES_LIST_HEAD
487 sb->s_instances.next = &(zpl_fs_type.fs_supers);
488 #endif /* HAVE_S_INSTANCES_LIST_HEAD */
492 zpl_prune_sb(int64_t nr_to_scan, void *arg)
494 struct super_block *sb = (struct super_block *)arg;
497 (void) -zfs_sb_prune(sb, nr_to_scan, &objects);
500 #ifdef HAVE_NR_CACHED_OBJECTS
502 zpl_nr_cached_objects(struct super_block *sb)
504 zfs_sb_t *zsb = sb->s_fs_info;
507 mutex_enter(&zsb->z_znodes_lock);
508 nr = zsb->z_nr_znodes;
509 mutex_exit(&zsb->z_znodes_lock);
513 #endif /* HAVE_NR_CACHED_OBJECTS */
515 #ifdef HAVE_FREE_CACHED_OBJECTS
517 * Attempt to evict some meta data from the cache. The ARC operates in
518 * terms of bytes while the Linux VFS uses objects. Now because this is
519 * just a best effort eviction and the exact values aren't critical so we
520 * extrapolate from an object count to a byte size using the znode_t size.
523 zpl_free_cached_objects(struct super_block *sb, int nr_to_scan)
527 #endif /* HAVE_FREE_CACHED_OBJECTS */
529 const struct super_operations zpl_super_operations = {
530 .alloc_inode = zpl_inode_alloc,
531 .destroy_inode = zpl_inode_destroy,
532 .dirty_inode = zpl_dirty_inode,
534 #ifdef HAVE_EVICT_INODE
535 .evict_inode = zpl_evict_inode,
537 .drop_inode = zpl_drop_inode,
538 .clear_inode = zpl_clear_inode,
539 .delete_inode = zpl_inode_delete,
540 #endif /* HAVE_EVICT_INODE */
541 .put_super = zpl_put_super,
542 .sync_fs = zpl_sync_fs,
543 .statfs = zpl_statfs,
544 .remount_fs = zpl_remount_fs,
545 .show_options = zpl_show_options,
547 #ifdef HAVE_NR_CACHED_OBJECTS
548 .nr_cached_objects = zpl_nr_cached_objects,
549 #endif /* HAVE_NR_CACHED_OBJECTS */
550 #ifdef HAVE_FREE_CACHED_OBJECTS
551 .free_cached_objects = zpl_free_cached_objects,
552 #endif /* HAVE_FREE_CACHED_OBJECTS */
555 struct file_system_type zpl_fs_type = {
556 .owner = THIS_MODULE,
558 #ifdef HAVE_MOUNT_NODEV
561 .get_sb = zpl_get_sb,
562 #endif /* HAVE_MOUNT_NODEV */
563 .kill_sb = zpl_kill_sb,