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
, *t
;
342 t
= tmp_mntopts
= strdup(mntopts
);
344 while ((p
= strsep(&t
, ",")) != 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
)
506 #endif /* HAVE_NR_CACHED_OBJECTS */
508 #ifdef HAVE_FREE_CACHED_OBJECTS
510 zpl_free_cached_objects(struct super_block
*sb
, int nr_to_scan
)
514 #endif /* HAVE_FREE_CACHED_OBJECTS */
516 const struct super_operations zpl_super_operations
= {
517 .alloc_inode
= zpl_inode_alloc
,
518 .destroy_inode
= zpl_inode_destroy
,
519 .dirty_inode
= zpl_dirty_inode
,
521 #ifdef HAVE_EVICT_INODE
522 .evict_inode
= zpl_evict_inode
,
524 .drop_inode
= zpl_drop_inode
,
525 .clear_inode
= zpl_clear_inode
,
526 .delete_inode
= zpl_inode_delete
,
527 #endif /* HAVE_EVICT_INODE */
528 .put_super
= zpl_put_super
,
529 .sync_fs
= zpl_sync_fs
,
530 .statfs
= zpl_statfs
,
531 .remount_fs
= zpl_remount_fs
,
532 .show_options
= zpl_show_options
,
534 #ifdef HAVE_NR_CACHED_OBJECTS
535 .nr_cached_objects
= zpl_nr_cached_objects
,
536 #endif /* HAVE_NR_CACHED_OBJECTS */
537 #ifdef HAVE_FREE_CACHED_OBJECTS
538 .free_cached_objects
= zpl_free_cached_objects
,
539 #endif /* HAVE_FREE_CACHED_OBJECTS */
542 struct file_system_type zpl_fs_type
= {
543 .owner
= THIS_MODULE
,
545 #ifdef HAVE_MOUNT_NODEV
548 .get_sb
= zpl_get_sb
,
549 #endif /* HAVE_MOUNT_NODEV */
550 .kill_sb
= zpl_kill_sb
,