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.
23 * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
25 * Rewritten for Linux by:
26 * Rohan Puri <rohan.puri15@gmail.com>
27 * Brian Behlendorf <behlendorf1@llnl.gov>
30 #include <sys/zfs_vfsops.h>
31 #include <sys/zfs_vnops.h>
32 #include <sys/zfs_znode.h>
33 #include <sys/zfs_ctldir.h>
37 * Common open routine. Disallow any write access.
41 zpl_common_open(struct inode *ip, struct file *filp)
43 if (filp->f_mode & FMODE_WRITE)
46 return generic_file_open(ip, filp);
50 zpl_common_readdir(struct file *filp, void *dirent, filldir_t filldir)
52 struct dentry *dentry = filp->f_path.dentry;
53 struct inode *ip = dentry->d_inode;
56 switch (filp->f_pos) {
58 error = filldir(dirent, ".", 1, 0, ip->i_ino, DT_DIR);
65 error = filldir(dirent, "..", 2, 1, parent_ino(dentry), DT_DIR);
79 * Get root directory contents.
82 zpl_root_readdir(struct file *filp, void *dirent, filldir_t filldir)
84 struct dentry *dentry = filp->f_path.dentry;
85 struct inode *ip = dentry->d_inode;
86 zfs_sb_t *zsb = ITOZSB(ip);
91 switch (filp->f_pos) {
93 error = filldir(dirent, ".", 1, 0, ip->i_ino, DT_DIR);
100 error = filldir(dirent, "..", 2, 1, parent_ino(dentry), DT_DIR);
107 error = filldir(dirent, ZFS_SNAPDIR_NAME,
108 strlen(ZFS_SNAPDIR_NAME), 2, ZFSCTL_INO_SNAPDIR, DT_DIR);
115 error = filldir(dirent, ZFS_SHAREDIR_NAME,
116 strlen(ZFS_SHAREDIR_NAME), 3, ZFSCTL_INO_SHARES, DT_DIR);
130 * Get root directory attributes.
134 zpl_root_getattr(struct vfsmount *mnt, struct dentry *dentry,
139 error = simple_getattr(mnt, dentry, stat);
140 stat->atime = CURRENT_TIME;
145 static struct dentry *
146 #ifdef HAVE_LOOKUP_NAMEIDATA
147 zpl_root_lookup(struct inode *dip, struct dentry *dentry, struct nameidata *nd)
149 zpl_root_lookup(struct inode *dip, struct dentry *dentry, unsigned int flags)
157 error = -zfsctl_root_lookup(dip, dname(dentry), &ip, 0, cr, NULL, NULL);
158 ASSERT3S(error, <=, 0);
162 if (error == -ENOENT)
163 return d_splice_alias(NULL, dentry);
165 return ERR_PTR(error);
168 return d_splice_alias(ip, dentry);
172 * The '.zfs' control directory file and inode operations.
174 const struct file_operations zpl_fops_root = {
175 .open = zpl_common_open,
176 .llseek = generic_file_llseek,
177 .read = generic_read_dir,
178 .readdir = zpl_root_readdir,
181 const struct inode_operations zpl_ops_root = {
182 .lookup = zpl_root_lookup,
183 .getattr = zpl_root_getattr,
186 #ifdef HAVE_AUTOMOUNT
187 static struct vfsmount *
188 zpl_snapdir_automount(struct path *path)
190 struct dentry *dentry = path->dentry;
194 * We must briefly disable automounts for this dentry because the
195 * user space mount utility will trigger another lookup on this
196 * directory. That will result in zpl_snapdir_automount() being
197 * called repeatedly. The DCACHE_NEED_AUTOMOUNT flag can be
198 * safely reset once the mount completes.
200 dentry->d_flags &= ~DCACHE_NEED_AUTOMOUNT;
201 error = -zfsctl_mount_snapshot(path, 0);
202 dentry->d_flags |= DCACHE_NEED_AUTOMOUNT;
204 return ERR_PTR(error);
207 * Rather than returning the new vfsmount for the snapshot we must
208 * return NULL to indicate a mount collision. This is done because
209 * the user space mount calls do_add_mount() which adds the vfsmount
210 * to the name space. If we returned the new mount here it would be
211 * added again to the vfsmount list resulting in list corruption.
215 #endif /* HAVE_AUTOMOUNT */
218 * Revalidate any dentry in the snapshot directory on lookup, since a snapshot
219 * having the same name have been created or destroyed since it was cached.
222 #ifdef HAVE_D_REVALIDATE_NAMEIDATA
223 zpl_snapdir_revalidate(struct dentry *dentry, struct nameidata *i)
225 zpl_snapdir_revalidate(struct dentry *dentry, unsigned int flags)
231 dentry_operations_t zpl_dops_snapdirs = {
233 * Auto mounting of snapshots is only supported for 2.6.37 and
234 * newer kernels. Prior to this kernel the ops->follow_link()
235 * callback was used as a hack to trigger the mount. The
236 * resulting vfsmount was then explicitly grafted in to the
237 * name space. While it might be possible to add compatibility
238 * code to accomplish this it would require considerable care.
240 #ifdef HAVE_AUTOMOUNT
241 .d_automount = zpl_snapdir_automount,
242 #endif /* HAVE_AUTOMOUNT */
243 .d_revalidate = zpl_snapdir_revalidate,
246 static struct dentry *
247 #ifdef HAVE_LOOKUP_NAMEIDATA
248 zpl_snapdir_lookup(struct inode *dip, struct dentry *dentry,
249 struct nameidata *nd)
251 zpl_snapdir_lookup(struct inode *dip, struct dentry *dentry,
257 struct inode *ip = NULL;
261 error = -zfsctl_snapdir_lookup(dip, dname(dentry), &ip,
263 ASSERT3S(error, <=, 0);
266 if (error && error != -ENOENT)
267 return ERR_PTR(error);
269 ASSERT(error == 0 || ip == NULL);
270 d_clear_d_op(dentry);
271 d_set_d_op(dentry, &zpl_dops_snapdirs);
273 return d_splice_alias(ip, dentry);
278 zpl_snapdir_readdir(struct file *filp, void *dirent, filldir_t filldir)
280 struct dentry *dentry = filp->f_path.dentry;
281 struct inode *dip = dentry->d_inode;
282 zfs_sb_t *zsb = ITOZSB(dip);
283 char snapname[MAXNAMELEN];
285 boolean_t case_conflict;
290 cookie = filp->f_pos;
291 switch (filp->f_pos) {
293 error = filldir(dirent, ".", 1, 0, dip->i_ino, DT_DIR);
300 error = filldir(dirent, "..", 2, 1, parent_ino(dentry), DT_DIR);
308 error = -dmu_snapshot_list_next(zsb->z_os, MAXNAMELEN,
309 snapname, &id, &cookie, &case_conflict);
313 error = filldir(dirent, snapname, strlen(snapname),
314 filp->f_pos, ZFSCTL_INO_SHARES - id, DT_DIR);
318 filp->f_pos = cookie;
324 if (error == -ENOENT)
331 zpl_snapdir_rename(struct inode *sdip, struct dentry *sdentry,
332 struct inode *tdip, struct dentry *tdentry)
338 error = -zfsctl_snapdir_rename(sdip, dname(sdentry),
339 tdip, dname(tdentry), cr, 0);
340 ASSERT3S(error, <=, 0);
347 zpl_snapdir_rmdir(struct inode *dip, struct dentry *dentry)
353 error = -zfsctl_snapdir_remove(dip, dname(dentry), cr, 0);
354 ASSERT3S(error, <=, 0);
361 zpl_snapdir_mkdir(struct inode *dip, struct dentry *dentry, zpl_umode_t mode)
369 vap = kmem_zalloc(sizeof(vattr_t), KM_SLEEP);
370 zpl_vap_init(vap, dip, mode | S_IFDIR, cr);
372 error = -zfsctl_snapdir_mkdir(dip, dname(dentry), vap, &ip, cr, 0);
374 d_clear_d_op(dentry);
375 d_set_d_op(dentry, &zpl_dops_snapdirs);
376 d_instantiate(dentry, ip);
379 kmem_free(vap, sizeof(vattr_t));
380 ASSERT3S(error, <=, 0);
387 * Get snapshot directory attributes.
391 zpl_snapdir_getattr(struct vfsmount *mnt, struct dentry *dentry,
394 zfs_sb_t *zsb = ITOZSB(dentry->d_inode);
398 error = simple_getattr(mnt, dentry, stat);
399 stat->nlink = stat->size = avl_numnodes(&zsb->z_ctldir_snaps) + 2;
400 stat->ctime = stat->mtime = dmu_objset_snap_cmtime(zsb->z_os);
401 stat->atime = CURRENT_TIME;
408 * The '.zfs/snapshot' directory file operations. These mainly control
409 * generating the list of available snapshots when doing an 'ls' in the
410 * directory. See zpl_snapdir_readdir().
412 const struct file_operations zpl_fops_snapdir = {
413 .open = zpl_common_open,
414 .llseek = generic_file_llseek,
415 .read = generic_read_dir,
416 .readdir = zpl_snapdir_readdir,
420 * The '.zfs/snapshot' directory inode operations. These mainly control
421 * creating an inode for a snapshot directory and initializing the needed
422 * infrastructure to automount the snapshot. See zpl_snapdir_lookup().
424 const struct inode_operations zpl_ops_snapdir = {
425 .lookup = zpl_snapdir_lookup,
426 .getattr = zpl_snapdir_getattr,
427 .rename = zpl_snapdir_rename,
428 .rmdir = zpl_snapdir_rmdir,
429 .mkdir = zpl_snapdir_mkdir,
432 static struct dentry *
433 #ifdef HAVE_LOOKUP_NAMEIDATA
434 zpl_shares_lookup(struct inode *dip, struct dentry *dentry,
435 struct nameidata *nd)
437 zpl_shares_lookup(struct inode *dip, struct dentry *dentry,
442 struct inode *ip = NULL;
446 error = -zfsctl_shares_lookup(dip, dname(dentry), &ip,
448 ASSERT3S(error, <=, 0);
452 if (error == -ENOENT)
453 return d_splice_alias(NULL, dentry);
455 return ERR_PTR(error);
458 return d_splice_alias(ip, dentry);
463 zpl_shares_readdir(struct file *filp, void *dirent, filldir_t filldir)
466 struct dentry *dentry = filp->f_path.dentry;
467 struct inode *ip = dentry->d_inode;
468 zfs_sb_t *zsb = ITOZSB(ip);
474 if (zsb->z_shares_dir == 0) {
475 error = zpl_common_readdir(filp, dirent, filldir);
480 error = -zfs_zget(zsb, zsb->z_shares_dir, &dzp);
487 error = -zfs_readdir(ZTOI(dzp), dirent, filldir, &filp->f_pos, cr);
492 ASSERT3S(error, <=, 0);
499 zpl_shares_getattr(struct vfsmount *mnt, struct dentry *dentry,
502 struct inode *ip = dentry->d_inode;
503 zfs_sb_t *zsb = ITOZSB(ip);
509 if (zsb->z_shares_dir == 0) {
510 error = simple_getattr(mnt, dentry, stat);
511 stat->nlink = stat->size = 2;
512 stat->atime = CURRENT_TIME;
517 error = -zfs_zget(zsb, zsb->z_shares_dir, &dzp);
519 error = -zfs_getattr_fast(dentry->d_inode, stat);
523 ASSERT3S(error, <=, 0);
529 * The '.zfs/shares' directory file operations.
531 const struct file_operations zpl_fops_shares = {
532 .open = zpl_common_open,
533 .llseek = generic_file_llseek,
534 .read = generic_read_dir,
535 .readdir = zpl_shares_readdir,
539 * The '.zfs/shares' directory inode operations.
541 const struct inode_operations zpl_ops_shares = {
542 .lookup = zpl_shares_lookup,
543 .getattr = zpl_shares_getattr,