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