~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfsd/nfs3proc.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Process version 3 NFS requests.
  3  *
  4  * Copyright (C) 1996, 1997, 1998 Olaf Kirch <okir@monad.swb.de>
  5  */
  6 
  7 #include <linux/fs.h>
  8 #include <linux/ext2_fs.h>
  9 #include <linux/magic.h>
 10 
 11 #include "cache.h"
 12 #include "xdr3.h"
 13 #include "vfs.h"
 14 
 15 #define NFSDDBG_FACILITY                NFSDDBG_PROC
 16 
 17 #define RETURN_STATUS(st)       { resp->status = (st); return (st); }
 18 
 19 static int      nfs3_ftypes[] = {
 20         0,                      /* NF3NON */
 21         S_IFREG,                /* NF3REG */
 22         S_IFDIR,                /* NF3DIR */
 23         S_IFBLK,                /* NF3BLK */
 24         S_IFCHR,                /* NF3CHR */
 25         S_IFLNK,                /* NF3LNK */
 26         S_IFSOCK,               /* NF3SOCK */
 27         S_IFIFO,                /* NF3FIFO */
 28 };
 29 
 30 /*
 31  * NULL call.
 32  */
 33 static __be32
 34 nfsd3_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
 35 {
 36         return nfs_ok;
 37 }
 38 
 39 /*
 40  * Get a file's attributes
 41  */
 42 static __be32
 43 nfsd3_proc_getattr(struct svc_rqst *rqstp, struct nfsd_fhandle  *argp,
 44                                            struct nfsd3_attrstat *resp)
 45 {
 46         __be32  nfserr;
 47 
 48         dprintk("nfsd: GETATTR(3)  %s\n",
 49                 SVCFH_fmt(&argp->fh));
 50 
 51         fh_copy(&resp->fh, &argp->fh);
 52         nfserr = fh_verify(rqstp, &resp->fh, 0,
 53                         NFSD_MAY_NOP | NFSD_MAY_BYPASS_GSS_ON_ROOT);
 54         if (nfserr)
 55                 RETURN_STATUS(nfserr);
 56 
 57         nfserr = fh_getattr(&resp->fh, &resp->stat);
 58 
 59         RETURN_STATUS(nfserr);
 60 }
 61 
 62 /*
 63  * Set a file's attributes
 64  */
 65 static __be32
 66 nfsd3_proc_setattr(struct svc_rqst *rqstp, struct nfsd3_sattrargs *argp,
 67                                            struct nfsd3_attrstat  *resp)
 68 {
 69         __be32  nfserr;
 70 
 71         dprintk("nfsd: SETATTR(3)  %s\n",
 72                                 SVCFH_fmt(&argp->fh));
 73 
 74         fh_copy(&resp->fh, &argp->fh);
 75         nfserr = nfsd_setattr(rqstp, &resp->fh, &argp->attrs,
 76                               argp->check_guard, argp->guardtime);
 77         RETURN_STATUS(nfserr);
 78 }
 79 
 80 /*
 81  * Look up a path name component
 82  */
 83 static __be32
 84 nfsd3_proc_lookup(struct svc_rqst *rqstp, struct nfsd3_diropargs *argp,
 85                                           struct nfsd3_diropres  *resp)
 86 {
 87         __be32  nfserr;
 88 
 89         dprintk("nfsd: LOOKUP(3)   %s %.*s\n",
 90                                 SVCFH_fmt(&argp->fh),
 91                                 argp->len,
 92                                 argp->name);
 93 
 94         fh_copy(&resp->dirfh, &argp->fh);
 95         fh_init(&resp->fh, NFS3_FHSIZE);
 96 
 97         nfserr = nfsd_lookup(rqstp, &resp->dirfh,
 98                                     argp->name,
 99                                     argp->len,
100                                     &resp->fh);
101         RETURN_STATUS(nfserr);
102 }
103 
104 /*
105  * Check file access
106  */
107 static __be32
108 nfsd3_proc_access(struct svc_rqst *rqstp, struct nfsd3_accessargs *argp,
109                                           struct nfsd3_accessres *resp)
110 {
111         __be32  nfserr;
112 
113         dprintk("nfsd: ACCESS(3)   %s 0x%x\n",
114                                 SVCFH_fmt(&argp->fh),
115                                 argp->access);
116 
117         fh_copy(&resp->fh, &argp->fh);
118         resp->access = argp->access;
119         nfserr = nfsd_access(rqstp, &resp->fh, &resp->access, NULL);
120         RETURN_STATUS(nfserr);
121 }
122 
123 /*
124  * Read a symlink.
125  */
126 static __be32
127 nfsd3_proc_readlink(struct svc_rqst *rqstp, struct nfsd3_readlinkargs *argp,
128                                            struct nfsd3_readlinkres *resp)
129 {
130         __be32 nfserr;
131 
132         dprintk("nfsd: READLINK(3) %s\n", SVCFH_fmt(&argp->fh));
133 
134         /* Read the symlink. */
135         fh_copy(&resp->fh, &argp->fh);
136         resp->len = NFS3_MAXPATHLEN;
137         nfserr = nfsd_readlink(rqstp, &resp->fh, argp->buffer, &resp->len);
138         RETURN_STATUS(nfserr);
139 }
140 
141 /*
142  * Read a portion of a file.
143  */
144 static __be32
145 nfsd3_proc_read(struct svc_rqst *rqstp, struct nfsd3_readargs *argp,
146                                         struct nfsd3_readres  *resp)
147 {
148         __be32  nfserr;
149         u32     max_blocksize = svc_max_payload(rqstp);
150         unsigned long cnt = min(argp->count, max_blocksize);
151 
152         dprintk("nfsd: READ(3) %s %lu bytes at %Lu\n",
153                                 SVCFH_fmt(&argp->fh),
154                                 (unsigned long) argp->count,
155                                 (unsigned long long) argp->offset);
156 
157         /* Obtain buffer pointer for payload.
158          * 1 (status) + 22 (post_op_attr) + 1 (count) + 1 (eof)
159          * + 1 (xdr opaque byte count) = 26
160          */
161         resp->count = cnt;
162         svc_reserve_auth(rqstp, ((1 + NFS3_POST_OP_ATTR_WORDS + 3)<<2) + resp->count +4);
163 
164         fh_copy(&resp->fh, &argp->fh);
165         nfserr = nfsd_read(rqstp, &resp->fh,
166                                   argp->offset,
167                                   rqstp->rq_vec, argp->vlen,
168                                   &resp->count);
169         if (nfserr == 0) {
170                 struct inode    *inode = d_inode(resp->fh.fh_dentry);
171                 resp->eof = nfsd_eof_on_read(cnt, resp->count, argp->offset,
172                                                         inode->i_size);
173         }
174 
175         RETURN_STATUS(nfserr);
176 }
177 
178 /*
179  * Write data to a file
180  */
181 static __be32
182 nfsd3_proc_write(struct svc_rqst *rqstp, struct nfsd3_writeargs *argp,
183                                          struct nfsd3_writeres  *resp)
184 {
185         __be32  nfserr;
186         unsigned long cnt = argp->len;
187 
188         dprintk("nfsd: WRITE(3)    %s %d bytes at %Lu%s\n",
189                                 SVCFH_fmt(&argp->fh),
190                                 argp->len,
191                                 (unsigned long long) argp->offset,
192                                 argp->stable? " stable" : "");
193 
194         fh_copy(&resp->fh, &argp->fh);
195         resp->committed = argp->stable;
196         nfserr = nfsd_write(rqstp, &resp->fh, NULL,
197                                    argp->offset,
198                                    rqstp->rq_vec, argp->vlen,
199                                    &cnt,
200                                    &resp->committed);
201         resp->count = cnt;
202         RETURN_STATUS(nfserr);
203 }
204 
205 /*
206  * With NFSv3, CREATE processing is a lot easier than with NFSv2.
207  * At least in theory; we'll see how it fares in practice when the
208  * first reports about SunOS compatibility problems start to pour in...
209  */
210 static __be32
211 nfsd3_proc_create(struct svc_rqst *rqstp, struct nfsd3_createargs *argp,
212                                           struct nfsd3_diropres   *resp)
213 {
214         svc_fh          *dirfhp, *newfhp = NULL;
215         struct iattr    *attr;
216         __be32          nfserr;
217 
218         dprintk("nfsd: CREATE(3)   %s %.*s\n",
219                                 SVCFH_fmt(&argp->fh),
220                                 argp->len,
221                                 argp->name);
222 
223         dirfhp = fh_copy(&resp->dirfh, &argp->fh);
224         newfhp = fh_init(&resp->fh, NFS3_FHSIZE);
225         attr   = &argp->attrs;
226 
227         /* Unfudge the mode bits */
228         attr->ia_mode &= ~S_IFMT;
229         if (!(attr->ia_valid & ATTR_MODE)) { 
230                 attr->ia_valid |= ATTR_MODE;
231                 attr->ia_mode = S_IFREG;
232         } else {
233                 attr->ia_mode = (attr->ia_mode & ~S_IFMT) | S_IFREG;
234         }
235 
236         /* Now create the file and set attributes */
237         nfserr = do_nfsd_create(rqstp, dirfhp, argp->name, argp->len,
238                                 attr, newfhp,
239                                 argp->createmode, (u32 *)argp->verf, NULL, NULL);
240 
241         RETURN_STATUS(nfserr);
242 }
243 
244 /*
245  * Make directory. This operation is not idempotent.
246  */
247 static __be32
248 nfsd3_proc_mkdir(struct svc_rqst *rqstp, struct nfsd3_createargs *argp,
249                                          struct nfsd3_diropres   *resp)
250 {
251         __be32  nfserr;
252 
253         dprintk("nfsd: MKDIR(3)    %s %.*s\n",
254                                 SVCFH_fmt(&argp->fh),
255                                 argp->len,
256                                 argp->name);
257 
258         argp->attrs.ia_valid &= ~ATTR_SIZE;
259         fh_copy(&resp->dirfh, &argp->fh);
260         fh_init(&resp->fh, NFS3_FHSIZE);
261         nfserr = nfsd_create(rqstp, &resp->dirfh, argp->name, argp->len,
262                                     &argp->attrs, S_IFDIR, 0, &resp->fh);
263         fh_unlock(&resp->dirfh);
264         RETURN_STATUS(nfserr);
265 }
266 
267 static __be32
268 nfsd3_proc_symlink(struct svc_rqst *rqstp, struct nfsd3_symlinkargs *argp,
269                                            struct nfsd3_diropres    *resp)
270 {
271         __be32  nfserr;
272 
273         dprintk("nfsd: SYMLINK(3)  %s %.*s -> %.*s\n",
274                                 SVCFH_fmt(&argp->ffh),
275                                 argp->flen, argp->fname,
276                                 argp->tlen, argp->tname);
277 
278         fh_copy(&resp->dirfh, &argp->ffh);
279         fh_init(&resp->fh, NFS3_FHSIZE);
280         nfserr = nfsd_symlink(rqstp, &resp->dirfh, argp->fname, argp->flen,
281                                                    argp->tname, &resp->fh);
282         RETURN_STATUS(nfserr);
283 }
284 
285 /*
286  * Make socket/fifo/device.
287  */
288 static __be32
289 nfsd3_proc_mknod(struct svc_rqst *rqstp, struct nfsd3_mknodargs *argp,
290                                          struct nfsd3_diropres  *resp)
291 {
292         __be32  nfserr;
293         int type;
294         dev_t   rdev = 0;
295 
296         dprintk("nfsd: MKNOD(3)    %s %.*s\n",
297                                 SVCFH_fmt(&argp->fh),
298                                 argp->len,
299                                 argp->name);
300 
301         fh_copy(&resp->dirfh, &argp->fh);
302         fh_init(&resp->fh, NFS3_FHSIZE);
303 
304         if (argp->ftype == 0 || argp->ftype >= NF3BAD)
305                 RETURN_STATUS(nfserr_inval);
306         if (argp->ftype == NF3CHR || argp->ftype == NF3BLK) {
307                 rdev = MKDEV(argp->major, argp->minor);
308                 if (MAJOR(rdev) != argp->major ||
309                     MINOR(rdev) != argp->minor)
310                         RETURN_STATUS(nfserr_inval);
311         } else
312                 if (argp->ftype != NF3SOCK && argp->ftype != NF3FIFO)
313                         RETURN_STATUS(nfserr_inval);
314 
315         type = nfs3_ftypes[argp->ftype];
316         nfserr = nfsd_create(rqstp, &resp->dirfh, argp->name, argp->len,
317                                     &argp->attrs, type, rdev, &resp->fh);
318         fh_unlock(&resp->dirfh);
319         RETURN_STATUS(nfserr);
320 }
321 
322 /*
323  * Remove file/fifo/socket etc.
324  */
325 static __be32
326 nfsd3_proc_remove(struct svc_rqst *rqstp, struct nfsd3_diropargs *argp,
327                                           struct nfsd3_attrstat  *resp)
328 {
329         __be32  nfserr;
330 
331         dprintk("nfsd: REMOVE(3)   %s %.*s\n",
332                                 SVCFH_fmt(&argp->fh),
333                                 argp->len,
334                                 argp->name);
335 
336         /* Unlink. -S_IFDIR means file must not be a directory */
337         fh_copy(&resp->fh, &argp->fh);
338         nfserr = nfsd_unlink(rqstp, &resp->fh, -S_IFDIR, argp->name, argp->len);
339         fh_unlock(&resp->fh);
340         RETURN_STATUS(nfserr);
341 }
342 
343 /*
344  * Remove a directory
345  */
346 static __be32
347 nfsd3_proc_rmdir(struct svc_rqst *rqstp, struct nfsd3_diropargs *argp,
348                                          struct nfsd3_attrstat  *resp)
349 {
350         __be32  nfserr;
351 
352         dprintk("nfsd: RMDIR(3)    %s %.*s\n",
353                                 SVCFH_fmt(&argp->fh),
354                                 argp->len,
355                                 argp->name);
356 
357         fh_copy(&resp->fh, &argp->fh);
358         nfserr = nfsd_unlink(rqstp, &resp->fh, S_IFDIR, argp->name, argp->len);
359         fh_unlock(&resp->fh);
360         RETURN_STATUS(nfserr);
361 }
362 
363 static __be32
364 nfsd3_proc_rename(struct svc_rqst *rqstp, struct nfsd3_renameargs *argp,
365                                           struct nfsd3_renameres  *resp)
366 {
367         __be32  nfserr;
368 
369         dprintk("nfsd: RENAME(3)   %s %.*s ->\n",
370                                 SVCFH_fmt(&argp->ffh),
371                                 argp->flen,
372                                 argp->fname);
373         dprintk("nfsd: -> %s %.*s\n",
374                                 SVCFH_fmt(&argp->tfh),
375                                 argp->tlen,
376                                 argp->tname);
377 
378         fh_copy(&resp->ffh, &argp->ffh);
379         fh_copy(&resp->tfh, &argp->tfh);
380         nfserr = nfsd_rename(rqstp, &resp->ffh, argp->fname, argp->flen,
381                                     &resp->tfh, argp->tname, argp->tlen);
382         RETURN_STATUS(nfserr);
383 }
384 
385 static __be32
386 nfsd3_proc_link(struct svc_rqst *rqstp, struct nfsd3_linkargs *argp,
387                                         struct nfsd3_linkres  *resp)
388 {
389         __be32  nfserr;
390 
391         dprintk("nfsd: LINK(3)     %s ->\n",
392                                 SVCFH_fmt(&argp->ffh));
393         dprintk("nfsd:   -> %s %.*s\n",
394                                 SVCFH_fmt(&argp->tfh),
395                                 argp->tlen,
396                                 argp->tname);
397 
398         fh_copy(&resp->fh,  &argp->ffh);
399         fh_copy(&resp->tfh, &argp->tfh);
400         nfserr = nfsd_link(rqstp, &resp->tfh, argp->tname, argp->tlen,
401                                   &resp->fh);
402         RETURN_STATUS(nfserr);
403 }
404 
405 /*
406  * Read a portion of a directory.
407  */
408 static __be32
409 nfsd3_proc_readdir(struct svc_rqst *rqstp, struct nfsd3_readdirargs *argp,
410                                            struct nfsd3_readdirres  *resp)
411 {
412         __be32          nfserr;
413         int             count;
414 
415         dprintk("nfsd: READDIR(3)  %s %d bytes at %d\n",
416                                 SVCFH_fmt(&argp->fh),
417                                 argp->count, (u32) argp->cookie);
418 
419         /* Make sure we've room for the NULL ptr & eof flag, and shrink to
420          * client read size */
421         count = (argp->count >> 2) - 2;
422 
423         /* Read directory and encode entries on the fly */
424         fh_copy(&resp->fh, &argp->fh);
425 
426         resp->buflen = count;
427         resp->common.err = nfs_ok;
428         resp->buffer = argp->buffer;
429         resp->rqstp = rqstp;
430         nfserr = nfsd_readdir(rqstp, &resp->fh, (loff_t*) &argp->cookie, 
431                                         &resp->common, nfs3svc_encode_entry);
432         memcpy(resp->verf, argp->verf, 8);
433         resp->count = resp->buffer - argp->buffer;
434         if (resp->offset)
435                 xdr_encode_hyper(resp->offset, argp->cookie);
436 
437         RETURN_STATUS(nfserr);
438 }
439 
440 /*
441  * Read a portion of a directory, including file handles and attrs.
442  * For now, we choose to ignore the dircount parameter.
443  */
444 static __be32
445 nfsd3_proc_readdirplus(struct svc_rqst *rqstp, struct nfsd3_readdirargs *argp,
446                                                struct nfsd3_readdirres  *resp)
447 {
448         __be32  nfserr;
449         int     count = 0;
450         loff_t  offset;
451         struct page **p;
452         caddr_t page_addr = NULL;
453 
454         dprintk("nfsd: READDIR+(3) %s %d bytes at %d\n",
455                                 SVCFH_fmt(&argp->fh),
456                                 argp->count, (u32) argp->cookie);
457 
458         /* Convert byte count to number of words (i.e. >> 2),
459          * and reserve room for the NULL ptr & eof flag (-2 words) */
460         resp->count = (argp->count >> 2) - 2;
461 
462         /* Read directory and encode entries on the fly */
463         fh_copy(&resp->fh, &argp->fh);
464 
465         resp->common.err = nfs_ok;
466         resp->buffer = argp->buffer;
467         resp->buflen = resp->count;
468         resp->rqstp = rqstp;
469         offset = argp->cookie;
470 
471         nfserr = fh_verify(rqstp, &resp->fh, S_IFDIR, NFSD_MAY_NOP);
472         if (nfserr)
473                 RETURN_STATUS(nfserr);
474 
475         if (resp->fh.fh_export->ex_flags & NFSEXP_NOREADDIRPLUS)
476                 RETURN_STATUS(nfserr_notsupp);
477 
478         nfserr = nfsd_readdir(rqstp, &resp->fh,
479                                      &offset,
480                                      &resp->common,
481                                      nfs3svc_encode_entry_plus);
482         memcpy(resp->verf, argp->verf, 8);
483         for (p = rqstp->rq_respages + 1; p < rqstp->rq_next_page; p++) {
484                 page_addr = page_address(*p);
485 
486                 if (((caddr_t)resp->buffer >= page_addr) &&
487                     ((caddr_t)resp->buffer < page_addr + PAGE_SIZE)) {
488                         count += (caddr_t)resp->buffer - page_addr;
489                         break;
490                 }
491                 count += PAGE_SIZE;
492         }
493         resp->count = count >> 2;
494         if (resp->offset) {
495                 if (unlikely(resp->offset1)) {
496                         /* we ended up with offset on a page boundary */
497                         *resp->offset = htonl(offset >> 32);
498                         *resp->offset1 = htonl(offset & 0xffffffff);
499                         resp->offset1 = NULL;
500                 } else {
501                         xdr_encode_hyper(resp->offset, offset);
502                 }
503         }
504 
505         RETURN_STATUS(nfserr);
506 }
507 
508 /*
509  * Get file system stats
510  */
511 static __be32
512 nfsd3_proc_fsstat(struct svc_rqst * rqstp, struct nfsd_fhandle    *argp,
513                                            struct nfsd3_fsstatres *resp)
514 {
515         __be32  nfserr;
516 
517         dprintk("nfsd: FSSTAT(3)   %s\n",
518                                 SVCFH_fmt(&argp->fh));
519 
520         nfserr = nfsd_statfs(rqstp, &argp->fh, &resp->stats, 0);
521         fh_put(&argp->fh);
522         RETURN_STATUS(nfserr);
523 }
524 
525 /*
526  * Get file system info
527  */
528 static __be32
529 nfsd3_proc_fsinfo(struct svc_rqst * rqstp, struct nfsd_fhandle    *argp,
530                                            struct nfsd3_fsinfores *resp)
531 {
532         __be32  nfserr;
533         u32     max_blocksize = svc_max_payload(rqstp);
534 
535         dprintk("nfsd: FSINFO(3)   %s\n",
536                                 SVCFH_fmt(&argp->fh));
537 
538         resp->f_rtmax  = max_blocksize;
539         resp->f_rtpref = max_blocksize;
540         resp->f_rtmult = PAGE_SIZE;
541         resp->f_wtmax  = max_blocksize;
542         resp->f_wtpref = max_blocksize;
543         resp->f_wtmult = PAGE_SIZE;
544         resp->f_dtpref = PAGE_SIZE;
545         resp->f_maxfilesize = ~(u32) 0;
546         resp->f_properties = NFS3_FSF_DEFAULT;
547 
548         nfserr = fh_verify(rqstp, &argp->fh, 0,
549                         NFSD_MAY_NOP | NFSD_MAY_BYPASS_GSS_ON_ROOT);
550 
551         /* Check special features of the file system. May request
552          * different read/write sizes for file systems known to have
553          * problems with large blocks */
554         if (nfserr == 0) {
555                 struct super_block *sb = argp->fh.fh_dentry->d_sb;
556 
557                 /* Note that we don't care for remote fs's here */
558                 if (sb->s_magic == MSDOS_SUPER_MAGIC) {
559                         resp->f_properties = NFS3_FSF_BILLYBOY;
560                 }
561                 resp->f_maxfilesize = sb->s_maxbytes;
562         }
563 
564         fh_put(&argp->fh);
565         RETURN_STATUS(nfserr);
566 }
567 
568 /*
569  * Get pathconf info for the specified file
570  */
571 static __be32
572 nfsd3_proc_pathconf(struct svc_rqst * rqstp, struct nfsd_fhandle      *argp,
573                                              struct nfsd3_pathconfres *resp)
574 {
575         __be32  nfserr;
576 
577         dprintk("nfsd: PATHCONF(3) %s\n",
578                                 SVCFH_fmt(&argp->fh));
579 
580         /* Set default pathconf */
581         resp->p_link_max = 255;         /* at least */
582         resp->p_name_max = 255;         /* at least */
583         resp->p_no_trunc = 0;
584         resp->p_chown_restricted = 1;
585         resp->p_case_insensitive = 0;
586         resp->p_case_preserving = 1;
587 
588         nfserr = fh_verify(rqstp, &argp->fh, 0, NFSD_MAY_NOP);
589 
590         if (nfserr == 0) {
591                 struct super_block *sb = argp->fh.fh_dentry->d_sb;
592 
593                 /* Note that we don't care for remote fs's here */
594                 switch (sb->s_magic) {
595                 case EXT2_SUPER_MAGIC:
596                         resp->p_link_max = EXT2_LINK_MAX;
597                         resp->p_name_max = EXT2_NAME_LEN;
598                         break;
599                 case MSDOS_SUPER_MAGIC:
600                         resp->p_case_insensitive = 1;
601                         resp->p_case_preserving  = 0;
602                         break;
603                 }
604         }
605 
606         fh_put(&argp->fh);
607         RETURN_STATUS(nfserr);
608 }
609 
610 
611 /*
612  * Commit a file (range) to stable storage.
613  */
614 static __be32
615 nfsd3_proc_commit(struct svc_rqst * rqstp, struct nfsd3_commitargs *argp,
616                                            struct nfsd3_commitres  *resp)
617 {
618         __be32  nfserr;
619 
620         dprintk("nfsd: COMMIT(3)   %s %u@%Lu\n",
621                                 SVCFH_fmt(&argp->fh),
622                                 argp->count,
623                                 (unsigned long long) argp->offset);
624 
625         if (argp->offset > NFS_OFFSET_MAX)
626                 RETURN_STATUS(nfserr_inval);
627 
628         fh_copy(&resp->fh, &argp->fh);
629         nfserr = nfsd_commit(rqstp, &resp->fh, argp->offset, argp->count);
630 
631         RETURN_STATUS(nfserr);
632 }
633 
634 
635 /*
636  * NFSv3 Server procedures.
637  * Only the results of non-idempotent operations are cached.
638  */
639 #define nfs3svc_decode_fhandleargs      nfs3svc_decode_fhandle
640 #define nfs3svc_encode_attrstatres      nfs3svc_encode_attrstat
641 #define nfs3svc_encode_wccstatres       nfs3svc_encode_wccstat
642 #define nfsd3_mkdirargs                 nfsd3_createargs
643 #define nfsd3_readdirplusargs           nfsd3_readdirargs
644 #define nfsd3_fhandleargs               nfsd_fhandle
645 #define nfsd3_fhandleres                nfsd3_attrstat
646 #define nfsd3_attrstatres               nfsd3_attrstat
647 #define nfsd3_wccstatres                nfsd3_attrstat
648 #define nfsd3_createres                 nfsd3_diropres
649 #define nfsd3_voidres                   nfsd3_voidargs
650 struct nfsd3_voidargs { int dummy; };
651 
652 #define PROC(name, argt, rest, relt, cache, respsize)   \
653  { (svc_procfunc) nfsd3_proc_##name,            \
654    (kxdrproc_t) nfs3svc_decode_##argt##args,    \
655    (kxdrproc_t) nfs3svc_encode_##rest##res,     \
656    (kxdrproc_t) nfs3svc_release_##relt,         \
657    sizeof(struct nfsd3_##argt##args),           \
658    sizeof(struct nfsd3_##rest##res),            \
659    0,                                           \
660    cache,                                       \
661    respsize,                                    \
662  }
663 
664 #define ST 1            /* status*/
665 #define FH 17           /* filehandle with length */
666 #define AT 21           /* attributes */
667 #define pAT (1+AT)      /* post attributes - conditional */
668 #define WC (7+pAT)      /* WCC attributes */
669 
670 static struct svc_procedure             nfsd_procedures3[22] = {
671         [NFS3PROC_NULL] = {
672                 .pc_func = (svc_procfunc) nfsd3_proc_null,
673                 .pc_encode = (kxdrproc_t) nfs3svc_encode_voidres,
674                 .pc_argsize = sizeof(struct nfsd3_voidargs),
675                 .pc_ressize = sizeof(struct nfsd3_voidres),
676                 .pc_cachetype = RC_NOCACHE,
677                 .pc_xdrressize = ST,
678         },
679         [NFS3PROC_GETATTR] = {
680                 .pc_func = (svc_procfunc) nfsd3_proc_getattr,
681                 .pc_decode = (kxdrproc_t) nfs3svc_decode_fhandleargs,
682                 .pc_encode = (kxdrproc_t) nfs3svc_encode_attrstatres,
683                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
684                 .pc_argsize = sizeof(struct nfsd3_fhandleargs),
685                 .pc_ressize = sizeof(struct nfsd3_attrstatres),
686                 .pc_cachetype = RC_NOCACHE,
687                 .pc_xdrressize = ST+AT,
688         },
689         [NFS3PROC_SETATTR] = {
690                 .pc_func = (svc_procfunc) nfsd3_proc_setattr,
691                 .pc_decode = (kxdrproc_t) nfs3svc_decode_sattrargs,
692                 .pc_encode = (kxdrproc_t) nfs3svc_encode_wccstatres,
693                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
694                 .pc_argsize = sizeof(struct nfsd3_sattrargs),
695                 .pc_ressize = sizeof(struct nfsd3_wccstatres),
696                 .pc_cachetype = RC_REPLBUFF,
697                 .pc_xdrressize = ST+WC,
698         },
699         [NFS3PROC_LOOKUP] = {
700                 .pc_func = (svc_procfunc) nfsd3_proc_lookup,
701                 .pc_decode = (kxdrproc_t) nfs3svc_decode_diropargs,
702                 .pc_encode = (kxdrproc_t) nfs3svc_encode_diropres,
703                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
704                 .pc_argsize = sizeof(struct nfsd3_diropargs),
705                 .pc_ressize = sizeof(struct nfsd3_diropres),
706                 .pc_cachetype = RC_NOCACHE,
707                 .pc_xdrressize = ST+FH+pAT+pAT,
708         },
709         [NFS3PROC_ACCESS] = {
710                 .pc_func = (svc_procfunc) nfsd3_proc_access,
711                 .pc_decode = (kxdrproc_t) nfs3svc_decode_accessargs,
712                 .pc_encode = (kxdrproc_t) nfs3svc_encode_accessres,
713                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
714                 .pc_argsize = sizeof(struct nfsd3_accessargs),
715                 .pc_ressize = sizeof(struct nfsd3_accessres),
716                 .pc_cachetype = RC_NOCACHE,
717                 .pc_xdrressize = ST+pAT+1,
718         },
719         [NFS3PROC_READLINK] = {
720                 .pc_func = (svc_procfunc) nfsd3_proc_readlink,
721                 .pc_decode = (kxdrproc_t) nfs3svc_decode_readlinkargs,
722                 .pc_encode = (kxdrproc_t) nfs3svc_encode_readlinkres,
723                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
724                 .pc_argsize = sizeof(struct nfsd3_readlinkargs),
725                 .pc_ressize = sizeof(struct nfsd3_readlinkres),
726                 .pc_cachetype = RC_NOCACHE,
727                 .pc_xdrressize = ST+pAT+1+NFS3_MAXPATHLEN/4,
728         },
729         [NFS3PROC_READ] = {
730                 .pc_func = (svc_procfunc) nfsd3_proc_read,
731                 .pc_decode = (kxdrproc_t) nfs3svc_decode_readargs,
732                 .pc_encode = (kxdrproc_t) nfs3svc_encode_readres,
733                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
734                 .pc_argsize = sizeof(struct nfsd3_readargs),
735                 .pc_ressize = sizeof(struct nfsd3_readres),
736                 .pc_cachetype = RC_NOCACHE,
737                 .pc_xdrressize = ST+pAT+4+NFSSVC_MAXBLKSIZE/4,
738         },
739         [NFS3PROC_WRITE] = {
740                 .pc_func = (svc_procfunc) nfsd3_proc_write,
741                 .pc_decode = (kxdrproc_t) nfs3svc_decode_writeargs,
742                 .pc_encode = (kxdrproc_t) nfs3svc_encode_writeres,
743                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
744                 .pc_argsize = sizeof(struct nfsd3_writeargs),
745                 .pc_ressize = sizeof(struct nfsd3_writeres),
746                 .pc_cachetype = RC_REPLBUFF,
747                 .pc_xdrressize = ST+WC+4,
748         },
749         [NFS3PROC_CREATE] = {
750                 .pc_func = (svc_procfunc) nfsd3_proc_create,
751                 .pc_decode = (kxdrproc_t) nfs3svc_decode_createargs,
752                 .pc_encode = (kxdrproc_t) nfs3svc_encode_createres,
753                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
754                 .pc_argsize = sizeof(struct nfsd3_createargs),
755                 .pc_ressize = sizeof(struct nfsd3_createres),
756                 .pc_cachetype = RC_REPLBUFF,
757                 .pc_xdrressize = ST+(1+FH+pAT)+WC,
758         },
759         [NFS3PROC_MKDIR] = {
760                 .pc_func = (svc_procfunc) nfsd3_proc_mkdir,
761                 .pc_decode = (kxdrproc_t) nfs3svc_decode_mkdirargs,
762                 .pc_encode = (kxdrproc_t) nfs3svc_encode_createres,
763                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
764                 .pc_argsize = sizeof(struct nfsd3_mkdirargs),
765                 .pc_ressize = sizeof(struct nfsd3_createres),
766                 .pc_cachetype = RC_REPLBUFF,
767                 .pc_xdrressize = ST+(1+FH+pAT)+WC,
768         },
769         [NFS3PROC_SYMLINK] = {
770                 .pc_func = (svc_procfunc) nfsd3_proc_symlink,
771                 .pc_decode = (kxdrproc_t) nfs3svc_decode_symlinkargs,
772                 .pc_encode = (kxdrproc_t) nfs3svc_encode_createres,
773                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
774                 .pc_argsize = sizeof(struct nfsd3_symlinkargs),
775                 .pc_ressize = sizeof(struct nfsd3_createres),
776                 .pc_cachetype = RC_REPLBUFF,
777                 .pc_xdrressize = ST+(1+FH+pAT)+WC,
778         },
779         [NFS3PROC_MKNOD] = {
780                 .pc_func = (svc_procfunc) nfsd3_proc_mknod,
781                 .pc_decode = (kxdrproc_t) nfs3svc_decode_mknodargs,
782                 .pc_encode = (kxdrproc_t) nfs3svc_encode_createres,
783                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
784                 .pc_argsize = sizeof(struct nfsd3_mknodargs),
785                 .pc_ressize = sizeof(struct nfsd3_createres),
786                 .pc_cachetype = RC_REPLBUFF,
787                 .pc_xdrressize = ST+(1+FH+pAT)+WC,
788         },
789         [NFS3PROC_REMOVE] = {
790                 .pc_func = (svc_procfunc) nfsd3_proc_remove,
791                 .pc_decode = (kxdrproc_t) nfs3svc_decode_diropargs,
792                 .pc_encode = (kxdrproc_t) nfs3svc_encode_wccstatres,
793                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
794                 .pc_argsize = sizeof(struct nfsd3_diropargs),
795                 .pc_ressize = sizeof(struct nfsd3_wccstatres),
796                 .pc_cachetype = RC_REPLBUFF,
797                 .pc_xdrressize = ST+WC,
798         },
799         [NFS3PROC_RMDIR] = {
800                 .pc_func = (svc_procfunc) nfsd3_proc_rmdir,
801                 .pc_decode = (kxdrproc_t) nfs3svc_decode_diropargs,
802                 .pc_encode = (kxdrproc_t) nfs3svc_encode_wccstatres,
803                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
804                 .pc_argsize = sizeof(struct nfsd3_diropargs),
805                 .pc_ressize = sizeof(struct nfsd3_wccstatres),
806                 .pc_cachetype = RC_REPLBUFF,
807                 .pc_xdrressize = ST+WC,
808         },
809         [NFS3PROC_RENAME] = {
810                 .pc_func = (svc_procfunc) nfsd3_proc_rename,
811                 .pc_decode = (kxdrproc_t) nfs3svc_decode_renameargs,
812                 .pc_encode = (kxdrproc_t) nfs3svc_encode_renameres,
813                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
814                 .pc_argsize = sizeof(struct nfsd3_renameargs),
815                 .pc_ressize = sizeof(struct nfsd3_renameres),
816                 .pc_cachetype = RC_REPLBUFF,
817                 .pc_xdrressize = ST+WC+WC,
818         },
819         [NFS3PROC_LINK] = {
820                 .pc_func = (svc_procfunc) nfsd3_proc_link,
821                 .pc_decode = (kxdrproc_t) nfs3svc_decode_linkargs,
822                 .pc_encode = (kxdrproc_t) nfs3svc_encode_linkres,
823                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
824                 .pc_argsize = sizeof(struct nfsd3_linkargs),
825                 .pc_ressize = sizeof(struct nfsd3_linkres),
826                 .pc_cachetype = RC_REPLBUFF,
827                 .pc_xdrressize = ST+pAT+WC,
828         },
829         [NFS3PROC_READDIR] = {
830                 .pc_func = (svc_procfunc) nfsd3_proc_readdir,
831                 .pc_decode = (kxdrproc_t) nfs3svc_decode_readdirargs,
832                 .pc_encode = (kxdrproc_t) nfs3svc_encode_readdirres,
833                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
834                 .pc_argsize = sizeof(struct nfsd3_readdirargs),
835                 .pc_ressize = sizeof(struct nfsd3_readdirres),
836                 .pc_cachetype = RC_NOCACHE,
837         },
838         [NFS3PROC_READDIRPLUS] = {
839                 .pc_func = (svc_procfunc) nfsd3_proc_readdirplus,
840                 .pc_decode = (kxdrproc_t) nfs3svc_decode_readdirplusargs,
841                 .pc_encode = (kxdrproc_t) nfs3svc_encode_readdirres,
842                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
843                 .pc_argsize = sizeof(struct nfsd3_readdirplusargs),
844                 .pc_ressize = sizeof(struct nfsd3_readdirres),
845                 .pc_cachetype = RC_NOCACHE,
846         },
847         [NFS3PROC_FSSTAT] = {
848                 .pc_func = (svc_procfunc) nfsd3_proc_fsstat,
849                 .pc_decode = (kxdrproc_t) nfs3svc_decode_fhandleargs,
850                 .pc_encode = (kxdrproc_t) nfs3svc_encode_fsstatres,
851                 .pc_argsize = sizeof(struct nfsd3_fhandleargs),
852                 .pc_ressize = sizeof(struct nfsd3_fsstatres),
853                 .pc_cachetype = RC_NOCACHE,
854                 .pc_xdrressize = ST+pAT+2*6+1,
855         },
856         [NFS3PROC_FSINFO] = {
857                 .pc_func = (svc_procfunc) nfsd3_proc_fsinfo,
858                 .pc_decode = (kxdrproc_t) nfs3svc_decode_fhandleargs,
859                 .pc_encode = (kxdrproc_t) nfs3svc_encode_fsinfores,
860                 .pc_argsize = sizeof(struct nfsd3_fhandleargs),
861                 .pc_ressize = sizeof(struct nfsd3_fsinfores),
862                 .pc_cachetype = RC_NOCACHE,
863                 .pc_xdrressize = ST+pAT+12,
864         },
865         [NFS3PROC_PATHCONF] = {
866                 .pc_func = (svc_procfunc) nfsd3_proc_pathconf,
867                 .pc_decode = (kxdrproc_t) nfs3svc_decode_fhandleargs,
868                 .pc_encode = (kxdrproc_t) nfs3svc_encode_pathconfres,
869                 .pc_argsize = sizeof(struct nfsd3_fhandleargs),
870                 .pc_ressize = sizeof(struct nfsd3_pathconfres),
871                 .pc_cachetype = RC_NOCACHE,
872                 .pc_xdrressize = ST+pAT+6,
873         },
874         [NFS3PROC_COMMIT] = {
875                 .pc_func = (svc_procfunc) nfsd3_proc_commit,
876                 .pc_decode = (kxdrproc_t) nfs3svc_decode_commitargs,
877                 .pc_encode = (kxdrproc_t) nfs3svc_encode_commitres,
878                 .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
879                 .pc_argsize = sizeof(struct nfsd3_commitargs),
880                 .pc_ressize = sizeof(struct nfsd3_commitres),
881                 .pc_cachetype = RC_NOCACHE,
882                 .pc_xdrressize = ST+WC+2,
883         },
884 };
885 
886 struct svc_version      nfsd_version3 = {
887                 .vs_vers        = 3,
888                 .vs_nproc       = 22,
889                 .vs_proc        = nfsd_procedures3,
890                 .vs_dispatch    = nfsd_dispatch,
891                 .vs_xdrsize     = NFS3_SVC_XDRSIZE,
892 };
893 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp