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 char *name; /* name that was found. It already points to a 216 buffer NAME_MAX+1 is size */ 217 unsigned long ino; /* the inum we are looking for */ 218 int found; /* inode matched? */ 219 int sequence; /* sequence counter */ 220 }; 221 222 /* 223 * A rather strange filldir function to capture 224 * the name matching the specified inode number. 225 */ 226 static int filldir_one(void * __buf, const char * name, int len, 227 loff_t pos, u64 ino, unsigned int d_type) 228 { 229 struct getdents_callback *buf = __buf; 230 int result = 0; 231 232 buf->sequence++; 233 if (buf->ino == ino) { 234 memcpy(buf->name, name, len); 235 buf->name[len] = '\0'; 236 buf->found = 1; 237 result = -1; 238 } 239 return result; 240 } 241 242 /** 243 * get_name - default export_operations->get_name function 244 * @dentry: the directory in which to find a name 245 * @name: a pointer to a %NAME_MAX+1 char buffer to store the name 246 * @child: the dentry for the child directory. 247 * 248 * calls readdir on the parent until it finds an entry with 249 * the same inode number as the child, and returns that. 250 */ 251 static int get_name(const struct path *path, char *name, struct dentry *child) 252 { 253 const struct cred *cred = current_cred(); 254 struct inode *dir = path->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(path, 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 298 out_close: 299 fput(file); 300 out: 301 return error; 302 } 303 304 /** 305 * export_encode_fh - default export_operations->encode_fh function 306 * @inode: the object to encode 307 * @fh: where to store the file handle fragment 308 * @max_len: maximum length to store there 309 * @parent: parent directory inode, if wanted 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 */ 316 static int export_encode_fh(struct inode *inode, struct fid *fid, 317 int *max_len, struct inode *parent) 318 { 319 int len = *max_len; 320 int type = FILEID_INO32_GEN; 321 322 if (parent && (len < 4)) { 323 *max_len = 4; 324 return FILEID_INVALID; 325 } else if (len < 2) { 326 *max_len = 2; 327 return FILEID_INVALID; 328 } 329 330 len = 2; 331 fid->i32.ino = inode->i_ino; 332 fid->i32.gen = inode->i_generation; 333 if (parent) { 334 fid->i32.parent_ino = parent->i_ino; 335 fid->i32.parent_gen = parent->i_generation; 336 len = 4; 337 type = FILEID_INO32_GEN_PARENT; 338 } 339 *max_len = len; 340 return type; 341 } 342 343 int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid, 344 int *max_len, struct inode *parent) 345 { 346 const struct export_operations *nop = inode->i_sb->s_export_op; 347 348 if (nop && nop->encode_fh) 349 return nop->encode_fh(inode, fid->raw, max_len, parent); 350 351 return export_encode_fh(inode, fid, max_len, parent); 352 } 353 EXPORT_SYMBOL_GPL(exportfs_encode_inode_fh); 354 355 int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len, 356 int connectable) 357 { 358 int error; 359 struct dentry *p = NULL; 360 struct inode *inode = dentry->d_inode, *parent = NULL; 361 362 if (connectable && !S_ISDIR(inode->i_mode)) { 363 p = dget_parent(dentry); 364 /* 365 * note that while p might've ceased to be our parent already, 366 * it's still pinned by and still positive. 367 */ 368 parent = p->d_inode; 369 } 370 371 error = exportfs_encode_inode_fh(inode, fid, max_len, parent); 372 dput(p); 373 374 return error; 375 } 376 EXPORT_SYMBOL_GPL(exportfs_encode_fh); 377 378 struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid, 379 int fh_len, int fileid_type, 380 int (*acceptable)(void *, struct dentry *), void *context) 381 { 382 const struct export_operations *nop = mnt->mnt_sb->s_export_op; 383 struct dentry *result, *alias; 384 char nbuf[NAME_MAX+1]; 385 int err; 386 387 /* 388 * Try to get any dentry for the given file handle from the filesystem. 389 */ 390 if (!nop || !nop->fh_to_dentry) 391 return ERR_PTR(-ESTALE); 392 result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type); 393 if (!result) 394 result = ERR_PTR(-ESTALE); 395 if (IS_ERR(result)) 396 return result; 397 398 if (S_ISDIR(result->d_inode->i_mode)) { 399 /* 400 * This request is for a directory. 401 * 402 * On the positive side there is only one dentry for each 403 * directory inode. On the negative side this implies that we 404 * to ensure our dentry is connected all the way up to the 405 * filesystem root. 406 */ 407 if (result->d_flags & DCACHE_DISCONNECTED) { 408 err = reconnect_path(mnt, result, nbuf); 409 if (err) 410 goto err_result; 411 } 412 413 if (!acceptable(context, result)) { 414 err = -EACCES; 415 goto err_result; 416 } 417 418 return result; 419 } else { 420 /* 421 * It's not a directory. Life is a little more complicated. 422 */ 423 struct dentry *target_dir, *nresult; 424 425 /* 426 * See if either the dentry we just got from the filesystem 427 * or any alias for it is acceptable. This is always true 428 * if this filesystem is exported without the subtreecheck 429 * option. If the filesystem is exported with the subtree 430 * check option there's a fair chance we need to look at 431 * the parent directory in the file handle and make sure 432 * it's connected to the filesystem root. 433 */ 434 alias = find_acceptable_alias(result, acceptable, context); 435 if (alias) 436 return alias; 437 438 /* 439 * Try to extract a dentry for the parent directory from the 440 * file handle. If this fails we'll have to give up. 441 */ 442 err = -ESTALE; 443 if (!nop->fh_to_parent) 444 goto err_result; 445 446 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid, 447 fh_len, fileid_type); 448 if (!target_dir) 449 goto err_result; 450 err = PTR_ERR(target_dir); 451 if (IS_ERR(target_dir)) 452 goto err_result; 453 454 /* 455 * And as usual we need to make sure the parent directory is 456 * connected to the filesystem root. The VFS really doesn't 457 * like disconnected directories.. 458 */ 459 err = reconnect_path(mnt, target_dir, nbuf); 460 if (err) { 461 dput(target_dir); 462 goto err_result; 463 } 464 465 /* 466 * Now that we've got both a well-connected parent and a 467 * dentry for the inode we're after, make sure that our 468 * inode is actually connected to the parent. 469 */ 470 err = exportfs_get_name(mnt, target_dir, nbuf, result); 471 if (!err) { 472 mutex_lock(&target_dir->d_inode->i_mutex); 473 nresult = lookup_one_len(nbuf, target_dir, 474 strlen(nbuf)); 475 mutex_unlock(&target_dir->d_inode->i_mutex); 476 if (!IS_ERR(nresult)) { 477 if (nresult->d_inode) { 478 dput(result); 479 result = nresult; 480 } else 481 dput(nresult); 482 } 483 } 484 485 /* 486 * At this point we are done with the parent, but it's pinned 487 * by the child dentry anyway. 488 */ 489 dput(target_dir); 490 491 /* 492 * And finally make sure the dentry is actually acceptable 493 * to NFSD. 494 */ 495 alias = find_acceptable_alias(result, acceptable, context); 496 if (!alias) { 497 err = -EACCES; 498 goto err_result; 499 } 500 501 return alias; 502 } 503 504 err_result: 505 dput(result); 506 return ERR_PTR(err); 507 } 508 EXPORT_SYMBOL_GPL(exportfs_decode_fh); 509 510 MODULE_LICENSE("GPL"); 511