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