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(struct vfsmount *mnt, struct dentry *dentry, char *name, 23 struct dentry *child); 24 25 26 static 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 */ 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 list_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(struct vfsmount *mnt, struct dentry *dentry, 252 char *name, struct dentry *child) 253 { 254 const struct cred *cred = current_cred(); 255 struct inode *dir = 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(dget(dentry), mntget(mnt), 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 * @dentry: the dentry to encode 308 * @fh: where to store the file handle fragment 309 * @max_len: maximum length to store there 310 * @connectable: whether to store parent information 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 dentry *dentry, struct fid *fid, 318 int *max_len, int connectable) 319 { 320 struct inode * inode = dentry->d_inode; 321 int len = *max_len; 322 int type = FILEID_INO32_GEN; 323 324 if (connectable && (len < 4)) { 325 *max_len = 4; 326 return 255; 327 } else if (len < 2) { 328 *max_len = 2; 329 return 255; 330 } 331 332 len = 2; 333 fid->i32.ino = inode->i_ino; 334 fid->i32.gen = inode->i_generation; 335 if (connectable && !S_ISDIR(inode->i_mode)) { 336 struct inode *parent; 337 338 spin_lock(&dentry->d_lock); 339 parent = dentry->d_parent->d_inode; 340 fid->i32.parent_ino = parent->i_ino; 341 fid->i32.parent_gen = parent->i_generation; 342 spin_unlock(&dentry->d_lock); 343 len = 4; 344 type = FILEID_INO32_GEN_PARENT; 345 } 346 *max_len = len; 347 return type; 348 } 349 350 int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len, 351 int connectable) 352 { 353 const struct export_operations *nop = dentry->d_sb->s_export_op; 354 int error; 355 356 if (nop->encode_fh) 357 error = nop->encode_fh(dentry, fid->raw, max_len, connectable); 358 else 359 error = export_encode_fh(dentry, fid, max_len, connectable); 360 361 return error; 362 } 363 EXPORT_SYMBOL_GPL(exportfs_encode_fh); 364 365 struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid, 366 int fh_len, int fileid_type, 367 int (*acceptable)(void *, struct dentry *), void *context) 368 { 369 const struct export_operations *nop = mnt->mnt_sb->s_export_op; 370 struct dentry *result, *alias; 371 char nbuf[NAME_MAX+1]; 372 int err; 373 374 /* 375 * Try to get any dentry for the given file handle from the filesystem. 376 */ 377 if (!nop || !nop->fh_to_dentry) 378 return ERR_PTR(-ESTALE); 379 result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type); 380 if (!result) 381 result = ERR_PTR(-ESTALE); 382 if (IS_ERR(result)) 383 return result; 384 385 if (S_ISDIR(result->d_inode->i_mode)) { 386 /* 387 * This request is for a directory. 388 * 389 * On the positive side there is only one dentry for each 390 * directory inode. On the negative side this implies that we 391 * to ensure our dentry is connected all the way up to the 392 * filesystem root. 393 */ 394 if (result->d_flags & DCACHE_DISCONNECTED) { 395 err = reconnect_path(mnt, result, nbuf); 396 if (err) 397 goto err_result; 398 } 399 400 if (!acceptable(context, result)) { 401 err = -EACCES; 402 goto err_result; 403 } 404 405 return result; 406 } else { 407 /* 408 * It's not a directory. Life is a little more complicated. 409 */ 410 struct dentry *target_dir, *nresult; 411 412 /* 413 * See if either the dentry we just got from the filesystem 414 * or any alias for it is acceptable. This is always true 415 * if this filesystem is exported without the subtreecheck 416 * option. If the filesystem is exported with the subtree 417 * check option there's a fair chance we need to look at 418 * the parent directory in the file handle and make sure 419 * it's connected to the filesystem root. 420 */ 421 alias = find_acceptable_alias(result, acceptable, context); 422 if (alias) 423 return alias; 424 425 /* 426 * Try to extract a dentry for the parent directory from the 427 * file handle. If this fails we'll have to give up. 428 */ 429 err = -ESTALE; 430 if (!nop->fh_to_parent) 431 goto err_result; 432 433 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid, 434 fh_len, fileid_type); 435 if (!target_dir) 436 goto err_result; 437 err = PTR_ERR(target_dir); 438 if (IS_ERR(target_dir)) 439 goto err_result; 440 441 /* 442 * And as usual we need to make sure the parent directory is 443 * connected to the filesystem root. The VFS really doesn't 444 * like disconnected directories.. 445 */ 446 err = reconnect_path(mnt, target_dir, nbuf); 447 if (err) { 448 dput(target_dir); 449 goto err_result; 450 } 451 452 /* 453 * Now that we've got both a well-connected parent and a 454 * dentry for the inode we're after, make sure that our 455 * inode is actually connected to the parent. 456 */ 457 err = exportfs_get_name(mnt, target_dir, nbuf, result); 458 if (!err) { 459 mutex_lock(&target_dir->d_inode->i_mutex); 460 nresult = lookup_one_len(nbuf, target_dir, 461 strlen(nbuf)); 462 mutex_unlock(&target_dir->d_inode->i_mutex); 463 if (!IS_ERR(nresult)) { 464 if (nresult->d_inode) { 465 dput(result); 466 result = nresult; 467 } else 468 dput(nresult); 469 } 470 } 471 472 /* 473 * At this point we are done with the parent, but it's pinned 474 * by the child dentry anyway. 475 */ 476 dput(target_dir); 477 478 /* 479 * And finally make sure the dentry is actually acceptable 480 * to NFSD. 481 */ 482 alias = find_acceptable_alias(result, acceptable, context); 483 if (!alias) { 484 err = -EACCES; 485 goto err_result; 486 } 487 488 return alias; 489 } 490 491 err_result: 492 dput(result); 493 return ERR_PTR(err); 494 } 495 EXPORT_SYMBOL_GPL(exportfs_decode_fh); 496 497 MODULE_LICENSE("GPL"); 498