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 struct hlist_node *p; 48 49 if (acceptable(context, result)) 50 return result; 51 52 inode = result->d_inode; 53 spin_lock(&inode->i_lock); 54 hlist_for_each_entry(dentry, p, &inode->i_dentry, d_alias) { 55 dget(dentry); 56 spin_unlock(&inode->i_lock); 57 if (toput) 58 dput(toput); 59 if (dentry != result && acceptable(context, dentry)) { 60 dput(result); 61 return dentry; 62 } 63 spin_lock(&inode->i_lock); 64 toput = dentry; 65 } 66 spin_unlock(&inode->i_lock); 67 68 if (toput) 69 dput(toput); 70 return NULL; 71 } 72 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); 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 88 dput(dentry); 89 dentry = parent; 90 } 91 return dentry; 92 } 93 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 100 reconnect_path(struct vfsmount *mnt, struct dentry *target_dir, char *nbuf) 101 { 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; 122 } else if (pd == mnt->mnt_sb->s_root) { 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); 148 if (mnt->mnt_sb->s_export_op->get_parent) 149 ppd = mnt->mnt_sb->s_export_op->get_parent(pd); 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", 155 __func__, pd->d_inode->i_ino, err); 156 dput(pd); 157 break; 158 } 159 160 dprintk("%s: find name of %lu in %lu\n", __func__, 161 pd->d_inode->i_ino, ppd->d_inode->i_ino); 162 err = exportfs_get_name(mnt, ppd, nbuf, pd); 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 } 173 dprintk("%s: found name: %s\n", __func__, nbuf); 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", 180 __func__, err); 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 193 printk("%s: npd != pd\n", __func__); 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 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, 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 260 error = -ENOTDIR; 261 if (!dir || !S_ISDIR(dir->i_mode)) 262 goto out; 263 error = -EINVAL; 264 if (!dir->i_fop) 265 goto out; 266 /* 267 * Open the directory ... 268 */ 269 file = dentry_open(path, O_RDONLY, cred); 270 error = PTR_ERR(file); 271 if (IS_ERR(file)) 272 goto out; 273 274 error = -EINVAL; 275 if (!file->f_op->readdir) 276 goto out_close; 277 278 buffer.name = name; 279 buffer.ino = child->d_inode->i_ino; 280 buffer.found = 0; 281 buffer.sequence = 0; 282 while (1) { 283 int old_seq = buffer.sequence; 284 285 error = vfs_readdir(file, filldir_one, &buffer); 286 if (buffer.found) { 287 error = 0; 288 break; 289 } 290 291 if (error < 0) 292 break; 293 294 error = -ENOENT; 295 if (old_seq == buffer.sequence) 296 break; 297 } 298 299 out_close: 300 fput(file); 301 out: 302 return error; 303 } 304 305 /** 306 * export_encode_fh - default export_operations->encode_fh function 307 * @inode: the object to encode 308 * @fh: where to store the file handle fragment 309 * @max_len: maximum length to store there 310 * @parent: parent directory inode, if wanted 311 * 312 * This default encode_fh function assumes that the 32 inode number 313 * is suitable for locating an inode, and that the generation number 314 * can be used to check that it is still valid. It places them in the 315 * filehandle fragment where export_decode_fh expects to find them. 316 */ 317 static int export_encode_fh(struct inode *inode, struct fid *fid, 318 int *max_len, struct inode *parent) 319 { 320 int len = *max_len; 321 int type = FILEID_INO32_GEN; 322 323 if (parent && (len < 4)) { 324 *max_len = 4; 325 return 255; 326 } else if (len < 2) { 327 *max_len = 2; 328 return 255; 329 } 330 331 len = 2; 332 fid->i32.ino = inode->i_ino; 333 fid->i32.gen = inode->i_generation; 334 if (parent) { 335 fid->i32.parent_ino = parent->i_ino; 336 fid->i32.parent_gen = parent->i_generation; 337 len = 4; 338 type = FILEID_INO32_GEN_PARENT; 339 } 340 *max_len = len; 341 return type; 342 } 343 344 int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid, 345 int *max_len, struct inode *parent) 346 { 347 const struct export_operations *nop = inode->i_sb->s_export_op; 348 349 if (nop && nop->encode_fh) 350 return nop->encode_fh(inode, fid->raw, max_len, parent); 351 352 return export_encode_fh(inode, fid, max_len, parent); 353 } 354 EXPORT_SYMBOL_GPL(exportfs_encode_inode_fh); 355 356 int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len, 357 int connectable) 358 { 359 int error; 360 struct dentry *p = NULL; 361 struct inode *inode = dentry->d_inode, *parent = NULL; 362 363 if (connectable && !S_ISDIR(inode->i_mode)) { 364 p = dget_parent(dentry); 365 /* 366 * note that while p might've ceased to be our parent already, 367 * it's still pinned by and still positive. 368 */ 369 parent = p->d_inode; 370 } 371 372 error = exportfs_encode_inode_fh(inode, fid, max_len, parent); 373 dput(p); 374 375 return error; 376 } 377 EXPORT_SYMBOL_GPL(exportfs_encode_fh); 378 379 struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid, 380 int fh_len, int fileid_type, 381 int (*acceptable)(void *, struct dentry *), void *context) 382 { 383 const struct export_operations *nop = mnt->mnt_sb->s_export_op; 384 struct dentry *result, *alias; 385 char nbuf[NAME_MAX+1]; 386 int err; 387 388 /* 389 * Try to get any dentry for the given file handle from the filesystem. 390 */ 391 if (!nop || !nop->fh_to_dentry) 392 return ERR_PTR(-ESTALE); 393 result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type); 394 if (!result) 395 result = ERR_PTR(-ESTALE); 396 if (IS_ERR(result)) 397 return result; 398 399 if (S_ISDIR(result->d_inode->i_mode)) { 400 /* 401 * This request is for a directory. 402 * 403 * On the positive side there is only one dentry for each 404 * directory inode. On the negative side this implies that we 405 * to ensure our dentry is connected all the way up to the 406 * filesystem root. 407 */ 408 if (result->d_flags & DCACHE_DISCONNECTED) { 409 err = reconnect_path(mnt, result, nbuf); 410 if (err) 411 goto err_result; 412 } 413 414 if (!acceptable(context, result)) { 415 err = -EACCES; 416 goto err_result; 417 } 418 419 return result; 420 } else { 421 /* 422 * It's not a directory. Life is a little more complicated. 423 */ 424 struct dentry *target_dir, *nresult; 425 426 /* 427 * See if either the dentry we just got from the filesystem 428 * or any alias for it is acceptable. This is always true 429 * if this filesystem is exported without the subtreecheck 430 * option. If the filesystem is exported with the subtree 431 * check option there's a fair chance we need to look at 432 * the parent directory in the file handle and make sure 433 * it's connected to the filesystem root. 434 */ 435 alias = find_acceptable_alias(result, acceptable, context); 436 if (alias) 437 return alias; 438 439 /* 440 * Try to extract a dentry for the parent directory from the 441 * file handle. If this fails we'll have to give up. 442 */ 443 err = -ESTALE; 444 if (!nop->fh_to_parent) 445 goto err_result; 446 447 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid, 448 fh_len, fileid_type); 449 if (!target_dir) 450 goto err_result; 451 err = PTR_ERR(target_dir); 452 if (IS_ERR(target_dir)) 453 goto err_result; 454 455 /* 456 * And as usual we need to make sure the parent directory is 457 * connected to the filesystem root. The VFS really doesn't 458 * like disconnected directories.. 459 */ 460 err = reconnect_path(mnt, target_dir, nbuf); 461 if (err) { 462 dput(target_dir); 463 goto err_result; 464 } 465 466 /* 467 * Now that we've got both a well-connected parent and a 468 * dentry for the inode we're after, make sure that our 469 * inode is actually connected to the parent. 470 */ 471 err = exportfs_get_name(mnt, target_dir, nbuf, result); 472 if (!err) { 473 mutex_lock(&target_dir->d_inode->i_mutex); 474 nresult = lookup_one_len(nbuf, target_dir, 475 strlen(nbuf)); 476 mutex_unlock(&target_dir->d_inode->i_mutex); 477 if (!IS_ERR(nresult)) { 478 if (nresult->d_inode) { 479 dput(result); 480 result = nresult; 481 } else 482 dput(nresult); 483 } 484 } 485 486 /* 487 * At this point we are done with the parent, but it's pinned 488 * by the child dentry anyway. 489 */ 490 dput(target_dir); 491 492 /* 493 * And finally make sure the dentry is actually acceptable 494 * to NFSD. 495 */ 496 alias = find_acceptable_alias(result, acceptable, context); 497 if (!alias) { 498 err = -EACCES; 499 goto err_result; 500 } 501 502 return alias; 503 } 504 505 err_result: 506 dput(result); 507 return ERR_PTR(err); 508 } 509 EXPORT_SYMBOL_GPL(exportfs_decode_fh); 510 511 MODULE_LICENSE("GPL"); 512