xref: /openbmc/linux/fs/nfsd/nfsfh.c (revision 0edbfea5)
1 /*
2  * NFS server file handle treatment.
3  *
4  * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
5  * Portions Copyright (C) 1999 G. Allen Morris III <gam3@acm.org>
6  * Extensive rewrite by Neil Brown <neilb@cse.unsw.edu.au> Southern-Spring 1999
7  * ... and again Southern-Winter 2001 to support export_operations
8  */
9 
10 #include <linux/exportfs.h>
11 
12 #include <linux/sunrpc/svcauth_gss.h>
13 #include "nfsd.h"
14 #include "vfs.h"
15 #include "auth.h"
16 
17 #define NFSDDBG_FACILITY		NFSDDBG_FH
18 
19 
20 /*
21  * our acceptability function.
22  * if NOSUBTREECHECK, accept anything
23  * if not, require that we can walk up to exp->ex_dentry
24  * doing some checks on the 'x' bits
25  */
26 static int nfsd_acceptable(void *expv, struct dentry *dentry)
27 {
28 	struct svc_export *exp = expv;
29 	int rv;
30 	struct dentry *tdentry;
31 	struct dentry *parent;
32 
33 	if (exp->ex_flags & NFSEXP_NOSUBTREECHECK)
34 		return 1;
35 
36 	tdentry = dget(dentry);
37 	while (tdentry != exp->ex_path.dentry && !IS_ROOT(tdentry)) {
38 		/* make sure parents give x permission to user */
39 		int err;
40 		parent = dget_parent(tdentry);
41 		err = inode_permission(d_inode(parent), MAY_EXEC);
42 		if (err < 0) {
43 			dput(parent);
44 			break;
45 		}
46 		dput(tdentry);
47 		tdentry = parent;
48 	}
49 	if (tdentry != exp->ex_path.dentry)
50 		dprintk("nfsd_acceptable failed at %p %pd\n", tdentry, tdentry);
51 	rv = (tdentry == exp->ex_path.dentry);
52 	dput(tdentry);
53 	return rv;
54 }
55 
56 /* Type check. The correct error return for type mismatches does not seem to be
57  * generally agreed upon. SunOS seems to use EISDIR if file isn't S_IFREG; a
58  * comment in the NFSv3 spec says this is incorrect (implementation notes for
59  * the write call).
60  */
61 static inline __be32
62 nfsd_mode_check(struct svc_rqst *rqstp, umode_t mode, umode_t requested)
63 {
64 	mode &= S_IFMT;
65 
66 	if (requested == 0) /* the caller doesn't care */
67 		return nfs_ok;
68 	if (mode == requested)
69 		return nfs_ok;
70 	/*
71 	 * v4 has an error more specific than err_notdir which we should
72 	 * return in preference to err_notdir:
73 	 */
74 	if (rqstp->rq_vers == 4 && mode == S_IFLNK)
75 		return nfserr_symlink;
76 	if (requested == S_IFDIR)
77 		return nfserr_notdir;
78 	if (mode == S_IFDIR)
79 		return nfserr_isdir;
80 	return nfserr_inval;
81 }
82 
83 static __be32 nfsd_setuser_and_check_port(struct svc_rqst *rqstp,
84 					  struct svc_export *exp)
85 {
86 	int flags = nfsexp_flags(rqstp, exp);
87 
88 	/* Check if the request originated from a secure port. */
89 	if (!test_bit(RQ_SECURE, &rqstp->rq_flags) && !(flags & NFSEXP_INSECURE_PORT)) {
90 		RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
91 		dprintk("nfsd: request from insecure port %s!\n",
92 		        svc_print_addr(rqstp, buf, sizeof(buf)));
93 		return nfserr_perm;
94 	}
95 
96 	/* Set user creds for this exportpoint */
97 	return nfserrno(nfsd_setuser(rqstp, exp));
98 }
99 
100 static inline __be32 check_pseudo_root(struct svc_rqst *rqstp,
101 	struct dentry *dentry, struct svc_export *exp)
102 {
103 	if (!(exp->ex_flags & NFSEXP_V4ROOT))
104 		return nfs_ok;
105 	/*
106 	 * v2/v3 clients have no need for the V4ROOT export--they use
107 	 * the mount protocl instead; also, further V4ROOT checks may be
108 	 * in v4-specific code, in which case v2/v3 clients could bypass
109 	 * them.
110 	 */
111 	if (!nfsd_v4client(rqstp))
112 		return nfserr_stale;
113 	/*
114 	 * We're exposing only the directories and symlinks that have to be
115 	 * traversed on the way to real exports:
116 	 */
117 	if (unlikely(!d_is_dir(dentry) &&
118 		     !d_is_symlink(dentry)))
119 		return nfserr_stale;
120 	/*
121 	 * A pseudoroot export gives permission to access only one
122 	 * single directory; the kernel has to make another upcall
123 	 * before granting access to anything else under it:
124 	 */
125 	if (unlikely(dentry != exp->ex_path.dentry))
126 		return nfserr_stale;
127 	return nfs_ok;
128 }
129 
130 /*
131  * Use the given filehandle to look up the corresponding export and
132  * dentry.  On success, the results are used to set fh_export and
133  * fh_dentry.
134  */
135 static __be32 nfsd_set_fh_dentry(struct svc_rqst *rqstp, struct svc_fh *fhp)
136 {
137 	struct knfsd_fh	*fh = &fhp->fh_handle;
138 	struct fid *fid = NULL, sfid;
139 	struct svc_export *exp;
140 	struct dentry *dentry;
141 	int fileid_type;
142 	int data_left = fh->fh_size/4;
143 	__be32 error;
144 
145 	error = nfserr_stale;
146 	if (rqstp->rq_vers > 2)
147 		error = nfserr_badhandle;
148 	if (rqstp->rq_vers == 4 && fh->fh_size == 0)
149 		return nfserr_nofilehandle;
150 
151 	if (fh->fh_version == 1) {
152 		int len;
153 
154 		if (--data_left < 0)
155 			return error;
156 		if (fh->fh_auth_type != 0)
157 			return error;
158 		len = key_len(fh->fh_fsid_type) / 4;
159 		if (len == 0)
160 			return error;
161 		if  (fh->fh_fsid_type == FSID_MAJOR_MINOR) {
162 			/* deprecated, convert to type 3 */
163 			len = key_len(FSID_ENCODE_DEV)/4;
164 			fh->fh_fsid_type = FSID_ENCODE_DEV;
165 			/*
166 			 * struct knfsd_fh uses host-endian fields, which are
167 			 * sometimes used to hold net-endian values. This
168 			 * confuses sparse, so we must use __force here to
169 			 * keep it from complaining.
170 			 */
171 			fh->fh_fsid[0] = new_encode_dev(MKDEV(ntohl((__force __be32)fh->fh_fsid[0]),
172 							ntohl((__force __be32)fh->fh_fsid[1])));
173 			fh->fh_fsid[1] = fh->fh_fsid[2];
174 		}
175 		data_left -= len;
176 		if (data_left < 0)
177 			return error;
178 		exp = rqst_exp_find(rqstp, fh->fh_fsid_type, fh->fh_fsid);
179 		fid = (struct fid *)(fh->fh_fsid + len);
180 	} else {
181 		__u32 tfh[2];
182 		dev_t xdev;
183 		ino_t xino;
184 
185 		if (fh->fh_size != NFS_FHSIZE)
186 			return error;
187 		/* assume old filehandle format */
188 		xdev = old_decode_dev(fh->ofh_xdev);
189 		xino = u32_to_ino_t(fh->ofh_xino);
190 		mk_fsid(FSID_DEV, tfh, xdev, xino, 0, NULL);
191 		exp = rqst_exp_find(rqstp, FSID_DEV, tfh);
192 	}
193 
194 	error = nfserr_stale;
195 	if (PTR_ERR(exp) == -ENOENT)
196 		return error;
197 
198 	if (IS_ERR(exp))
199 		return nfserrno(PTR_ERR(exp));
200 
201 	if (exp->ex_flags & NFSEXP_NOSUBTREECHECK) {
202 		/* Elevate privileges so that the lack of 'r' or 'x'
203 		 * permission on some parent directory will
204 		 * not stop exportfs_decode_fh from being able
205 		 * to reconnect a directory into the dentry cache.
206 		 * The same problem can affect "SUBTREECHECK" exports,
207 		 * but as nfsd_acceptable depends on correct
208 		 * access control settings being in effect, we cannot
209 		 * fix that case easily.
210 		 */
211 		struct cred *new = prepare_creds();
212 		if (!new) {
213 			error =  nfserrno(-ENOMEM);
214 			goto out;
215 		}
216 		new->cap_effective =
217 			cap_raise_nfsd_set(new->cap_effective,
218 					   new->cap_permitted);
219 		put_cred(override_creds(new));
220 		put_cred(new);
221 	} else {
222 		error = nfsd_setuser_and_check_port(rqstp, exp);
223 		if (error)
224 			goto out;
225 	}
226 
227 	/*
228 	 * Look up the dentry using the NFS file handle.
229 	 */
230 	error = nfserr_stale;
231 	if (rqstp->rq_vers > 2)
232 		error = nfserr_badhandle;
233 
234 	if (fh->fh_version != 1) {
235 		sfid.i32.ino = fh->ofh_ino;
236 		sfid.i32.gen = fh->ofh_generation;
237 		sfid.i32.parent_ino = fh->ofh_dirino;
238 		fid = &sfid;
239 		data_left = 3;
240 		if (fh->ofh_dirino == 0)
241 			fileid_type = FILEID_INO32_GEN;
242 		else
243 			fileid_type = FILEID_INO32_GEN_PARENT;
244 	} else
245 		fileid_type = fh->fh_fileid_type;
246 
247 	if (fileid_type == FILEID_ROOT)
248 		dentry = dget(exp->ex_path.dentry);
249 	else {
250 		dentry = exportfs_decode_fh(exp->ex_path.mnt, fid,
251 				data_left, fileid_type,
252 				nfsd_acceptable, exp);
253 	}
254 	if (dentry == NULL)
255 		goto out;
256 	if (IS_ERR(dentry)) {
257 		if (PTR_ERR(dentry) != -EINVAL)
258 			error = nfserrno(PTR_ERR(dentry));
259 		goto out;
260 	}
261 
262 	if (d_is_dir(dentry) &&
263 			(dentry->d_flags & DCACHE_DISCONNECTED)) {
264 		printk("nfsd: find_fh_dentry returned a DISCONNECTED directory: %pd2\n",
265 				dentry);
266 	}
267 
268 	fhp->fh_dentry = dentry;
269 	fhp->fh_export = exp;
270 	return 0;
271 out:
272 	exp_put(exp);
273 	return error;
274 }
275 
276 /**
277  * fh_verify - filehandle lookup and access checking
278  * @rqstp: pointer to current rpc request
279  * @fhp: filehandle to be verified
280  * @type: expected type of object pointed to by filehandle
281  * @access: type of access needed to object
282  *
283  * Look up a dentry from the on-the-wire filehandle, check the client's
284  * access to the export, and set the current task's credentials.
285  *
286  * Regardless of success or failure of fh_verify(), fh_put() should be
287  * called on @fhp when the caller is finished with the filehandle.
288  *
289  * fh_verify() may be called multiple times on a given filehandle, for
290  * example, when processing an NFSv4 compound.  The first call will look
291  * up a dentry using the on-the-wire filehandle.  Subsequent calls will
292  * skip the lookup and just perform the other checks and possibly change
293  * the current task's credentials.
294  *
295  * @type specifies the type of object expected using one of the S_IF*
296  * constants defined in include/linux/stat.h.  The caller may use zero
297  * to indicate that it doesn't care, or a negative integer to indicate
298  * that it expects something not of the given type.
299  *
300  * @access is formed from the NFSD_MAY_* constants defined in
301  * include/linux/nfsd/nfsd.h.
302  */
303 __be32
304 fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type, int access)
305 {
306 	struct svc_export *exp;
307 	struct dentry	*dentry;
308 	__be32		error;
309 
310 	dprintk("nfsd: fh_verify(%s)\n", SVCFH_fmt(fhp));
311 
312 	if (!fhp->fh_dentry) {
313 		error = nfsd_set_fh_dentry(rqstp, fhp);
314 		if (error)
315 			goto out;
316 	}
317 	dentry = fhp->fh_dentry;
318 	exp = fhp->fh_export;
319 	/*
320 	 * We still have to do all these permission checks, even when
321 	 * fh_dentry is already set:
322 	 * 	- fh_verify may be called multiple times with different
323 	 * 	  "access" arguments (e.g. nfsd_proc_create calls
324 	 * 	  fh_verify(...,NFSD_MAY_EXEC) first, then later (in
325 	 * 	  nfsd_create) calls fh_verify(...,NFSD_MAY_CREATE).
326 	 *	- in the NFSv4 case, the filehandle may have been filled
327 	 *	  in by fh_compose, and given a dentry, but further
328 	 *	  compound operations performed with that filehandle
329 	 *	  still need permissions checks.  In the worst case, a
330 	 *	  mountpoint crossing may have changed the export
331 	 *	  options, and we may now need to use a different uid
332 	 *	  (for example, if different id-squashing options are in
333 	 *	  effect on the new filesystem).
334 	 */
335 	error = check_pseudo_root(rqstp, dentry, exp);
336 	if (error)
337 		goto out;
338 
339 	error = nfsd_setuser_and_check_port(rqstp, exp);
340 	if (error)
341 		goto out;
342 
343 	error = nfsd_mode_check(rqstp, d_inode(dentry)->i_mode, type);
344 	if (error)
345 		goto out;
346 
347 	/*
348 	 * pseudoflavor restrictions are not enforced on NLM,
349 	 * which clients virtually always use auth_sys for,
350 	 * even while using RPCSEC_GSS for NFS.
351 	 */
352 	if (access & NFSD_MAY_LOCK || access & NFSD_MAY_BYPASS_GSS)
353 		goto skip_pseudoflavor_check;
354 	/*
355 	 * Clients may expect to be able to use auth_sys during mount,
356 	 * even if they use gss for everything else; see section 2.3.2
357 	 * of rfc 2623.
358 	 */
359 	if (access & NFSD_MAY_BYPASS_GSS_ON_ROOT
360 			&& exp->ex_path.dentry == dentry)
361 		goto skip_pseudoflavor_check;
362 
363 	error = check_nfsd_access(exp, rqstp);
364 	if (error)
365 		goto out;
366 
367 skip_pseudoflavor_check:
368 	/* Finally, check access permissions. */
369 	error = nfsd_permission(rqstp, exp, dentry, access);
370 
371 	if (error) {
372 		dprintk("fh_verify: %pd2 permission failure, "
373 			"acc=%x, error=%d\n",
374 			dentry,
375 			access, ntohl(error));
376 	}
377 out:
378 	if (error == nfserr_stale)
379 		nfsdstats.fh_stale++;
380 	return error;
381 }
382 
383 
384 /*
385  * Compose a file handle for an NFS reply.
386  *
387  * Note that when first composed, the dentry may not yet have
388  * an inode.  In this case a call to fh_update should be made
389  * before the fh goes out on the wire ...
390  */
391 static void _fh_update(struct svc_fh *fhp, struct svc_export *exp,
392 		struct dentry *dentry)
393 {
394 	if (dentry != exp->ex_path.dentry) {
395 		struct fid *fid = (struct fid *)
396 			(fhp->fh_handle.fh_fsid + fhp->fh_handle.fh_size/4 - 1);
397 		int maxsize = (fhp->fh_maxsize - fhp->fh_handle.fh_size)/4;
398 		int subtreecheck = !(exp->ex_flags & NFSEXP_NOSUBTREECHECK);
399 
400 		fhp->fh_handle.fh_fileid_type =
401 			exportfs_encode_fh(dentry, fid, &maxsize, subtreecheck);
402 		fhp->fh_handle.fh_size += maxsize * 4;
403 	} else {
404 		fhp->fh_handle.fh_fileid_type = FILEID_ROOT;
405 	}
406 }
407 
408 /*
409  * for composing old style file handles
410  */
411 static inline void _fh_update_old(struct dentry *dentry,
412 				  struct svc_export *exp,
413 				  struct knfsd_fh *fh)
414 {
415 	fh->ofh_ino = ino_t_to_u32(d_inode(dentry)->i_ino);
416 	fh->ofh_generation = d_inode(dentry)->i_generation;
417 	if (d_is_dir(dentry) ||
418 	    (exp->ex_flags & NFSEXP_NOSUBTREECHECK))
419 		fh->ofh_dirino = 0;
420 }
421 
422 static bool is_root_export(struct svc_export *exp)
423 {
424 	return exp->ex_path.dentry == exp->ex_path.dentry->d_sb->s_root;
425 }
426 
427 static struct super_block *exp_sb(struct svc_export *exp)
428 {
429 	return exp->ex_path.dentry->d_sb;
430 }
431 
432 static bool fsid_type_ok_for_exp(u8 fsid_type, struct svc_export *exp)
433 {
434 	switch (fsid_type) {
435 	case FSID_DEV:
436 		if (!old_valid_dev(exp_sb(exp)->s_dev))
437 			return 0;
438 		/* FALL THROUGH */
439 	case FSID_MAJOR_MINOR:
440 	case FSID_ENCODE_DEV:
441 		return exp_sb(exp)->s_type->fs_flags & FS_REQUIRES_DEV;
442 	case FSID_NUM:
443 		return exp->ex_flags & NFSEXP_FSID;
444 	case FSID_UUID8:
445 	case FSID_UUID16:
446 		if (!is_root_export(exp))
447 			return 0;
448 		/* fall through */
449 	case FSID_UUID4_INUM:
450 	case FSID_UUID16_INUM:
451 		return exp->ex_uuid != NULL;
452 	}
453 	return 1;
454 }
455 
456 
457 static void set_version_and_fsid_type(struct svc_fh *fhp, struct svc_export *exp, struct svc_fh *ref_fh)
458 {
459 	u8 version;
460 	u8 fsid_type;
461 retry:
462 	version = 1;
463 	if (ref_fh && ref_fh->fh_export == exp) {
464 		version = ref_fh->fh_handle.fh_version;
465 		fsid_type = ref_fh->fh_handle.fh_fsid_type;
466 
467 		ref_fh = NULL;
468 
469 		switch (version) {
470 		case 0xca:
471 			fsid_type = FSID_DEV;
472 			break;
473 		case 1:
474 			break;
475 		default:
476 			goto retry;
477 		}
478 
479 		/*
480 		 * As the fsid -> filesystem mapping was guided by
481 		 * user-space, there is no guarantee that the filesystem
482 		 * actually supports that fsid type. If it doesn't we
483 		 * loop around again without ref_fh set.
484 		 */
485 		if (!fsid_type_ok_for_exp(fsid_type, exp))
486 			goto retry;
487 	} else if (exp->ex_flags & NFSEXP_FSID) {
488 		fsid_type = FSID_NUM;
489 	} else if (exp->ex_uuid) {
490 		if (fhp->fh_maxsize >= 64) {
491 			if (is_root_export(exp))
492 				fsid_type = FSID_UUID16;
493 			else
494 				fsid_type = FSID_UUID16_INUM;
495 		} else {
496 			if (is_root_export(exp))
497 				fsid_type = FSID_UUID8;
498 			else
499 				fsid_type = FSID_UUID4_INUM;
500 		}
501 	} else if (!old_valid_dev(exp_sb(exp)->s_dev))
502 		/* for newer device numbers, we must use a newer fsid format */
503 		fsid_type = FSID_ENCODE_DEV;
504 	else
505 		fsid_type = FSID_DEV;
506 	fhp->fh_handle.fh_version = version;
507 	if (version)
508 		fhp->fh_handle.fh_fsid_type = fsid_type;
509 }
510 
511 __be32
512 fh_compose(struct svc_fh *fhp, struct svc_export *exp, struct dentry *dentry,
513 	   struct svc_fh *ref_fh)
514 {
515 	/* ref_fh is a reference file handle.
516 	 * if it is non-null and for the same filesystem, then we should compose
517 	 * a filehandle which is of the same version, where possible.
518 	 * Currently, that means that if ref_fh->fh_handle.fh_version == 0xca
519 	 * Then create a 32byte filehandle using nfs_fhbase_old
520 	 *
521 	 */
522 
523 	struct inode * inode = d_inode(dentry);
524 	dev_t ex_dev = exp_sb(exp)->s_dev;
525 
526 	dprintk("nfsd: fh_compose(exp %02x:%02x/%ld %pd2, ino=%ld)\n",
527 		MAJOR(ex_dev), MINOR(ex_dev),
528 		(long) d_inode(exp->ex_path.dentry)->i_ino,
529 		dentry,
530 		(inode ? inode->i_ino : 0));
531 
532 	/* Choose filehandle version and fsid type based on
533 	 * the reference filehandle (if it is in the same export)
534 	 * or the export options.
535 	 */
536 	 set_version_and_fsid_type(fhp, exp, ref_fh);
537 
538 	if (ref_fh == fhp)
539 		fh_put(ref_fh);
540 
541 	if (fhp->fh_locked || fhp->fh_dentry) {
542 		printk(KERN_ERR "fh_compose: fh %pd2 not initialized!\n",
543 		       dentry);
544 	}
545 	if (fhp->fh_maxsize < NFS_FHSIZE)
546 		printk(KERN_ERR "fh_compose: called with maxsize %d! %pd2\n",
547 		       fhp->fh_maxsize,
548 		       dentry);
549 
550 	fhp->fh_dentry = dget(dentry); /* our internal copy */
551 	fhp->fh_export = exp_get(exp);
552 
553 	if (fhp->fh_handle.fh_version == 0xca) {
554 		/* old style filehandle please */
555 		memset(&fhp->fh_handle.fh_base, 0, NFS_FHSIZE);
556 		fhp->fh_handle.fh_size = NFS_FHSIZE;
557 		fhp->fh_handle.ofh_dcookie = 0xfeebbaca;
558 		fhp->fh_handle.ofh_dev =  old_encode_dev(ex_dev);
559 		fhp->fh_handle.ofh_xdev = fhp->fh_handle.ofh_dev;
560 		fhp->fh_handle.ofh_xino =
561 			ino_t_to_u32(d_inode(exp->ex_path.dentry)->i_ino);
562 		fhp->fh_handle.ofh_dirino = ino_t_to_u32(parent_ino(dentry));
563 		if (inode)
564 			_fh_update_old(dentry, exp, &fhp->fh_handle);
565 	} else {
566 		fhp->fh_handle.fh_size =
567 			key_len(fhp->fh_handle.fh_fsid_type) + 4;
568 		fhp->fh_handle.fh_auth_type = 0;
569 
570 		mk_fsid(fhp->fh_handle.fh_fsid_type,
571 			fhp->fh_handle.fh_fsid,
572 			ex_dev,
573 			d_inode(exp->ex_path.dentry)->i_ino,
574 			exp->ex_fsid, exp->ex_uuid);
575 
576 		if (inode)
577 			_fh_update(fhp, exp, dentry);
578 		if (fhp->fh_handle.fh_fileid_type == FILEID_INVALID) {
579 			fh_put(fhp);
580 			return nfserr_opnotsupp;
581 		}
582 	}
583 
584 	return 0;
585 }
586 
587 /*
588  * Update file handle information after changing a dentry.
589  * This is only called by nfsd_create, nfsd_create_v3 and nfsd_proc_create
590  */
591 __be32
592 fh_update(struct svc_fh *fhp)
593 {
594 	struct dentry *dentry;
595 
596 	if (!fhp->fh_dentry)
597 		goto out_bad;
598 
599 	dentry = fhp->fh_dentry;
600 	if (d_really_is_negative(dentry))
601 		goto out_negative;
602 	if (fhp->fh_handle.fh_version != 1) {
603 		_fh_update_old(dentry, fhp->fh_export, &fhp->fh_handle);
604 	} else {
605 		if (fhp->fh_handle.fh_fileid_type != FILEID_ROOT)
606 			return 0;
607 
608 		_fh_update(fhp, fhp->fh_export, dentry);
609 		if (fhp->fh_handle.fh_fileid_type == FILEID_INVALID)
610 			return nfserr_opnotsupp;
611 	}
612 	return 0;
613 out_bad:
614 	printk(KERN_ERR "fh_update: fh not verified!\n");
615 	return nfserr_serverfault;
616 out_negative:
617 	printk(KERN_ERR "fh_update: %pd2 still negative!\n",
618 		dentry);
619 	return nfserr_serverfault;
620 }
621 
622 /*
623  * Release a file handle.
624  */
625 void
626 fh_put(struct svc_fh *fhp)
627 {
628 	struct dentry * dentry = fhp->fh_dentry;
629 	struct svc_export * exp = fhp->fh_export;
630 	if (dentry) {
631 		fh_unlock(fhp);
632 		fhp->fh_dentry = NULL;
633 		dput(dentry);
634 		fh_clear_wcc(fhp);
635 	}
636 	fh_drop_write(fhp);
637 	if (exp) {
638 		exp_put(exp);
639 		fhp->fh_export = NULL;
640 	}
641 	return;
642 }
643 
644 /*
645  * Shorthand for dprintk()'s
646  */
647 char * SVCFH_fmt(struct svc_fh *fhp)
648 {
649 	struct knfsd_fh *fh = &fhp->fh_handle;
650 
651 	static char buf[80];
652 	sprintf(buf, "%d: %08x %08x %08x %08x %08x %08x",
653 		fh->fh_size,
654 		fh->fh_base.fh_pad[0],
655 		fh->fh_base.fh_pad[1],
656 		fh->fh_base.fh_pad[2],
657 		fh->fh_base.fh_pad[3],
658 		fh->fh_base.fh_pad[4],
659 		fh->fh_base.fh_pad[5]);
660 	return buf;
661 }
662 
663 enum fsid_source fsid_source(struct svc_fh *fhp)
664 {
665 	if (fhp->fh_handle.fh_version != 1)
666 		return FSIDSOURCE_DEV;
667 	switch(fhp->fh_handle.fh_fsid_type) {
668 	case FSID_DEV:
669 	case FSID_ENCODE_DEV:
670 	case FSID_MAJOR_MINOR:
671 		if (exp_sb(fhp->fh_export)->s_type->fs_flags & FS_REQUIRES_DEV)
672 			return FSIDSOURCE_DEV;
673 		break;
674 	case FSID_NUM:
675 		if (fhp->fh_export->ex_flags & NFSEXP_FSID)
676 			return FSIDSOURCE_FSID;
677 		break;
678 	default:
679 		break;
680 	}
681 	/* either a UUID type filehandle, or the filehandle doesn't
682 	 * match the export.
683 	 */
684 	if (fhp->fh_export->ex_flags & NFSEXP_FSID)
685 		return FSIDSOURCE_FSID;
686 	if (fhp->fh_export->ex_uuid)
687 		return FSIDSOURCE_UUID;
688 	return FSIDSOURCE_DEV;
689 }
690