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