Christoph Hellwig | e38f981 | 2007-10-21 16:42:19 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) Neil Brown 2002 |
| 3 | * Copyright (C) Christoph Hellwig 2007 |
| 4 | * |
| 5 | * This file contains the code mapping from inodes to NFS file handles, |
| 6 | * and for mapping back from file handles to dentries. |
| 7 | * |
| 8 | * For details on why we do all the strange and hairy things in here |
J. Bruce Fields | dc7a081 | 2009-10-27 14:41:35 -0400 | [diff] [blame] | 9 | * take a look at Documentation/filesystems/nfs/Exporting. |
Christoph Hellwig | e38f981 | 2007-10-21 16:42:19 -0700 | [diff] [blame] | 10 | */ |
Christoph Hellwig | a569425 | 2007-07-17 04:04:28 -0700 | [diff] [blame] | 11 | #include <linux/exportfs.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | #include <linux/fs.h> |
| 13 | #include <linux/file.h> |
| 14 | #include <linux/module.h> |
Christoph Hellwig | d37065c | 2007-07-17 04:04:30 -0700 | [diff] [blame] | 15 | #include <linux/mount.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 16 | #include <linux/namei.h> |
David Howells | 745ca24 | 2008-11-14 10:39:22 +1100 | [diff] [blame] | 17 | #include <linux/sched.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | #define dprintk(fmt, args...) do{}while(0) |
| 20 | |
Christoph Hellwig | 10f11c3 | 2007-07-17 04:04:31 -0700 | [diff] [blame] | 21 | |
Christoph Hellwig | e38f981 | 2007-10-21 16:42:19 -0700 | [diff] [blame] | 22 | static int get_name(struct vfsmount *mnt, struct dentry *dentry, char *name, |
Christoph Hellwig | 10f11c3 | 2007-07-17 04:04:31 -0700 | [diff] [blame] | 23 | struct dentry *child); |
| 24 | |
| 25 | |
Christoph Hellwig | e38f981 | 2007-10-21 16:42:19 -0700 | [diff] [blame] | 26 | static int exportfs_get_name(struct vfsmount *mnt, struct dentry *dir, |
| 27 | char *name, struct dentry *child) |
Christoph Hellwig | 10f11c3 | 2007-07-17 04:04:31 -0700 | [diff] [blame] | 28 | { |
Christoph Hellwig | 3965516 | 2007-10-21 16:42:17 -0700 | [diff] [blame] | 29 | const struct export_operations *nop = dir->d_sb->s_export_op; |
Christoph Hellwig | 10f11c3 | 2007-07-17 04:04:31 -0700 | [diff] [blame] | 30 | |
| 31 | if (nop->get_name) |
| 32 | return nop->get_name(dir, name, child); |
| 33 | else |
Christoph Hellwig | e38f981 | 2007-10-21 16:42:19 -0700 | [diff] [blame] | 34 | return get_name(mnt, dir, name, child); |
Christoph Hellwig | 10f11c3 | 2007-07-17 04:04:31 -0700 | [diff] [blame] | 35 | } |
| 36 | |
Christoph Hellwig | fb66a19 | 2007-07-17 04:04:32 -0700 | [diff] [blame] | 37 | /* |
| 38 | * Check if the dentry or any of it's aliases is acceptable. |
| 39 | */ |
Christoph Hellwig | e2f9901 | 2006-01-18 17:43:52 -0800 | [diff] [blame] | 40 | static struct dentry * |
| 41 | find_acceptable_alias(struct dentry *result, |
| 42 | int (*acceptable)(void *context, struct dentry *dentry), |
| 43 | void *context) |
| 44 | { |
| 45 | struct dentry *dentry, *toput = NULL; |
Nick Piggin | 873feea | 2011-01-07 17:50:06 +1100 | [diff] [blame] | 46 | struct inode *inode; |
Al Viro | b3d9b7a | 2012-06-09 13:51:19 -0400 | [diff] [blame] | 47 | struct hlist_node *p; |
Christoph Hellwig | e2f9901 | 2006-01-18 17:43:52 -0800 | [diff] [blame] | 48 | |
Christoph Hellwig | fb66a19 | 2007-07-17 04:04:32 -0700 | [diff] [blame] | 49 | if (acceptable(context, result)) |
| 50 | return result; |
| 51 | |
Nick Piggin | 873feea | 2011-01-07 17:50:06 +1100 | [diff] [blame] | 52 | inode = result->d_inode; |
| 53 | spin_lock(&inode->i_lock); |
Al Viro | b3d9b7a | 2012-06-09 13:51:19 -0400 | [diff] [blame] | 54 | hlist_for_each_entry(dentry, p, &inode->i_dentry, d_alias) { |
Nick Piggin | dc0474b | 2011-01-07 17:49:43 +1100 | [diff] [blame] | 55 | dget(dentry); |
Nick Piggin | 873feea | 2011-01-07 17:50:06 +1100 | [diff] [blame] | 56 | spin_unlock(&inode->i_lock); |
Christoph Hellwig | e2f9901 | 2006-01-18 17:43:52 -0800 | [diff] [blame] | 57 | if (toput) |
| 58 | dput(toput); |
| 59 | if (dentry != result && acceptable(context, dentry)) { |
| 60 | dput(result); |
| 61 | return dentry; |
| 62 | } |
Nick Piggin | 873feea | 2011-01-07 17:50:06 +1100 | [diff] [blame] | 63 | spin_lock(&inode->i_lock); |
Christoph Hellwig | e2f9901 | 2006-01-18 17:43:52 -0800 | [diff] [blame] | 64 | toput = dentry; |
| 65 | } |
Nick Piggin | 873feea | 2011-01-07 17:50:06 +1100 | [diff] [blame] | 66 | spin_unlock(&inode->i_lock); |
Christoph Hellwig | e2f9901 | 2006-01-18 17:43:52 -0800 | [diff] [blame] | 67 | |
| 68 | if (toput) |
| 69 | dput(toput); |
| 70 | return NULL; |
| 71 | } |
| 72 | |
Christoph Hellwig | dd90b50 | 2007-07-17 04:04:32 -0700 | [diff] [blame] | 73 | /* |
| 74 | * Find root of a disconnected subtree and return a reference to it. |
| 75 | */ |
| 76 | static struct dentry * |
| 77 | find_disconnected_root(struct dentry *dentry) |
| 78 | { |
| 79 | dget(dentry); |
Christoph Hellwig | 0461ee2 | 2010-10-13 11:56:37 -0400 | [diff] [blame] | 80 | while (!IS_ROOT(dentry)) { |
| 81 | struct dentry *parent = dget_parent(dentry); |
| 82 | |
| 83 | if (!(parent->d_flags & DCACHE_DISCONNECTED)) { |
| 84 | dput(parent); |
| 85 | break; |
| 86 | } |
| 87 | |
Christoph Hellwig | dd90b50 | 2007-07-17 04:04:32 -0700 | [diff] [blame] | 88 | dput(dentry); |
| 89 | dentry = parent; |
Christoph Hellwig | dd90b50 | 2007-07-17 04:04:32 -0700 | [diff] [blame] | 90 | } |
Christoph Hellwig | dd90b50 | 2007-07-17 04:04:32 -0700 | [diff] [blame] | 91 | return dentry; |
| 92 | } |
| 93 | |
Christoph Hellwig | 019ab80 | 2007-07-17 04:04:33 -0700 | [diff] [blame] | 94 | /* |
| 95 | * Make sure target_dir is fully connected to the dentry tree. |
| 96 | * |
| 97 | * It may already be, as the flag isn't always updated when connection happens. |
| 98 | */ |
| 99 | static int |
Al Viro | f3f8e17 | 2008-08-11 12:39:47 -0400 | [diff] [blame] | 100 | reconnect_path(struct vfsmount *mnt, struct dentry *target_dir, char *nbuf) |
Christoph Hellwig | 019ab80 | 2007-07-17 04:04:33 -0700 | [diff] [blame] | 101 | { |
Christoph Hellwig | 019ab80 | 2007-07-17 04:04:33 -0700 | [diff] [blame] | 102 | int noprogress = 0; |
| 103 | int err = -ESTALE; |
| 104 | |
| 105 | /* |
| 106 | * It is possible that a confused file system might not let us complete |
| 107 | * the path to the root. For example, if get_parent returns a directory |
| 108 | * in which we cannot find a name for the child. While this implies a |
| 109 | * very sick filesystem we don't want it to cause knfsd to spin. Hence |
| 110 | * the noprogress counter. If we go through the loop 10 times (2 is |
| 111 | * probably enough) without getting anywhere, we just give up |
| 112 | */ |
| 113 | while (target_dir->d_flags & DCACHE_DISCONNECTED && noprogress++ < 10) { |
| 114 | struct dentry *pd = find_disconnected_root(target_dir); |
| 115 | |
| 116 | if (!IS_ROOT(pd)) { |
| 117 | /* must have found a connected parent - great */ |
| 118 | spin_lock(&pd->d_lock); |
| 119 | pd->d_flags &= ~DCACHE_DISCONNECTED; |
| 120 | spin_unlock(&pd->d_lock); |
| 121 | noprogress = 0; |
Christoph Hellwig | e38f981 | 2007-10-21 16:42:19 -0700 | [diff] [blame] | 122 | } else if (pd == mnt->mnt_sb->s_root) { |
Christoph Hellwig | 019ab80 | 2007-07-17 04:04:33 -0700 | [diff] [blame] | 123 | printk(KERN_ERR "export: Eeek filesystem root is not connected, impossible\n"); |
| 124 | spin_lock(&pd->d_lock); |
| 125 | pd->d_flags &= ~DCACHE_DISCONNECTED; |
| 126 | spin_unlock(&pd->d_lock); |
| 127 | noprogress = 0; |
| 128 | } else { |
| 129 | /* |
| 130 | * We have hit the top of a disconnected path, try to |
| 131 | * find parent and connect. |
| 132 | * |
| 133 | * Racing with some other process renaming a directory |
| 134 | * isn't much of a problem here. If someone renames |
| 135 | * the directory, it will end up properly connected, |
| 136 | * which is what we want |
| 137 | * |
| 138 | * Getting the parent can't be supported generically, |
| 139 | * the locking is too icky. |
| 140 | * |
| 141 | * Instead we just return EACCES. If server reboots |
| 142 | * or inodes get flushed, you lose |
| 143 | */ |
| 144 | struct dentry *ppd = ERR_PTR(-EACCES); |
| 145 | struct dentry *npd; |
| 146 | |
| 147 | mutex_lock(&pd->d_inode->i_mutex); |
Christoph Hellwig | e38f981 | 2007-10-21 16:42:19 -0700 | [diff] [blame] | 148 | if (mnt->mnt_sb->s_export_op->get_parent) |
| 149 | ppd = mnt->mnt_sb->s_export_op->get_parent(pd); |
Christoph Hellwig | 019ab80 | 2007-07-17 04:04:33 -0700 | [diff] [blame] | 150 | mutex_unlock(&pd->d_inode->i_mutex); |
| 151 | |
| 152 | if (IS_ERR(ppd)) { |
| 153 | err = PTR_ERR(ppd); |
| 154 | dprintk("%s: get_parent of %ld failed, err %d\n", |
Harvey Harrison | 8e24eea | 2008-04-30 00:55:09 -0700 | [diff] [blame] | 155 | __func__, pd->d_inode->i_ino, err); |
Christoph Hellwig | 019ab80 | 2007-07-17 04:04:33 -0700 | [diff] [blame] | 156 | dput(pd); |
| 157 | break; |
| 158 | } |
| 159 | |
Harvey Harrison | 8e24eea | 2008-04-30 00:55:09 -0700 | [diff] [blame] | 160 | dprintk("%s: find name of %lu in %lu\n", __func__, |
Christoph Hellwig | 019ab80 | 2007-07-17 04:04:33 -0700 | [diff] [blame] | 161 | pd->d_inode->i_ino, ppd->d_inode->i_ino); |
Christoph Hellwig | e38f981 | 2007-10-21 16:42:19 -0700 | [diff] [blame] | 162 | err = exportfs_get_name(mnt, ppd, nbuf, pd); |
Christoph Hellwig | 019ab80 | 2007-07-17 04:04:33 -0700 | [diff] [blame] | 163 | if (err) { |
| 164 | dput(ppd); |
| 165 | dput(pd); |
| 166 | if (err == -ENOENT) |
| 167 | /* some race between get_parent and |
| 168 | * get_name? just try again |
| 169 | */ |
| 170 | continue; |
| 171 | break; |
| 172 | } |
Harvey Harrison | 8e24eea | 2008-04-30 00:55:09 -0700 | [diff] [blame] | 173 | dprintk("%s: found name: %s\n", __func__, nbuf); |
Christoph Hellwig | 019ab80 | 2007-07-17 04:04:33 -0700 | [diff] [blame] | 174 | mutex_lock(&ppd->d_inode->i_mutex); |
| 175 | npd = lookup_one_len(nbuf, ppd, strlen(nbuf)); |
| 176 | mutex_unlock(&ppd->d_inode->i_mutex); |
| 177 | if (IS_ERR(npd)) { |
| 178 | err = PTR_ERR(npd); |
| 179 | dprintk("%s: lookup failed: %d\n", |
Harvey Harrison | 8e24eea | 2008-04-30 00:55:09 -0700 | [diff] [blame] | 180 | __func__, err); |
Christoph Hellwig | 019ab80 | 2007-07-17 04:04:33 -0700 | [diff] [blame] | 181 | dput(ppd); |
| 182 | dput(pd); |
| 183 | break; |
| 184 | } |
| 185 | /* we didn't really want npd, we really wanted |
| 186 | * a side-effect of the lookup. |
| 187 | * hopefully, npd == pd, though it isn't really |
| 188 | * a problem if it isn't |
| 189 | */ |
| 190 | if (npd == pd) |
| 191 | noprogress = 0; |
| 192 | else |
Harvey Harrison | 8e24eea | 2008-04-30 00:55:09 -0700 | [diff] [blame] | 193 | printk("%s: npd != pd\n", __func__); |
Christoph Hellwig | 019ab80 | 2007-07-17 04:04:33 -0700 | [diff] [blame] | 194 | dput(npd); |
| 195 | dput(ppd); |
| 196 | if (IS_ROOT(pd)) { |
| 197 | /* something went wrong, we have to give up */ |
| 198 | dput(pd); |
| 199 | break; |
| 200 | } |
| 201 | } |
| 202 | dput(pd); |
| 203 | } |
| 204 | |
| 205 | if (target_dir->d_flags & DCACHE_DISCONNECTED) { |
| 206 | /* something went wrong - oh-well */ |
| 207 | if (!err) |
| 208 | err = -ESTALE; |
| 209 | return err; |
| 210 | } |
| 211 | |
| 212 | return 0; |
| 213 | } |
| 214 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | struct getdents_callback { |
| 216 | char *name; /* name that was found. It already points to a |
| 217 | buffer NAME_MAX+1 is size */ |
| 218 | unsigned long ino; /* the inum we are looking for */ |
| 219 | int found; /* inode matched? */ |
| 220 | int sequence; /* sequence counter */ |
| 221 | }; |
| 222 | |
| 223 | /* |
| 224 | * A rather strange filldir function to capture |
| 225 | * the name matching the specified inode number. |
| 226 | */ |
| 227 | static int filldir_one(void * __buf, const char * name, int len, |
David Howells | afefdbb | 2006-10-03 01:13:46 -0700 | [diff] [blame] | 228 | loff_t pos, u64 ino, unsigned int d_type) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 229 | { |
| 230 | struct getdents_callback *buf = __buf; |
| 231 | int result = 0; |
| 232 | |
| 233 | buf->sequence++; |
| 234 | if (buf->ino == ino) { |
| 235 | memcpy(buf->name, name, len); |
| 236 | buf->name[len] = '\0'; |
| 237 | buf->found = 1; |
| 238 | result = -1; |
| 239 | } |
| 240 | return result; |
| 241 | } |
| 242 | |
| 243 | /** |
| 244 | * get_name - default export_operations->get_name function |
| 245 | * @dentry: the directory in which to find a name |
| 246 | * @name: a pointer to a %NAME_MAX+1 char buffer to store the name |
| 247 | * @child: the dentry for the child directory. |
| 248 | * |
| 249 | * calls readdir on the parent until it finds an entry with |
| 250 | * the same inode number as the child, and returns that. |
| 251 | */ |
Christoph Hellwig | e38f981 | 2007-10-21 16:42:19 -0700 | [diff] [blame] | 252 | static int get_name(struct vfsmount *mnt, struct dentry *dentry, |
| 253 | char *name, struct dentry *child) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | { |
David Howells | 745ca24 | 2008-11-14 10:39:22 +1100 | [diff] [blame] | 255 | const struct cred *cred = current_cred(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | struct inode *dir = dentry->d_inode; |
| 257 | int error; |
| 258 | struct file *file; |
| 259 | struct getdents_callback buffer; |
| 260 | |
| 261 | error = -ENOTDIR; |
| 262 | if (!dir || !S_ISDIR(dir->i_mode)) |
| 263 | goto out; |
| 264 | error = -EINVAL; |
| 265 | if (!dir->i_fop) |
| 266 | goto out; |
| 267 | /* |
| 268 | * Open the directory ... |
| 269 | */ |
David Howells | 745ca24 | 2008-11-14 10:39:22 +1100 | [diff] [blame] | 270 | file = dentry_open(dget(dentry), mntget(mnt), O_RDONLY, cred); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | error = PTR_ERR(file); |
| 272 | if (IS_ERR(file)) |
| 273 | goto out; |
| 274 | |
| 275 | error = -EINVAL; |
| 276 | if (!file->f_op->readdir) |
| 277 | goto out_close; |
| 278 | |
| 279 | buffer.name = name; |
| 280 | buffer.ino = child->d_inode->i_ino; |
| 281 | buffer.found = 0; |
| 282 | buffer.sequence = 0; |
| 283 | while (1) { |
| 284 | int old_seq = buffer.sequence; |
| 285 | |
| 286 | error = vfs_readdir(file, filldir_one, &buffer); |
Al Viro | 53c9c5c | 2008-08-24 07:29:52 -0400 | [diff] [blame] | 287 | if (buffer.found) { |
| 288 | error = 0; |
| 289 | break; |
| 290 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | |
| 292 | if (error < 0) |
| 293 | break; |
| 294 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 295 | error = -ENOENT; |
| 296 | if (old_seq == buffer.sequence) |
| 297 | break; |
| 298 | } |
| 299 | |
| 300 | out_close: |
| 301 | fput(file); |
| 302 | out: |
| 303 | return error; |
| 304 | } |
| 305 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 306 | /** |
| 307 | * export_encode_fh - default export_operations->encode_fh function |
Al Viro | b0b0382 | 2012-04-02 14:34:06 -0400 | [diff] [blame] | 308 | * @inode: the object to encode |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 309 | * @fh: where to store the file handle fragment |
| 310 | * @max_len: maximum length to store there |
Al Viro | b0b0382 | 2012-04-02 14:34:06 -0400 | [diff] [blame] | 311 | * @parent: parent directory inode, if wanted |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 312 | * |
| 313 | * This default encode_fh function assumes that the 32 inode number |
| 314 | * is suitable for locating an inode, and that the generation number |
| 315 | * can be used to check that it is still valid. It places them in the |
| 316 | * filehandle fragment where export_decode_fh expects to find them. |
| 317 | */ |
Al Viro | b0b0382 | 2012-04-02 14:34:06 -0400 | [diff] [blame] | 318 | static int export_encode_fh(struct inode *inode, struct fid *fid, |
| 319 | int *max_len, struct inode *parent) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 320 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 321 | int len = *max_len; |
Christoph Hellwig | 6e91ea2 | 2007-10-21 16:42:03 -0700 | [diff] [blame] | 322 | int type = FILEID_INO32_GEN; |
Aneesh Kumar K.V | 5fe0c23 | 2011-01-29 18:43:25 +0530 | [diff] [blame] | 323 | |
Al Viro | b0b0382 | 2012-04-02 14:34:06 -0400 | [diff] [blame] | 324 | if (parent && (len < 4)) { |
Aneesh Kumar K.V | 5fe0c23 | 2011-01-29 18:43:25 +0530 | [diff] [blame] | 325 | *max_len = 4; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 326 | return 255; |
Aneesh Kumar K.V | 5fe0c23 | 2011-01-29 18:43:25 +0530 | [diff] [blame] | 327 | } else if (len < 2) { |
| 328 | *max_len = 2; |
| 329 | return 255; |
| 330 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 331 | |
| 332 | len = 2; |
Christoph Hellwig | 6e91ea2 | 2007-10-21 16:42:03 -0700 | [diff] [blame] | 333 | fid->i32.ino = inode->i_ino; |
| 334 | fid->i32.gen = inode->i_generation; |
Al Viro | b0b0382 | 2012-04-02 14:34:06 -0400 | [diff] [blame] | 335 | if (parent) { |
Christoph Hellwig | 6e91ea2 | 2007-10-21 16:42:03 -0700 | [diff] [blame] | 336 | fid->i32.parent_ino = parent->i_ino; |
| 337 | fid->i32.parent_gen = parent->i_generation; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 338 | len = 4; |
Christoph Hellwig | 6e91ea2 | 2007-10-21 16:42:03 -0700 | [diff] [blame] | 339 | type = FILEID_INO32_GEN_PARENT; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 340 | } |
| 341 | *max_len = len; |
| 342 | return type; |
| 343 | } |
| 344 | |
Christoph Hellwig | 6e91ea2 | 2007-10-21 16:42:03 -0700 | [diff] [blame] | 345 | int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len, |
Christoph Hellwig | d37065c | 2007-07-17 04:04:30 -0700 | [diff] [blame] | 346 | int connectable) |
| 347 | { |
Christoph Hellwig | 3965516 | 2007-10-21 16:42:17 -0700 | [diff] [blame] | 348 | const struct export_operations *nop = dentry->d_sb->s_export_op; |
Christoph Hellwig | 10f11c3 | 2007-07-17 04:04:31 -0700 | [diff] [blame] | 349 | int error; |
Al Viro | b0b0382 | 2012-04-02 14:34:06 -0400 | [diff] [blame] | 350 | struct dentry *p = NULL; |
| 351 | struct inode *inode = dentry->d_inode, *parent = NULL; |
Christoph Hellwig | d37065c | 2007-07-17 04:04:30 -0700 | [diff] [blame] | 352 | |
Al Viro | b0b0382 | 2012-04-02 14:34:06 -0400 | [diff] [blame] | 353 | if (connectable && !S_ISDIR(inode->i_mode)) { |
| 354 | p = dget_parent(dentry); |
| 355 | /* |
| 356 | * note that while p might've ceased to be our parent already, |
| 357 | * it's still pinned by and still positive. |
| 358 | */ |
| 359 | parent = p->d_inode; |
| 360 | } |
Christoph Hellwig | 10f11c3 | 2007-07-17 04:04:31 -0700 | [diff] [blame] | 361 | if (nop->encode_fh) |
Al Viro | b0b0382 | 2012-04-02 14:34:06 -0400 | [diff] [blame] | 362 | error = nop->encode_fh(inode, fid->raw, max_len, parent); |
Christoph Hellwig | 10f11c3 | 2007-07-17 04:04:31 -0700 | [diff] [blame] | 363 | else |
Al Viro | b0b0382 | 2012-04-02 14:34:06 -0400 | [diff] [blame] | 364 | error = export_encode_fh(inode, fid, max_len, parent); |
| 365 | dput(p); |
Christoph Hellwig | 10f11c3 | 2007-07-17 04:04:31 -0700 | [diff] [blame] | 366 | |
| 367 | return error; |
Christoph Hellwig | d37065c | 2007-07-17 04:04:30 -0700 | [diff] [blame] | 368 | } |
| 369 | EXPORT_SYMBOL_GPL(exportfs_encode_fh); |
| 370 | |
Christoph Hellwig | 6e91ea2 | 2007-10-21 16:42:03 -0700 | [diff] [blame] | 371 | struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid, |
| 372 | int fh_len, int fileid_type, |
| 373 | int (*acceptable)(void *, struct dentry *), void *context) |
Christoph Hellwig | d37065c | 2007-07-17 04:04:30 -0700 | [diff] [blame] | 374 | { |
Christoph Hellwig | 3965516 | 2007-10-21 16:42:17 -0700 | [diff] [blame] | 375 | const struct export_operations *nop = mnt->mnt_sb->s_export_op; |
Christoph Hellwig | 2596110 | 2007-10-21 16:42:05 -0700 | [diff] [blame] | 376 | struct dentry *result, *alias; |
Al Viro | f3f8e17 | 2008-08-11 12:39:47 -0400 | [diff] [blame] | 377 | char nbuf[NAME_MAX+1]; |
Christoph Hellwig | 2596110 | 2007-10-21 16:42:05 -0700 | [diff] [blame] | 378 | int err; |
Christoph Hellwig | d37065c | 2007-07-17 04:04:30 -0700 | [diff] [blame] | 379 | |
Christoph Hellwig | 2596110 | 2007-10-21 16:42:05 -0700 | [diff] [blame] | 380 | /* |
Christoph Hellwig | 2596110 | 2007-10-21 16:42:05 -0700 | [diff] [blame] | 381 | * Try to get any dentry for the given file handle from the filesystem. |
| 382 | */ |
Aneesh Kumar K.V | becfd1f | 2011-01-29 18:43:26 +0530 | [diff] [blame] | 383 | if (!nop || !nop->fh_to_dentry) |
| 384 | return ERR_PTR(-ESTALE); |
Christoph Hellwig | 2596110 | 2007-10-21 16:42:05 -0700 | [diff] [blame] | 385 | result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type); |
J. Bruce Fields | a4f4d6d | 2008-12-08 18:24:18 -0500 | [diff] [blame] | 386 | if (!result) |
| 387 | result = ERR_PTR(-ESTALE); |
Christoph Hellwig | 2596110 | 2007-10-21 16:42:05 -0700 | [diff] [blame] | 388 | if (IS_ERR(result)) |
| 389 | return result; |
| 390 | |
| 391 | if (S_ISDIR(result->d_inode->i_mode)) { |
| 392 | /* |
| 393 | * This request is for a directory. |
| 394 | * |
| 395 | * On the positive side there is only one dentry for each |
| 396 | * directory inode. On the negative side this implies that we |
| 397 | * to ensure our dentry is connected all the way up to the |
| 398 | * filesystem root. |
| 399 | */ |
| 400 | if (result->d_flags & DCACHE_DISCONNECTED) { |
Al Viro | f3f8e17 | 2008-08-11 12:39:47 -0400 | [diff] [blame] | 401 | err = reconnect_path(mnt, result, nbuf); |
Christoph Hellwig | 2596110 | 2007-10-21 16:42:05 -0700 | [diff] [blame] | 402 | if (err) |
| 403 | goto err_result; |
| 404 | } |
| 405 | |
| 406 | if (!acceptable(context, result)) { |
| 407 | err = -EACCES; |
| 408 | goto err_result; |
| 409 | } |
| 410 | |
| 411 | return result; |
| 412 | } else { |
| 413 | /* |
| 414 | * It's not a directory. Life is a little more complicated. |
| 415 | */ |
| 416 | struct dentry *target_dir, *nresult; |
Christoph Hellwig | 2596110 | 2007-10-21 16:42:05 -0700 | [diff] [blame] | 417 | |
| 418 | /* |
| 419 | * See if either the dentry we just got from the filesystem |
| 420 | * or any alias for it is acceptable. This is always true |
| 421 | * if this filesystem is exported without the subtreecheck |
| 422 | * option. If the filesystem is exported with the subtree |
| 423 | * check option there's a fair chance we need to look at |
| 424 | * the parent directory in the file handle and make sure |
| 425 | * it's connected to the filesystem root. |
| 426 | */ |
| 427 | alias = find_acceptable_alias(result, acceptable, context); |
| 428 | if (alias) |
| 429 | return alias; |
| 430 | |
| 431 | /* |
| 432 | * Try to extract a dentry for the parent directory from the |
| 433 | * file handle. If this fails we'll have to give up. |
| 434 | */ |
| 435 | err = -ESTALE; |
| 436 | if (!nop->fh_to_parent) |
| 437 | goto err_result; |
| 438 | |
| 439 | target_dir = nop->fh_to_parent(mnt->mnt_sb, fid, |
| 440 | fh_len, fileid_type); |
J. Bruce Fields | a4f4d6d | 2008-12-08 18:24:18 -0500 | [diff] [blame] | 441 | if (!target_dir) |
| 442 | goto err_result; |
Christoph Hellwig | 2596110 | 2007-10-21 16:42:05 -0700 | [diff] [blame] | 443 | err = PTR_ERR(target_dir); |
| 444 | if (IS_ERR(target_dir)) |
| 445 | goto err_result; |
| 446 | |
| 447 | /* |
| 448 | * And as usual we need to make sure the parent directory is |
| 449 | * connected to the filesystem root. The VFS really doesn't |
| 450 | * like disconnected directories.. |
| 451 | */ |
Al Viro | f3f8e17 | 2008-08-11 12:39:47 -0400 | [diff] [blame] | 452 | err = reconnect_path(mnt, target_dir, nbuf); |
Christoph Hellwig | 2596110 | 2007-10-21 16:42:05 -0700 | [diff] [blame] | 453 | if (err) { |
| 454 | dput(target_dir); |
| 455 | goto err_result; |
| 456 | } |
| 457 | |
| 458 | /* |
| 459 | * Now that we've got both a well-connected parent and a |
| 460 | * dentry for the inode we're after, make sure that our |
| 461 | * inode is actually connected to the parent. |
| 462 | */ |
Christoph Hellwig | e38f981 | 2007-10-21 16:42:19 -0700 | [diff] [blame] | 463 | err = exportfs_get_name(mnt, target_dir, nbuf, result); |
Christoph Hellwig | 2596110 | 2007-10-21 16:42:05 -0700 | [diff] [blame] | 464 | if (!err) { |
| 465 | mutex_lock(&target_dir->d_inode->i_mutex); |
| 466 | nresult = lookup_one_len(nbuf, target_dir, |
| 467 | strlen(nbuf)); |
| 468 | mutex_unlock(&target_dir->d_inode->i_mutex); |
| 469 | if (!IS_ERR(nresult)) { |
| 470 | if (nresult->d_inode) { |
| 471 | dput(result); |
| 472 | result = nresult; |
| 473 | } else |
| 474 | dput(nresult); |
| 475 | } |
| 476 | } |
| 477 | |
| 478 | /* |
| 479 | * At this point we are done with the parent, but it's pinned |
| 480 | * by the child dentry anyway. |
| 481 | */ |
| 482 | dput(target_dir); |
| 483 | |
| 484 | /* |
| 485 | * And finally make sure the dentry is actually acceptable |
| 486 | * to NFSD. |
| 487 | */ |
| 488 | alias = find_acceptable_alias(result, acceptable, context); |
| 489 | if (!alias) { |
| 490 | err = -EACCES; |
| 491 | goto err_result; |
| 492 | } |
| 493 | |
| 494 | return alias; |
| 495 | } |
| 496 | |
| 497 | err_result: |
| 498 | dput(result); |
| 499 | return ERR_PTR(err); |
Christoph Hellwig | d37065c | 2007-07-17 04:04:30 -0700 | [diff] [blame] | 500 | } |
| 501 | EXPORT_SYMBOL_GPL(exportfs_decode_fh); |
| 502 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 503 | MODULE_LICENSE("GPL"); |