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