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