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