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 47 if (acceptable(context, result)) 48 return result; 49 50 spin_lock(&dcache_lock); 51 list_for_each_entry(dentry, &result->d_inode->i_dentry, d_alias) { 52 dget_locked(dentry); 53 spin_unlock(&dcache_lock); 54 if (toput) 55 dput(toput); 56 if (dentry != result && acceptable(context, dentry)) { 57 dput(result); 58 return dentry; 59 } 60 spin_lock(&dcache_lock); 61 toput = dentry; 62 } 63 spin_unlock(&dcache_lock); 64 65 if (toput) 66 dput(toput); 67 return NULL; 68 } 69 70 /* 71 * Find root of a disconnected subtree and return a reference to it. 72 */ 73 static struct dentry * 74 find_disconnected_root(struct dentry *dentry) 75 { 76 dget(dentry); 77 while (!IS_ROOT(dentry)) { 78 struct dentry *parent = dget_parent(dentry); 79 80 if (!(parent->d_flags & DCACHE_DISCONNECTED)) { 81 dput(parent); 82 break; 83 } 84 85 dput(dentry); 86 dentry = parent; 87 } 88 return dentry; 89 } 90 91 /* 92 * Make sure target_dir is fully connected to the dentry tree. 93 * 94 * It may already be, as the flag isn't always updated when connection happens. 95 */ 96 static int 97 reconnect_path(struct vfsmount *mnt, struct dentry *target_dir, char *nbuf) 98 { 99 int noprogress = 0; 100 int err = -ESTALE; 101 102 /* 103 * It is possible that a confused file system might not let us complete 104 * the path to the root. For example, if get_parent returns a directory 105 * in which we cannot find a name for the child. While this implies a 106 * very sick filesystem we don't want it to cause knfsd to spin. Hence 107 * the noprogress counter. If we go through the loop 10 times (2 is 108 * probably enough) without getting anywhere, we just give up 109 */ 110 while (target_dir->d_flags & DCACHE_DISCONNECTED && noprogress++ < 10) { 111 struct dentry *pd = find_disconnected_root(target_dir); 112 113 if (!IS_ROOT(pd)) { 114 /* must have found a connected parent - great */ 115 spin_lock(&pd->d_lock); 116 pd->d_flags &= ~DCACHE_DISCONNECTED; 117 spin_unlock(&pd->d_lock); 118 noprogress = 0; 119 } else if (pd == mnt->mnt_sb->s_root) { 120 printk(KERN_ERR "export: Eeek filesystem root is not connected, impossible\n"); 121 spin_lock(&pd->d_lock); 122 pd->d_flags &= ~DCACHE_DISCONNECTED; 123 spin_unlock(&pd->d_lock); 124 noprogress = 0; 125 } else { 126 /* 127 * We have hit the top of a disconnected path, try to 128 * find parent and connect. 129 * 130 * Racing with some other process renaming a directory 131 * isn't much of a problem here. If someone renames 132 * the directory, it will end up properly connected, 133 * which is what we want 134 * 135 * Getting the parent can't be supported generically, 136 * the locking is too icky. 137 * 138 * Instead we just return EACCES. If server reboots 139 * or inodes get flushed, you lose 140 */ 141 struct dentry *ppd = ERR_PTR(-EACCES); 142 struct dentry *npd; 143 144 mutex_lock(&pd->d_inode->i_mutex); 145 if (mnt->mnt_sb->s_export_op->get_parent) 146 ppd = mnt->mnt_sb->s_export_op->get_parent(pd); 147 mutex_unlock(&pd->d_inode->i_mutex); 148 149 if (IS_ERR(ppd)) { 150 err = PTR_ERR(ppd); 151 dprintk("%s: get_parent of %ld failed, err %d\n", 152 __func__, pd->d_inode->i_ino, err); 153 dput(pd); 154 break; 155 } 156 157 dprintk("%s: find name of %lu in %lu\n", __func__, 158 pd->d_inode->i_ino, ppd->d_inode->i_ino); 159 err = exportfs_get_name(mnt, ppd, nbuf, pd); 160 if (err) { 161 dput(ppd); 162 dput(pd); 163 if (err == -ENOENT) 164 /* some race between get_parent and 165 * get_name? just try again 166 */ 167 continue; 168 break; 169 } 170 dprintk("%s: found name: %s\n", __func__, nbuf); 171 mutex_lock(&ppd->d_inode->i_mutex); 172 npd = lookup_one_len(nbuf, ppd, strlen(nbuf)); 173 mutex_unlock(&ppd->d_inode->i_mutex); 174 if (IS_ERR(npd)) { 175 err = PTR_ERR(npd); 176 dprintk("%s: lookup failed: %d\n", 177 __func__, err); 178 dput(ppd); 179 dput(pd); 180 break; 181 } 182 /* we didn't really want npd, we really wanted 183 * a side-effect of the lookup. 184 * hopefully, npd == pd, though it isn't really 185 * a problem if it isn't 186 */ 187 if (npd == pd) 188 noprogress = 0; 189 else 190 printk("%s: npd != pd\n", __func__); 191 dput(npd); 192 dput(ppd); 193 if (IS_ROOT(pd)) { 194 /* something went wrong, we have to give up */ 195 dput(pd); 196 break; 197 } 198 } 199 dput(pd); 200 } 201 202 if (target_dir->d_flags & DCACHE_DISCONNECTED) { 203 /* something went wrong - oh-well */ 204 if (!err) 205 err = -ESTALE; 206 return err; 207 } 208 209 return 0; 210 } 211 212 struct getdents_callback { 213 char *name; /* name that was found. It already points to a 214 buffer NAME_MAX+1 is size */ 215 unsigned long ino; /* the inum we are looking for */ 216 int found; /* inode matched? */ 217 int sequence; /* sequence counter */ 218 }; 219 220 /* 221 * A rather strange filldir function to capture 222 * the name matching the specified inode number. 223 */ 224 static int filldir_one(void * __buf, const char * name, int len, 225 loff_t pos, u64 ino, unsigned int d_type) 226 { 227 struct getdents_callback *buf = __buf; 228 int result = 0; 229 230 buf->sequence++; 231 if (buf->ino == ino) { 232 memcpy(buf->name, name, len); 233 buf->name[len] = '\0'; 234 buf->found = 1; 235 result = -1; 236 } 237 return result; 238 } 239 240 /** 241 * get_name - default export_operations->get_name function 242 * @dentry: the directory in which to find a name 243 * @name: a pointer to a %NAME_MAX+1 char buffer to store the name 244 * @child: the dentry for the child directory. 245 * 246 * calls readdir on the parent until it finds an entry with 247 * the same inode number as the child, and returns that. 248 */ 249 static int get_name(struct vfsmount *mnt, struct dentry *dentry, 250 char *name, struct dentry *child) 251 { 252 const struct cred *cred = current_cred(); 253 struct inode *dir = dentry->d_inode; 254 int error; 255 struct file *file; 256 struct getdents_callback buffer; 257 258 error = -ENOTDIR; 259 if (!dir || !S_ISDIR(dir->i_mode)) 260 goto out; 261 error = -EINVAL; 262 if (!dir->i_fop) 263 goto out; 264 /* 265 * Open the directory ... 266 */ 267 file = dentry_open(dget(dentry), mntget(mnt), O_RDONLY, cred); 268 error = PTR_ERR(file); 269 if (IS_ERR(file)) 270 goto out; 271 272 error = -EINVAL; 273 if (!file->f_op->readdir) 274 goto out_close; 275 276 buffer.name = name; 277 buffer.ino = child->d_inode->i_ino; 278 buffer.found = 0; 279 buffer.sequence = 0; 280 while (1) { 281 int old_seq = buffer.sequence; 282 283 error = vfs_readdir(file, filldir_one, &buffer); 284 if (buffer.found) { 285 error = 0; 286 break; 287 } 288 289 if (error < 0) 290 break; 291 292 error = -ENOENT; 293 if (old_seq == buffer.sequence) 294 break; 295 } 296 297 out_close: 298 fput(file); 299 out: 300 return error; 301 } 302 303 /** 304 * export_encode_fh - default export_operations->encode_fh function 305 * @dentry: the dentry to encode 306 * @fh: where to store the file handle fragment 307 * @max_len: maximum length to store there 308 * @connectable: whether to store parent information 309 * 310 * This default encode_fh function assumes that the 32 inode number 311 * is suitable for locating an inode, and that the generation number 312 * can be used to check that it is still valid. It places them in the 313 * filehandle fragment where export_decode_fh expects to find them. 314 */ 315 static int export_encode_fh(struct dentry *dentry, struct fid *fid, 316 int *max_len, int connectable) 317 { 318 struct inode * inode = dentry->d_inode; 319 int len = *max_len; 320 int type = FILEID_INO32_GEN; 321 322 if (len < 2 || (connectable && len < 4)) 323 return 255; 324 325 len = 2; 326 fid->i32.ino = inode->i_ino; 327 fid->i32.gen = inode->i_generation; 328 if (connectable && !S_ISDIR(inode->i_mode)) { 329 struct inode *parent; 330 331 spin_lock(&dentry->d_lock); 332 parent = dentry->d_parent->d_inode; 333 fid->i32.parent_ino = parent->i_ino; 334 fid->i32.parent_gen = parent->i_generation; 335 spin_unlock(&dentry->d_lock); 336 len = 4; 337 type = FILEID_INO32_GEN_PARENT; 338 } 339 *max_len = len; 340 return type; 341 } 342 343 int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len, 344 int connectable) 345 { 346 const struct export_operations *nop = dentry->d_sb->s_export_op; 347 int error; 348 349 if (nop->encode_fh) 350 error = nop->encode_fh(dentry, fid->raw, max_len, connectable); 351 else 352 error = export_encode_fh(dentry, fid, max_len, connectable); 353 354 return error; 355 } 356 EXPORT_SYMBOL_GPL(exportfs_encode_fh); 357 358 struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid, 359 int fh_len, int fileid_type, 360 int (*acceptable)(void *, struct dentry *), void *context) 361 { 362 const struct export_operations *nop = mnt->mnt_sb->s_export_op; 363 struct dentry *result, *alias; 364 char nbuf[NAME_MAX+1]; 365 int err; 366 367 /* 368 * Try to get any dentry for the given file handle from the filesystem. 369 */ 370 result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type); 371 if (!result) 372 result = ERR_PTR(-ESTALE); 373 if (IS_ERR(result)) 374 return result; 375 376 if (S_ISDIR(result->d_inode->i_mode)) { 377 /* 378 * This request is for a directory. 379 * 380 * On the positive side there is only one dentry for each 381 * directory inode. On the negative side this implies that we 382 * to ensure our dentry is connected all the way up to the 383 * filesystem root. 384 */ 385 if (result->d_flags & DCACHE_DISCONNECTED) { 386 err = reconnect_path(mnt, result, nbuf); 387 if (err) 388 goto err_result; 389 } 390 391 if (!acceptable(context, result)) { 392 err = -EACCES; 393 goto err_result; 394 } 395 396 return result; 397 } else { 398 /* 399 * It's not a directory. Life is a little more complicated. 400 */ 401 struct dentry *target_dir, *nresult; 402 403 /* 404 * See if either the dentry we just got from the filesystem 405 * or any alias for it is acceptable. This is always true 406 * if this filesystem is exported without the subtreecheck 407 * option. If the filesystem is exported with the subtree 408 * check option there's a fair chance we need to look at 409 * the parent directory in the file handle and make sure 410 * it's connected to the filesystem root. 411 */ 412 alias = find_acceptable_alias(result, acceptable, context); 413 if (alias) 414 return alias; 415 416 /* 417 * Try to extract a dentry for the parent directory from the 418 * file handle. If this fails we'll have to give up. 419 */ 420 err = -ESTALE; 421 if (!nop->fh_to_parent) 422 goto err_result; 423 424 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid, 425 fh_len, fileid_type); 426 if (!target_dir) 427 goto err_result; 428 err = PTR_ERR(target_dir); 429 if (IS_ERR(target_dir)) 430 goto err_result; 431 432 /* 433 * And as usual we need to make sure the parent directory is 434 * connected to the filesystem root. The VFS really doesn't 435 * like disconnected directories.. 436 */ 437 err = reconnect_path(mnt, target_dir, nbuf); 438 if (err) { 439 dput(target_dir); 440 goto err_result; 441 } 442 443 /* 444 * Now that we've got both a well-connected parent and a 445 * dentry for the inode we're after, make sure that our 446 * inode is actually connected to the parent. 447 */ 448 err = exportfs_get_name(mnt, target_dir, nbuf, result); 449 if (!err) { 450 mutex_lock(&target_dir->d_inode->i_mutex); 451 nresult = lookup_one_len(nbuf, target_dir, 452 strlen(nbuf)); 453 mutex_unlock(&target_dir->d_inode->i_mutex); 454 if (!IS_ERR(nresult)) { 455 if (nresult->d_inode) { 456 dput(result); 457 result = nresult; 458 } else 459 dput(nresult); 460 } 461 } 462 463 /* 464 * At this point we are done with the parent, but it's pinned 465 * by the child dentry anyway. 466 */ 467 dput(target_dir); 468 469 /* 470 * And finally make sure the dentry is actually acceptable 471 * to NFSD. 472 */ 473 alias = find_acceptable_alias(result, acceptable, context); 474 if (!alias) { 475 err = -EACCES; 476 goto err_result; 477 } 478 479 return alias; 480 } 481 482 err_result: 483 dput(result); 484 return ERR_PTR(err); 485 } 486 EXPORT_SYMBOL_GPL(exportfs_decode_fh); 487 488 MODULE_LICENSE("GPL"); 489