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 unsigned int nvecs; 196 197 dprintk("nfsd: WRITE(3) %s %d bytes at %Lu%s\n", 198 SVCFH_fmt(&argp->fh), 199 argp->len, 200 (unsigned long long) argp->offset, 201 argp->stable? " stable" : ""); 202 203 fh_copy(&resp->fh, &argp->fh); 204 resp->committed = argp->stable; 205 nvecs = svc_fill_write_vector(rqstp, rqstp->rq_arg.pages, 206 &argp->first, cnt); 207 if (!nvecs) 208 RETURN_STATUS(nfserr_io); 209 nfserr = nfsd_write(rqstp, &resp->fh, argp->offset, 210 rqstp->rq_vec, nvecs, &cnt, 211 resp->committed); 212 resp->count = cnt; 213 RETURN_STATUS(nfserr); 214 } 215 216 /* 217 * With NFSv3, CREATE processing is a lot easier than with NFSv2. 218 * At least in theory; we'll see how it fares in practice when the 219 * first reports about SunOS compatibility problems start to pour in... 220 */ 221 static __be32 222 nfsd3_proc_create(struct svc_rqst *rqstp) 223 { 224 struct nfsd3_createargs *argp = rqstp->rq_argp; 225 struct nfsd3_diropres *resp = rqstp->rq_resp; 226 svc_fh *dirfhp, *newfhp = NULL; 227 struct iattr *attr; 228 __be32 nfserr; 229 230 dprintk("nfsd: CREATE(3) %s %.*s\n", 231 SVCFH_fmt(&argp->fh), 232 argp->len, 233 argp->name); 234 235 dirfhp = fh_copy(&resp->dirfh, &argp->fh); 236 newfhp = fh_init(&resp->fh, NFS3_FHSIZE); 237 attr = &argp->attrs; 238 239 /* Unfudge the mode bits */ 240 attr->ia_mode &= ~S_IFMT; 241 if (!(attr->ia_valid & ATTR_MODE)) { 242 attr->ia_valid |= ATTR_MODE; 243 attr->ia_mode = S_IFREG; 244 } else { 245 attr->ia_mode = (attr->ia_mode & ~S_IFMT) | S_IFREG; 246 } 247 248 /* Now create the file and set attributes */ 249 nfserr = do_nfsd_create(rqstp, dirfhp, argp->name, argp->len, 250 attr, newfhp, 251 argp->createmode, (u32 *)argp->verf, NULL, NULL); 252 253 RETURN_STATUS(nfserr); 254 } 255 256 /* 257 * Make directory. This operation is not idempotent. 258 */ 259 static __be32 260 nfsd3_proc_mkdir(struct svc_rqst *rqstp) 261 { 262 struct nfsd3_createargs *argp = rqstp->rq_argp; 263 struct nfsd3_diropres *resp = rqstp->rq_resp; 264 __be32 nfserr; 265 266 dprintk("nfsd: MKDIR(3) %s %.*s\n", 267 SVCFH_fmt(&argp->fh), 268 argp->len, 269 argp->name); 270 271 argp->attrs.ia_valid &= ~ATTR_SIZE; 272 fh_copy(&resp->dirfh, &argp->fh); 273 fh_init(&resp->fh, NFS3_FHSIZE); 274 nfserr = nfsd_create(rqstp, &resp->dirfh, argp->name, argp->len, 275 &argp->attrs, S_IFDIR, 0, &resp->fh); 276 fh_unlock(&resp->dirfh); 277 RETURN_STATUS(nfserr); 278 } 279 280 static __be32 281 nfsd3_proc_symlink(struct svc_rqst *rqstp) 282 { 283 struct nfsd3_symlinkargs *argp = rqstp->rq_argp; 284 struct nfsd3_diropres *resp = rqstp->rq_resp; 285 __be32 nfserr; 286 287 if (argp->tlen == 0) 288 RETURN_STATUS(nfserr_inval); 289 if (argp->tlen > NFS3_MAXPATHLEN) 290 RETURN_STATUS(nfserr_nametoolong); 291 292 argp->tname = svc_fill_symlink_pathname(rqstp, &argp->first, 293 page_address(rqstp->rq_arg.pages[0]), 294 argp->tlen); 295 if (IS_ERR(argp->tname)) 296 RETURN_STATUS(nfserrno(PTR_ERR(argp->tname))); 297 298 dprintk("nfsd: SYMLINK(3) %s %.*s -> %.*s\n", 299 SVCFH_fmt(&argp->ffh), 300 argp->flen, argp->fname, 301 argp->tlen, argp->tname); 302 303 fh_copy(&resp->dirfh, &argp->ffh); 304 fh_init(&resp->fh, NFS3_FHSIZE); 305 nfserr = nfsd_symlink(rqstp, &resp->dirfh, argp->fname, argp->flen, 306 argp->tname, &resp->fh); 307 kfree(argp->tname); 308 RETURN_STATUS(nfserr); 309 } 310 311 /* 312 * Make socket/fifo/device. 313 */ 314 static __be32 315 nfsd3_proc_mknod(struct svc_rqst *rqstp) 316 { 317 struct nfsd3_mknodargs *argp = rqstp->rq_argp; 318 struct nfsd3_diropres *resp = rqstp->rq_resp; 319 __be32 nfserr; 320 int type; 321 dev_t rdev = 0; 322 323 dprintk("nfsd: MKNOD(3) %s %.*s\n", 324 SVCFH_fmt(&argp->fh), 325 argp->len, 326 argp->name); 327 328 fh_copy(&resp->dirfh, &argp->fh); 329 fh_init(&resp->fh, NFS3_FHSIZE); 330 331 if (argp->ftype == 0 || argp->ftype >= NF3BAD) 332 RETURN_STATUS(nfserr_inval); 333 if (argp->ftype == NF3CHR || argp->ftype == NF3BLK) { 334 rdev = MKDEV(argp->major, argp->minor); 335 if (MAJOR(rdev) != argp->major || 336 MINOR(rdev) != argp->minor) 337 RETURN_STATUS(nfserr_inval); 338 } else 339 if (argp->ftype != NF3SOCK && argp->ftype != NF3FIFO) 340 RETURN_STATUS(nfserr_inval); 341 342 type = nfs3_ftypes[argp->ftype]; 343 nfserr = nfsd_create(rqstp, &resp->dirfh, argp->name, argp->len, 344 &argp->attrs, type, rdev, &resp->fh); 345 fh_unlock(&resp->dirfh); 346 RETURN_STATUS(nfserr); 347 } 348 349 /* 350 * Remove file/fifo/socket etc. 351 */ 352 static __be32 353 nfsd3_proc_remove(struct svc_rqst *rqstp) 354 { 355 struct nfsd3_diropargs *argp = rqstp->rq_argp; 356 struct nfsd3_attrstat *resp = rqstp->rq_resp; 357 __be32 nfserr; 358 359 dprintk("nfsd: REMOVE(3) %s %.*s\n", 360 SVCFH_fmt(&argp->fh), 361 argp->len, 362 argp->name); 363 364 /* Unlink. -S_IFDIR means file must not be a directory */ 365 fh_copy(&resp->fh, &argp->fh); 366 nfserr = nfsd_unlink(rqstp, &resp->fh, -S_IFDIR, argp->name, argp->len); 367 fh_unlock(&resp->fh); 368 RETURN_STATUS(nfserr); 369 } 370 371 /* 372 * Remove a directory 373 */ 374 static __be32 375 nfsd3_proc_rmdir(struct svc_rqst *rqstp) 376 { 377 struct nfsd3_diropargs *argp = rqstp->rq_argp; 378 struct nfsd3_attrstat *resp = rqstp->rq_resp; 379 __be32 nfserr; 380 381 dprintk("nfsd: RMDIR(3) %s %.*s\n", 382 SVCFH_fmt(&argp->fh), 383 argp->len, 384 argp->name); 385 386 fh_copy(&resp->fh, &argp->fh); 387 nfserr = nfsd_unlink(rqstp, &resp->fh, S_IFDIR, argp->name, argp->len); 388 fh_unlock(&resp->fh); 389 RETURN_STATUS(nfserr); 390 } 391 392 static __be32 393 nfsd3_proc_rename(struct svc_rqst *rqstp) 394 { 395 struct nfsd3_renameargs *argp = rqstp->rq_argp; 396 struct nfsd3_renameres *resp = rqstp->rq_resp; 397 __be32 nfserr; 398 399 dprintk("nfsd: RENAME(3) %s %.*s ->\n", 400 SVCFH_fmt(&argp->ffh), 401 argp->flen, 402 argp->fname); 403 dprintk("nfsd: -> %s %.*s\n", 404 SVCFH_fmt(&argp->tfh), 405 argp->tlen, 406 argp->tname); 407 408 fh_copy(&resp->ffh, &argp->ffh); 409 fh_copy(&resp->tfh, &argp->tfh); 410 nfserr = nfsd_rename(rqstp, &resp->ffh, argp->fname, argp->flen, 411 &resp->tfh, argp->tname, argp->tlen); 412 RETURN_STATUS(nfserr); 413 } 414 415 static __be32 416 nfsd3_proc_link(struct svc_rqst *rqstp) 417 { 418 struct nfsd3_linkargs *argp = rqstp->rq_argp; 419 struct nfsd3_linkres *resp = rqstp->rq_resp; 420 __be32 nfserr; 421 422 dprintk("nfsd: LINK(3) %s ->\n", 423 SVCFH_fmt(&argp->ffh)); 424 dprintk("nfsd: -> %s %.*s\n", 425 SVCFH_fmt(&argp->tfh), 426 argp->tlen, 427 argp->tname); 428 429 fh_copy(&resp->fh, &argp->ffh); 430 fh_copy(&resp->tfh, &argp->tfh); 431 nfserr = nfsd_link(rqstp, &resp->tfh, argp->tname, argp->tlen, 432 &resp->fh); 433 RETURN_STATUS(nfserr); 434 } 435 436 /* 437 * Read a portion of a directory. 438 */ 439 static __be32 440 nfsd3_proc_readdir(struct svc_rqst *rqstp) 441 { 442 struct nfsd3_readdirargs *argp = rqstp->rq_argp; 443 struct nfsd3_readdirres *resp = rqstp->rq_resp; 444 __be32 nfserr; 445 int count = 0; 446 struct page **p; 447 caddr_t page_addr = NULL; 448 449 dprintk("nfsd: READDIR(3) %s %d bytes at %d\n", 450 SVCFH_fmt(&argp->fh), 451 argp->count, (u32) argp->cookie); 452 453 /* Make sure we've room for the NULL ptr & eof flag, and shrink to 454 * client read size */ 455 count = (argp->count >> 2) - 2; 456 457 /* Read directory and encode entries on the fly */ 458 fh_copy(&resp->fh, &argp->fh); 459 460 resp->buflen = count; 461 resp->common.err = nfs_ok; 462 resp->buffer = argp->buffer; 463 resp->rqstp = rqstp; 464 nfserr = nfsd_readdir(rqstp, &resp->fh, (loff_t*) &argp->cookie, 465 &resp->common, nfs3svc_encode_entry); 466 memcpy(resp->verf, argp->verf, 8); 467 count = 0; 468 for (p = rqstp->rq_respages + 1; p < rqstp->rq_next_page; p++) { 469 page_addr = page_address(*p); 470 471 if (((caddr_t)resp->buffer >= page_addr) && 472 ((caddr_t)resp->buffer < page_addr + PAGE_SIZE)) { 473 count += (caddr_t)resp->buffer - page_addr; 474 break; 475 } 476 count += PAGE_SIZE; 477 } 478 resp->count = count >> 2; 479 if (resp->offset) { 480 loff_t offset = argp->cookie; 481 482 if (unlikely(resp->offset1)) { 483 /* we ended up with offset on a page boundary */ 484 *resp->offset = htonl(offset >> 32); 485 *resp->offset1 = htonl(offset & 0xffffffff); 486 resp->offset1 = NULL; 487 } else { 488 xdr_encode_hyper(resp->offset, offset); 489 } 490 resp->offset = NULL; 491 } 492 493 RETURN_STATUS(nfserr); 494 } 495 496 /* 497 * Read a portion of a directory, including file handles and attrs. 498 * For now, we choose to ignore the dircount parameter. 499 */ 500 static __be32 501 nfsd3_proc_readdirplus(struct svc_rqst *rqstp) 502 { 503 struct nfsd3_readdirargs *argp = rqstp->rq_argp; 504 struct nfsd3_readdirres *resp = rqstp->rq_resp; 505 __be32 nfserr; 506 int count = 0; 507 loff_t offset; 508 struct page **p; 509 caddr_t page_addr = NULL; 510 511 dprintk("nfsd: READDIR+(3) %s %d bytes at %d\n", 512 SVCFH_fmt(&argp->fh), 513 argp->count, (u32) argp->cookie); 514 515 /* Convert byte count to number of words (i.e. >> 2), 516 * and reserve room for the NULL ptr & eof flag (-2 words) */ 517 resp->count = (argp->count >> 2) - 2; 518 519 /* Read directory and encode entries on the fly */ 520 fh_copy(&resp->fh, &argp->fh); 521 522 resp->common.err = nfs_ok; 523 resp->buffer = argp->buffer; 524 resp->buflen = resp->count; 525 resp->rqstp = rqstp; 526 offset = argp->cookie; 527 528 nfserr = fh_verify(rqstp, &resp->fh, S_IFDIR, NFSD_MAY_NOP); 529 if (nfserr) 530 RETURN_STATUS(nfserr); 531 532 if (resp->fh.fh_export->ex_flags & NFSEXP_NOREADDIRPLUS) 533 RETURN_STATUS(nfserr_notsupp); 534 535 nfserr = nfsd_readdir(rqstp, &resp->fh, 536 &offset, 537 &resp->common, 538 nfs3svc_encode_entry_plus); 539 memcpy(resp->verf, argp->verf, 8); 540 for (p = rqstp->rq_respages + 1; p < rqstp->rq_next_page; p++) { 541 page_addr = page_address(*p); 542 543 if (((caddr_t)resp->buffer >= page_addr) && 544 ((caddr_t)resp->buffer < page_addr + PAGE_SIZE)) { 545 count += (caddr_t)resp->buffer - page_addr; 546 break; 547 } 548 count += PAGE_SIZE; 549 } 550 resp->count = count >> 2; 551 if (resp->offset) { 552 if (unlikely(resp->offset1)) { 553 /* we ended up with offset on a page boundary */ 554 *resp->offset = htonl(offset >> 32); 555 *resp->offset1 = htonl(offset & 0xffffffff); 556 resp->offset1 = NULL; 557 } else { 558 xdr_encode_hyper(resp->offset, offset); 559 } 560 resp->offset = NULL; 561 } 562 563 RETURN_STATUS(nfserr); 564 } 565 566 /* 567 * Get file system stats 568 */ 569 static __be32 570 nfsd3_proc_fsstat(struct svc_rqst *rqstp) 571 { 572 struct nfsd_fhandle *argp = rqstp->rq_argp; 573 struct nfsd3_fsstatres *resp = rqstp->rq_resp; 574 __be32 nfserr; 575 576 dprintk("nfsd: FSSTAT(3) %s\n", 577 SVCFH_fmt(&argp->fh)); 578 579 nfserr = nfsd_statfs(rqstp, &argp->fh, &resp->stats, 0); 580 fh_put(&argp->fh); 581 RETURN_STATUS(nfserr); 582 } 583 584 /* 585 * Get file system info 586 */ 587 static __be32 588 nfsd3_proc_fsinfo(struct svc_rqst *rqstp) 589 { 590 struct nfsd_fhandle *argp = rqstp->rq_argp; 591 struct nfsd3_fsinfores *resp = rqstp->rq_resp; 592 __be32 nfserr; 593 u32 max_blocksize = svc_max_payload(rqstp); 594 595 dprintk("nfsd: FSINFO(3) %s\n", 596 SVCFH_fmt(&argp->fh)); 597 598 resp->f_rtmax = max_blocksize; 599 resp->f_rtpref = max_blocksize; 600 resp->f_rtmult = PAGE_SIZE; 601 resp->f_wtmax = max_blocksize; 602 resp->f_wtpref = max_blocksize; 603 resp->f_wtmult = PAGE_SIZE; 604 resp->f_dtpref = max_blocksize; 605 resp->f_maxfilesize = ~(u32) 0; 606 resp->f_properties = NFS3_FSF_DEFAULT; 607 608 nfserr = fh_verify(rqstp, &argp->fh, 0, 609 NFSD_MAY_NOP | NFSD_MAY_BYPASS_GSS_ON_ROOT); 610 611 /* Check special features of the file system. May request 612 * different read/write sizes for file systems known to have 613 * problems with large blocks */ 614 if (nfserr == 0) { 615 struct super_block *sb = argp->fh.fh_dentry->d_sb; 616 617 /* Note that we don't care for remote fs's here */ 618 if (sb->s_magic == MSDOS_SUPER_MAGIC) { 619 resp->f_properties = NFS3_FSF_BILLYBOY; 620 } 621 resp->f_maxfilesize = sb->s_maxbytes; 622 } 623 624 fh_put(&argp->fh); 625 RETURN_STATUS(nfserr); 626 } 627 628 /* 629 * Get pathconf info for the specified file 630 */ 631 static __be32 632 nfsd3_proc_pathconf(struct svc_rqst *rqstp) 633 { 634 struct nfsd_fhandle *argp = rqstp->rq_argp; 635 struct nfsd3_pathconfres *resp = rqstp->rq_resp; 636 __be32 nfserr; 637 638 dprintk("nfsd: PATHCONF(3) %s\n", 639 SVCFH_fmt(&argp->fh)); 640 641 /* Set default pathconf */ 642 resp->p_link_max = 255; /* at least */ 643 resp->p_name_max = 255; /* at least */ 644 resp->p_no_trunc = 0; 645 resp->p_chown_restricted = 1; 646 resp->p_case_insensitive = 0; 647 resp->p_case_preserving = 1; 648 649 nfserr = fh_verify(rqstp, &argp->fh, 0, NFSD_MAY_NOP); 650 651 if (nfserr == 0) { 652 struct super_block *sb = argp->fh.fh_dentry->d_sb; 653 654 /* Note that we don't care for remote fs's here */ 655 switch (sb->s_magic) { 656 case EXT2_SUPER_MAGIC: 657 resp->p_link_max = EXT2_LINK_MAX; 658 resp->p_name_max = EXT2_NAME_LEN; 659 break; 660 case MSDOS_SUPER_MAGIC: 661 resp->p_case_insensitive = 1; 662 resp->p_case_preserving = 0; 663 break; 664 } 665 } 666 667 fh_put(&argp->fh); 668 RETURN_STATUS(nfserr); 669 } 670 671 672 /* 673 * Commit a file (range) to stable storage. 674 */ 675 static __be32 676 nfsd3_proc_commit(struct svc_rqst *rqstp) 677 { 678 struct nfsd3_commitargs *argp = rqstp->rq_argp; 679 struct nfsd3_commitres *resp = rqstp->rq_resp; 680 __be32 nfserr; 681 682 dprintk("nfsd: COMMIT(3) %s %u@%Lu\n", 683 SVCFH_fmt(&argp->fh), 684 argp->count, 685 (unsigned long long) argp->offset); 686 687 if (argp->offset > NFS_OFFSET_MAX) 688 RETURN_STATUS(nfserr_inval); 689 690 fh_copy(&resp->fh, &argp->fh); 691 nfserr = nfsd_commit(rqstp, &resp->fh, argp->offset, argp->count); 692 693 RETURN_STATUS(nfserr); 694 } 695 696 697 /* 698 * NFSv3 Server procedures. 699 * Only the results of non-idempotent operations are cached. 700 */ 701 #define nfs3svc_decode_fhandleargs nfs3svc_decode_fhandle 702 #define nfs3svc_encode_attrstatres nfs3svc_encode_attrstat 703 #define nfs3svc_encode_wccstatres nfs3svc_encode_wccstat 704 #define nfsd3_mkdirargs nfsd3_createargs 705 #define nfsd3_readdirplusargs nfsd3_readdirargs 706 #define nfsd3_fhandleargs nfsd_fhandle 707 #define nfsd3_fhandleres nfsd3_attrstat 708 #define nfsd3_attrstatres nfsd3_attrstat 709 #define nfsd3_wccstatres nfsd3_attrstat 710 #define nfsd3_createres nfsd3_diropres 711 #define nfsd3_voidres nfsd3_voidargs 712 struct nfsd3_voidargs { int dummy; }; 713 714 #define ST 1 /* status*/ 715 #define FH 17 /* filehandle with length */ 716 #define AT 21 /* attributes */ 717 #define pAT (1+AT) /* post attributes - conditional */ 718 #define WC (7+pAT) /* WCC attributes */ 719 720 static const struct svc_procedure nfsd_procedures3[22] = { 721 [NFS3PROC_NULL] = { 722 .pc_func = nfsd3_proc_null, 723 .pc_encode = nfs3svc_encode_voidres, 724 .pc_argsize = sizeof(struct nfsd3_voidargs), 725 .pc_ressize = sizeof(struct nfsd3_voidres), 726 .pc_cachetype = RC_NOCACHE, 727 .pc_xdrressize = ST, 728 }, 729 [NFS3PROC_GETATTR] = { 730 .pc_func = nfsd3_proc_getattr, 731 .pc_decode = nfs3svc_decode_fhandleargs, 732 .pc_encode = nfs3svc_encode_attrstatres, 733 .pc_release = nfs3svc_release_fhandle, 734 .pc_argsize = sizeof(struct nfsd3_fhandleargs), 735 .pc_ressize = sizeof(struct nfsd3_attrstatres), 736 .pc_cachetype = RC_NOCACHE, 737 .pc_xdrressize = ST+AT, 738 }, 739 [NFS3PROC_SETATTR] = { 740 .pc_func = nfsd3_proc_setattr, 741 .pc_decode = nfs3svc_decode_sattrargs, 742 .pc_encode = nfs3svc_encode_wccstatres, 743 .pc_release = nfs3svc_release_fhandle, 744 .pc_argsize = sizeof(struct nfsd3_sattrargs), 745 .pc_ressize = sizeof(struct nfsd3_wccstatres), 746 .pc_cachetype = RC_REPLBUFF, 747 .pc_xdrressize = ST+WC, 748 }, 749 [NFS3PROC_LOOKUP] = { 750 .pc_func = nfsd3_proc_lookup, 751 .pc_decode = nfs3svc_decode_diropargs, 752 .pc_encode = nfs3svc_encode_diropres, 753 .pc_release = nfs3svc_release_fhandle2, 754 .pc_argsize = sizeof(struct nfsd3_diropargs), 755 .pc_ressize = sizeof(struct nfsd3_diropres), 756 .pc_cachetype = RC_NOCACHE, 757 .pc_xdrressize = ST+FH+pAT+pAT, 758 }, 759 [NFS3PROC_ACCESS] = { 760 .pc_func = nfsd3_proc_access, 761 .pc_decode = nfs3svc_decode_accessargs, 762 .pc_encode = nfs3svc_encode_accessres, 763 .pc_release = nfs3svc_release_fhandle, 764 .pc_argsize = sizeof(struct nfsd3_accessargs), 765 .pc_ressize = sizeof(struct nfsd3_accessres), 766 .pc_cachetype = RC_NOCACHE, 767 .pc_xdrressize = ST+pAT+1, 768 }, 769 [NFS3PROC_READLINK] = { 770 .pc_func = nfsd3_proc_readlink, 771 .pc_decode = nfs3svc_decode_readlinkargs, 772 .pc_encode = nfs3svc_encode_readlinkres, 773 .pc_release = nfs3svc_release_fhandle, 774 .pc_argsize = sizeof(struct nfsd3_readlinkargs), 775 .pc_ressize = sizeof(struct nfsd3_readlinkres), 776 .pc_cachetype = RC_NOCACHE, 777 .pc_xdrressize = ST+pAT+1+NFS3_MAXPATHLEN/4, 778 }, 779 [NFS3PROC_READ] = { 780 .pc_func = nfsd3_proc_read, 781 .pc_decode = nfs3svc_decode_readargs, 782 .pc_encode = nfs3svc_encode_readres, 783 .pc_release = nfs3svc_release_fhandle, 784 .pc_argsize = sizeof(struct nfsd3_readargs), 785 .pc_ressize = sizeof(struct nfsd3_readres), 786 .pc_cachetype = RC_NOCACHE, 787 .pc_xdrressize = ST+pAT+4+NFSSVC_MAXBLKSIZE/4, 788 }, 789 [NFS3PROC_WRITE] = { 790 .pc_func = nfsd3_proc_write, 791 .pc_decode = nfs3svc_decode_writeargs, 792 .pc_encode = nfs3svc_encode_writeres, 793 .pc_release = nfs3svc_release_fhandle, 794 .pc_argsize = sizeof(struct nfsd3_writeargs), 795 .pc_ressize = sizeof(struct nfsd3_writeres), 796 .pc_cachetype = RC_REPLBUFF, 797 .pc_xdrressize = ST+WC+4, 798 }, 799 [NFS3PROC_CREATE] = { 800 .pc_func = nfsd3_proc_create, 801 .pc_decode = nfs3svc_decode_createargs, 802 .pc_encode = nfs3svc_encode_createres, 803 .pc_release = nfs3svc_release_fhandle2, 804 .pc_argsize = sizeof(struct nfsd3_createargs), 805 .pc_ressize = sizeof(struct nfsd3_createres), 806 .pc_cachetype = RC_REPLBUFF, 807 .pc_xdrressize = ST+(1+FH+pAT)+WC, 808 }, 809 [NFS3PROC_MKDIR] = { 810 .pc_func = nfsd3_proc_mkdir, 811 .pc_decode = nfs3svc_decode_mkdirargs, 812 .pc_encode = nfs3svc_encode_createres, 813 .pc_release = nfs3svc_release_fhandle2, 814 .pc_argsize = sizeof(struct nfsd3_mkdirargs), 815 .pc_ressize = sizeof(struct nfsd3_createres), 816 .pc_cachetype = RC_REPLBUFF, 817 .pc_xdrressize = ST+(1+FH+pAT)+WC, 818 }, 819 [NFS3PROC_SYMLINK] = { 820 .pc_func = nfsd3_proc_symlink, 821 .pc_decode = nfs3svc_decode_symlinkargs, 822 .pc_encode = nfs3svc_encode_createres, 823 .pc_release = nfs3svc_release_fhandle2, 824 .pc_argsize = sizeof(struct nfsd3_symlinkargs), 825 .pc_ressize = sizeof(struct nfsd3_createres), 826 .pc_cachetype = RC_REPLBUFF, 827 .pc_xdrressize = ST+(1+FH+pAT)+WC, 828 }, 829 [NFS3PROC_MKNOD] = { 830 .pc_func = nfsd3_proc_mknod, 831 .pc_decode = nfs3svc_decode_mknodargs, 832 .pc_encode = nfs3svc_encode_createres, 833 .pc_release = nfs3svc_release_fhandle2, 834 .pc_argsize = sizeof(struct nfsd3_mknodargs), 835 .pc_ressize = sizeof(struct nfsd3_createres), 836 .pc_cachetype = RC_REPLBUFF, 837 .pc_xdrressize = ST+(1+FH+pAT)+WC, 838 }, 839 [NFS3PROC_REMOVE] = { 840 .pc_func = nfsd3_proc_remove, 841 .pc_decode = nfs3svc_decode_diropargs, 842 .pc_encode = nfs3svc_encode_wccstatres, 843 .pc_release = nfs3svc_release_fhandle, 844 .pc_argsize = sizeof(struct nfsd3_diropargs), 845 .pc_ressize = sizeof(struct nfsd3_wccstatres), 846 .pc_cachetype = RC_REPLBUFF, 847 .pc_xdrressize = ST+WC, 848 }, 849 [NFS3PROC_RMDIR] = { 850 .pc_func = nfsd3_proc_rmdir, 851 .pc_decode = nfs3svc_decode_diropargs, 852 .pc_encode = nfs3svc_encode_wccstatres, 853 .pc_release = nfs3svc_release_fhandle, 854 .pc_argsize = sizeof(struct nfsd3_diropargs), 855 .pc_ressize = sizeof(struct nfsd3_wccstatres), 856 .pc_cachetype = RC_REPLBUFF, 857 .pc_xdrressize = ST+WC, 858 }, 859 [NFS3PROC_RENAME] = { 860 .pc_func = nfsd3_proc_rename, 861 .pc_decode = nfs3svc_decode_renameargs, 862 .pc_encode = nfs3svc_encode_renameres, 863 .pc_release = nfs3svc_release_fhandle2, 864 .pc_argsize = sizeof(struct nfsd3_renameargs), 865 .pc_ressize = sizeof(struct nfsd3_renameres), 866 .pc_cachetype = RC_REPLBUFF, 867 .pc_xdrressize = ST+WC+WC, 868 }, 869 [NFS3PROC_LINK] = { 870 .pc_func = nfsd3_proc_link, 871 .pc_decode = nfs3svc_decode_linkargs, 872 .pc_encode = nfs3svc_encode_linkres, 873 .pc_release = nfs3svc_release_fhandle2, 874 .pc_argsize = sizeof(struct nfsd3_linkargs), 875 .pc_ressize = sizeof(struct nfsd3_linkres), 876 .pc_cachetype = RC_REPLBUFF, 877 .pc_xdrressize = ST+pAT+WC, 878 }, 879 [NFS3PROC_READDIR] = { 880 .pc_func = nfsd3_proc_readdir, 881 .pc_decode = nfs3svc_decode_readdirargs, 882 .pc_encode = nfs3svc_encode_readdirres, 883 .pc_release = nfs3svc_release_fhandle, 884 .pc_argsize = sizeof(struct nfsd3_readdirargs), 885 .pc_ressize = sizeof(struct nfsd3_readdirres), 886 .pc_cachetype = RC_NOCACHE, 887 }, 888 [NFS3PROC_READDIRPLUS] = { 889 .pc_func = nfsd3_proc_readdirplus, 890 .pc_decode = nfs3svc_decode_readdirplusargs, 891 .pc_encode = nfs3svc_encode_readdirres, 892 .pc_release = nfs3svc_release_fhandle, 893 .pc_argsize = sizeof(struct nfsd3_readdirplusargs), 894 .pc_ressize = sizeof(struct nfsd3_readdirres), 895 .pc_cachetype = RC_NOCACHE, 896 }, 897 [NFS3PROC_FSSTAT] = { 898 .pc_func = nfsd3_proc_fsstat, 899 .pc_decode = nfs3svc_decode_fhandleargs, 900 .pc_encode = nfs3svc_encode_fsstatres, 901 .pc_argsize = sizeof(struct nfsd3_fhandleargs), 902 .pc_ressize = sizeof(struct nfsd3_fsstatres), 903 .pc_cachetype = RC_NOCACHE, 904 .pc_xdrressize = ST+pAT+2*6+1, 905 }, 906 [NFS3PROC_FSINFO] = { 907 .pc_func = nfsd3_proc_fsinfo, 908 .pc_decode = nfs3svc_decode_fhandleargs, 909 .pc_encode = nfs3svc_encode_fsinfores, 910 .pc_argsize = sizeof(struct nfsd3_fhandleargs), 911 .pc_ressize = sizeof(struct nfsd3_fsinfores), 912 .pc_cachetype = RC_NOCACHE, 913 .pc_xdrressize = ST+pAT+12, 914 }, 915 [NFS3PROC_PATHCONF] = { 916 .pc_func = nfsd3_proc_pathconf, 917 .pc_decode = nfs3svc_decode_fhandleargs, 918 .pc_encode = nfs3svc_encode_pathconfres, 919 .pc_argsize = sizeof(struct nfsd3_fhandleargs), 920 .pc_ressize = sizeof(struct nfsd3_pathconfres), 921 .pc_cachetype = RC_NOCACHE, 922 .pc_xdrressize = ST+pAT+6, 923 }, 924 [NFS3PROC_COMMIT] = { 925 .pc_func = nfsd3_proc_commit, 926 .pc_decode = nfs3svc_decode_commitargs, 927 .pc_encode = nfs3svc_encode_commitres, 928 .pc_release = nfs3svc_release_fhandle, 929 .pc_argsize = sizeof(struct nfsd3_commitargs), 930 .pc_ressize = sizeof(struct nfsd3_commitres), 931 .pc_cachetype = RC_NOCACHE, 932 .pc_xdrressize = ST+WC+2, 933 }, 934 }; 935 936 static unsigned int nfsd_count3[ARRAY_SIZE(nfsd_procedures3)]; 937 const struct svc_version nfsd_version3 = { 938 .vs_vers = 3, 939 .vs_nproc = 22, 940 .vs_proc = nfsd_procedures3, 941 .vs_dispatch = nfsd_dispatch, 942 .vs_count = nfsd_count3, 943 .vs_xdrsize = NFS3_SVC_XDRSIZE, 944 }; 945