1 /* 2 * linux/fs/nfs/nfs3xdr.c 3 * 4 * XDR functions to encode/decode NFSv3 RPC arguments and results. 5 * 6 * Copyright (C) 1996, 1997 Olaf Kirch 7 */ 8 9 #include <linux/param.h> 10 #include <linux/time.h> 11 #include <linux/mm.h> 12 #include <linux/slab.h> 13 #include <linux/utsname.h> 14 #include <linux/errno.h> 15 #include <linux/string.h> 16 #include <linux/in.h> 17 #include <linux/pagemap.h> 18 #include <linux/proc_fs.h> 19 #include <linux/kdev_t.h> 20 #include <linux/sunrpc/clnt.h> 21 #include <linux/nfs.h> 22 #include <linux/nfs3.h> 23 #include <linux/nfs_fs.h> 24 #include <linux/nfsacl.h> 25 #include "internal.h" 26 27 #define NFSDBG_FACILITY NFSDBG_XDR 28 29 /* Mapping from NFS error code to "errno" error code. */ 30 #define errno_NFSERR_IO EIO 31 32 /* 33 * Declare the space requirements for NFS arguments and replies as 34 * number of 32bit-words 35 */ 36 #define NFS3_fhandle_sz (1+16) 37 #define NFS3_fh_sz (NFS3_fhandle_sz) /* shorthand */ 38 #define NFS3_sattr_sz (15) 39 #define NFS3_filename_sz (1+(NFS3_MAXNAMLEN>>2)) 40 #define NFS3_path_sz (1+(NFS3_MAXPATHLEN>>2)) 41 #define NFS3_fattr_sz (21) 42 #define NFS3_wcc_attr_sz (6) 43 #define NFS3_pre_op_attr_sz (1+NFS3_wcc_attr_sz) 44 #define NFS3_post_op_attr_sz (1+NFS3_fattr_sz) 45 #define NFS3_wcc_data_sz (NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz) 46 #define NFS3_fsstat_sz 47 #define NFS3_fsinfo_sz 48 #define NFS3_pathconf_sz 49 #define NFS3_entry_sz (NFS3_filename_sz+3) 50 51 #define NFS3_sattrargs_sz (NFS3_fh_sz+NFS3_sattr_sz+3) 52 #define NFS3_diropargs_sz (NFS3_fh_sz+NFS3_filename_sz) 53 #define NFS3_removeargs_sz (NFS3_fh_sz+NFS3_filename_sz) 54 #define NFS3_accessargs_sz (NFS3_fh_sz+1) 55 #define NFS3_readlinkargs_sz (NFS3_fh_sz) 56 #define NFS3_readargs_sz (NFS3_fh_sz+3) 57 #define NFS3_writeargs_sz (NFS3_fh_sz+5) 58 #define NFS3_createargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz) 59 #define NFS3_mkdirargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz) 60 #define NFS3_symlinkargs_sz (NFS3_diropargs_sz+1+NFS3_sattr_sz) 61 #define NFS3_mknodargs_sz (NFS3_diropargs_sz+2+NFS3_sattr_sz) 62 #define NFS3_renameargs_sz (NFS3_diropargs_sz+NFS3_diropargs_sz) 63 #define NFS3_linkargs_sz (NFS3_fh_sz+NFS3_diropargs_sz) 64 #define NFS3_readdirargs_sz (NFS3_fh_sz+2) 65 #define NFS3_commitargs_sz (NFS3_fh_sz+3) 66 67 #define NFS3_attrstat_sz (1+NFS3_fattr_sz) 68 #define NFS3_wccstat_sz (1+NFS3_wcc_data_sz) 69 #define NFS3_removeres_sz (NFS3_wccstat_sz) 70 #define NFS3_lookupres_sz (1+NFS3_fh_sz+(2 * NFS3_post_op_attr_sz)) 71 #define NFS3_accessres_sz (1+NFS3_post_op_attr_sz+1) 72 #define NFS3_readlinkres_sz (1+NFS3_post_op_attr_sz+1) 73 #define NFS3_readres_sz (1+NFS3_post_op_attr_sz+3) 74 #define NFS3_writeres_sz (1+NFS3_wcc_data_sz+4) 75 #define NFS3_createres_sz (1+NFS3_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz) 76 #define NFS3_renameres_sz (1+(2 * NFS3_wcc_data_sz)) 77 #define NFS3_linkres_sz (1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz) 78 #define NFS3_readdirres_sz (1+NFS3_post_op_attr_sz+2) 79 #define NFS3_fsstatres_sz (1+NFS3_post_op_attr_sz+13) 80 #define NFS3_fsinfores_sz (1+NFS3_post_op_attr_sz+12) 81 #define NFS3_pathconfres_sz (1+NFS3_post_op_attr_sz+6) 82 #define NFS3_commitres_sz (1+NFS3_wcc_data_sz+2) 83 84 #define ACL3_getaclargs_sz (NFS3_fh_sz+1) 85 #define ACL3_setaclargs_sz (NFS3_fh_sz+1+2*(2+5*3)) 86 #define ACL3_getaclres_sz (1+NFS3_post_op_attr_sz+1+2*(2+5*3)) 87 #define ACL3_setaclres_sz (1+NFS3_post_op_attr_sz) 88 89 /* 90 * Map file type to S_IFMT bits 91 */ 92 static struct { 93 unsigned int mode; 94 unsigned int nfs2type; 95 } nfs_type2fmt[] = { 96 { 0, NFNON }, 97 { S_IFREG, NFREG }, 98 { S_IFDIR, NFDIR }, 99 { S_IFBLK, NFBLK }, 100 { S_IFCHR, NFCHR }, 101 { S_IFLNK, NFLNK }, 102 { S_IFSOCK, NFSOCK }, 103 { S_IFIFO, NFFIFO }, 104 { 0, NFBAD } 105 }; 106 107 /* 108 * Common NFS XDR functions as inlines 109 */ 110 static inline __be32 * 111 xdr_encode_fhandle(__be32 *p, const struct nfs_fh *fh) 112 { 113 return xdr_encode_array(p, fh->data, fh->size); 114 } 115 116 static inline __be32 * 117 xdr_decode_fhandle(__be32 *p, struct nfs_fh *fh) 118 { 119 if ((fh->size = ntohl(*p++)) <= NFS3_FHSIZE) { 120 memcpy(fh->data, p, fh->size); 121 return p + XDR_QUADLEN(fh->size); 122 } 123 return NULL; 124 } 125 126 /* 127 * Encode/decode time. 128 */ 129 static inline __be32 * 130 xdr_encode_time3(__be32 *p, struct timespec *timep) 131 { 132 *p++ = htonl(timep->tv_sec); 133 *p++ = htonl(timep->tv_nsec); 134 return p; 135 } 136 137 static inline __be32 * 138 xdr_decode_time3(__be32 *p, struct timespec *timep) 139 { 140 timep->tv_sec = ntohl(*p++); 141 timep->tv_nsec = ntohl(*p++); 142 return p; 143 } 144 145 static __be32 * 146 xdr_decode_fattr(__be32 *p, struct nfs_fattr *fattr) 147 { 148 unsigned int type, major, minor; 149 int fmode; 150 151 type = ntohl(*p++); 152 if (type >= NF3BAD) 153 type = NF3BAD; 154 fmode = nfs_type2fmt[type].mode; 155 fattr->type = nfs_type2fmt[type].nfs2type; 156 fattr->mode = (ntohl(*p++) & ~S_IFMT) | fmode; 157 fattr->nlink = ntohl(*p++); 158 fattr->uid = ntohl(*p++); 159 fattr->gid = ntohl(*p++); 160 p = xdr_decode_hyper(p, &fattr->size); 161 p = xdr_decode_hyper(p, &fattr->du.nfs3.used); 162 163 /* Turn remote device info into Linux-specific dev_t */ 164 major = ntohl(*p++); 165 minor = ntohl(*p++); 166 fattr->rdev = MKDEV(major, minor); 167 if (MAJOR(fattr->rdev) != major || MINOR(fattr->rdev) != minor) 168 fattr->rdev = 0; 169 170 p = xdr_decode_hyper(p, &fattr->fsid.major); 171 fattr->fsid.minor = 0; 172 p = xdr_decode_hyper(p, &fattr->fileid); 173 p = xdr_decode_time3(p, &fattr->atime); 174 p = xdr_decode_time3(p, &fattr->mtime); 175 p = xdr_decode_time3(p, &fattr->ctime); 176 177 /* Update the mode bits */ 178 fattr->valid |= (NFS_ATTR_FATTR | NFS_ATTR_FATTR_V3); 179 return p; 180 } 181 182 static inline __be32 * 183 xdr_encode_sattr(__be32 *p, struct iattr *attr) 184 { 185 if (attr->ia_valid & ATTR_MODE) { 186 *p++ = xdr_one; 187 *p++ = htonl(attr->ia_mode & S_IALLUGO); 188 } else { 189 *p++ = xdr_zero; 190 } 191 if (attr->ia_valid & ATTR_UID) { 192 *p++ = xdr_one; 193 *p++ = htonl(attr->ia_uid); 194 } else { 195 *p++ = xdr_zero; 196 } 197 if (attr->ia_valid & ATTR_GID) { 198 *p++ = xdr_one; 199 *p++ = htonl(attr->ia_gid); 200 } else { 201 *p++ = xdr_zero; 202 } 203 if (attr->ia_valid & ATTR_SIZE) { 204 *p++ = xdr_one; 205 p = xdr_encode_hyper(p, (__u64) attr->ia_size); 206 } else { 207 *p++ = xdr_zero; 208 } 209 if (attr->ia_valid & ATTR_ATIME_SET) { 210 *p++ = xdr_two; 211 p = xdr_encode_time3(p, &attr->ia_atime); 212 } else if (attr->ia_valid & ATTR_ATIME) { 213 *p++ = xdr_one; 214 } else { 215 *p++ = xdr_zero; 216 } 217 if (attr->ia_valid & ATTR_MTIME_SET) { 218 *p++ = xdr_two; 219 p = xdr_encode_time3(p, &attr->ia_mtime); 220 } else if (attr->ia_valid & ATTR_MTIME) { 221 *p++ = xdr_one; 222 } else { 223 *p++ = xdr_zero; 224 } 225 return p; 226 } 227 228 static inline __be32 * 229 xdr_decode_wcc_attr(__be32 *p, struct nfs_fattr *fattr) 230 { 231 p = xdr_decode_hyper(p, &fattr->pre_size); 232 p = xdr_decode_time3(p, &fattr->pre_mtime); 233 p = xdr_decode_time3(p, &fattr->pre_ctime); 234 fattr->valid |= NFS_ATTR_WCC; 235 return p; 236 } 237 238 static inline __be32 * 239 xdr_decode_post_op_attr(__be32 *p, struct nfs_fattr *fattr) 240 { 241 if (*p++) 242 p = xdr_decode_fattr(p, fattr); 243 return p; 244 } 245 246 static inline __be32 * 247 xdr_decode_pre_op_attr(__be32 *p, struct nfs_fattr *fattr) 248 { 249 if (*p++) 250 return xdr_decode_wcc_attr(p, fattr); 251 return p; 252 } 253 254 255 static inline __be32 * 256 xdr_decode_wcc_data(__be32 *p, struct nfs_fattr *fattr) 257 { 258 p = xdr_decode_pre_op_attr(p, fattr); 259 return xdr_decode_post_op_attr(p, fattr); 260 } 261 262 /* 263 * NFS encode functions 264 */ 265 266 /* 267 * Encode file handle argument 268 */ 269 static int 270 nfs3_xdr_fhandle(struct rpc_rqst *req, __be32 *p, struct nfs_fh *fh) 271 { 272 p = xdr_encode_fhandle(p, fh); 273 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 274 return 0; 275 } 276 277 /* 278 * Encode SETATTR arguments 279 */ 280 static int 281 nfs3_xdr_sattrargs(struct rpc_rqst *req, __be32 *p, struct nfs3_sattrargs *args) 282 { 283 p = xdr_encode_fhandle(p, args->fh); 284 p = xdr_encode_sattr(p, args->sattr); 285 *p++ = htonl(args->guard); 286 if (args->guard) 287 p = xdr_encode_time3(p, &args->guardtime); 288 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 289 return 0; 290 } 291 292 /* 293 * Encode directory ops argument 294 */ 295 static int 296 nfs3_xdr_diropargs(struct rpc_rqst *req, __be32 *p, struct nfs3_diropargs *args) 297 { 298 p = xdr_encode_fhandle(p, args->fh); 299 p = xdr_encode_array(p, args->name, args->len); 300 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 301 return 0; 302 } 303 304 /* 305 * Encode REMOVE argument 306 */ 307 static int 308 nfs3_xdr_removeargs(struct rpc_rqst *req, __be32 *p, const struct nfs_removeargs *args) 309 { 310 p = xdr_encode_fhandle(p, args->fh); 311 p = xdr_encode_array(p, args->name.name, args->name.len); 312 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 313 return 0; 314 } 315 316 /* 317 * Encode access() argument 318 */ 319 static int 320 nfs3_xdr_accessargs(struct rpc_rqst *req, __be32 *p, struct nfs3_accessargs *args) 321 { 322 p = xdr_encode_fhandle(p, args->fh); 323 *p++ = htonl(args->access); 324 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 325 return 0; 326 } 327 328 /* 329 * Arguments to a READ call. Since we read data directly into the page 330 * cache, we also set up the reply iovec here so that iov[1] points 331 * exactly to the page we want to fetch. 332 */ 333 static int 334 nfs3_xdr_readargs(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args) 335 { 336 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth; 337 unsigned int replen; 338 u32 count = args->count; 339 340 p = xdr_encode_fhandle(p, args->fh); 341 p = xdr_encode_hyper(p, args->offset); 342 *p++ = htonl(count); 343 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 344 345 /* Inline the page array */ 346 replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readres_sz) << 2; 347 xdr_inline_pages(&req->rq_rcv_buf, replen, 348 args->pages, args->pgbase, count); 349 req->rq_rcv_buf.flags |= XDRBUF_READ; 350 return 0; 351 } 352 353 /* 354 * Write arguments. Splice the buffer to be written into the iovec. 355 */ 356 static int 357 nfs3_xdr_writeargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args) 358 { 359 struct xdr_buf *sndbuf = &req->rq_snd_buf; 360 u32 count = args->count; 361 362 p = xdr_encode_fhandle(p, args->fh); 363 p = xdr_encode_hyper(p, args->offset); 364 *p++ = htonl(count); 365 *p++ = htonl(args->stable); 366 *p++ = htonl(count); 367 sndbuf->len = xdr_adjust_iovec(sndbuf->head, p); 368 369 /* Copy the page array */ 370 xdr_encode_pages(sndbuf, args->pages, args->pgbase, count); 371 sndbuf->flags |= XDRBUF_WRITE; 372 return 0; 373 } 374 375 /* 376 * Encode CREATE arguments 377 */ 378 static int 379 nfs3_xdr_createargs(struct rpc_rqst *req, __be32 *p, struct nfs3_createargs *args) 380 { 381 p = xdr_encode_fhandle(p, args->fh); 382 p = xdr_encode_array(p, args->name, args->len); 383 384 *p++ = htonl(args->createmode); 385 if (args->createmode == NFS3_CREATE_EXCLUSIVE) { 386 *p++ = args->verifier[0]; 387 *p++ = args->verifier[1]; 388 } else 389 p = xdr_encode_sattr(p, args->sattr); 390 391 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 392 return 0; 393 } 394 395 /* 396 * Encode MKDIR arguments 397 */ 398 static int 399 nfs3_xdr_mkdirargs(struct rpc_rqst *req, __be32 *p, struct nfs3_mkdirargs *args) 400 { 401 p = xdr_encode_fhandle(p, args->fh); 402 p = xdr_encode_array(p, args->name, args->len); 403 p = xdr_encode_sattr(p, args->sattr); 404 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 405 return 0; 406 } 407 408 /* 409 * Encode SYMLINK arguments 410 */ 411 static int 412 nfs3_xdr_symlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_symlinkargs *args) 413 { 414 p = xdr_encode_fhandle(p, args->fromfh); 415 p = xdr_encode_array(p, args->fromname, args->fromlen); 416 p = xdr_encode_sattr(p, args->sattr); 417 *p++ = htonl(args->pathlen); 418 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 419 420 /* Copy the page */ 421 xdr_encode_pages(&req->rq_snd_buf, args->pages, 0, args->pathlen); 422 return 0; 423 } 424 425 /* 426 * Encode MKNOD arguments 427 */ 428 static int 429 nfs3_xdr_mknodargs(struct rpc_rqst *req, __be32 *p, struct nfs3_mknodargs *args) 430 { 431 p = xdr_encode_fhandle(p, args->fh); 432 p = xdr_encode_array(p, args->name, args->len); 433 *p++ = htonl(args->type); 434 p = xdr_encode_sattr(p, args->sattr); 435 if (args->type == NF3CHR || args->type == NF3BLK) { 436 *p++ = htonl(MAJOR(args->rdev)); 437 *p++ = htonl(MINOR(args->rdev)); 438 } 439 440 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 441 return 0; 442 } 443 444 /* 445 * Encode RENAME arguments 446 */ 447 static int 448 nfs3_xdr_renameargs(struct rpc_rqst *req, __be32 *p, struct nfs3_renameargs *args) 449 { 450 p = xdr_encode_fhandle(p, args->fromfh); 451 p = xdr_encode_array(p, args->fromname, args->fromlen); 452 p = xdr_encode_fhandle(p, args->tofh); 453 p = xdr_encode_array(p, args->toname, args->tolen); 454 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 455 return 0; 456 } 457 458 /* 459 * Encode LINK arguments 460 */ 461 static int 462 nfs3_xdr_linkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_linkargs *args) 463 { 464 p = xdr_encode_fhandle(p, args->fromfh); 465 p = xdr_encode_fhandle(p, args->tofh); 466 p = xdr_encode_array(p, args->toname, args->tolen); 467 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 468 return 0; 469 } 470 471 /* 472 * Encode arguments to readdir call 473 */ 474 static int 475 nfs3_xdr_readdirargs(struct rpc_rqst *req, __be32 *p, struct nfs3_readdirargs *args) 476 { 477 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth; 478 unsigned int replen; 479 u32 count = args->count; 480 481 p = xdr_encode_fhandle(p, args->fh); 482 p = xdr_encode_hyper(p, args->cookie); 483 *p++ = args->verf[0]; 484 *p++ = args->verf[1]; 485 if (args->plus) { 486 /* readdirplus: need dircount + buffer size. 487 * We just make sure we make dircount big enough */ 488 *p++ = htonl(count >> 3); 489 } 490 *p++ = htonl(count); 491 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 492 493 /* Inline the page array */ 494 replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readdirres_sz) << 2; 495 xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, count); 496 return 0; 497 } 498 499 /* 500 * Decode the result of a readdir call. 501 * We just check for syntactical correctness. 502 */ 503 static int 504 nfs3_xdr_readdirres(struct rpc_rqst *req, __be32 *p, struct nfs3_readdirres *res) 505 { 506 struct xdr_buf *rcvbuf = &req->rq_rcv_buf; 507 struct kvec *iov = rcvbuf->head; 508 struct page **page; 509 int hdrlen, recvd; 510 int status, nr; 511 unsigned int len, pglen; 512 __be32 *entry, *end, *kaddr; 513 514 status = ntohl(*p++); 515 /* Decode post_op_attrs */ 516 p = xdr_decode_post_op_attr(p, res->dir_attr); 517 if (status) 518 return -nfs_stat_to_errno(status); 519 /* Decode verifier cookie */ 520 if (res->verf) { 521 res->verf[0] = *p++; 522 res->verf[1] = *p++; 523 } else { 524 p += 2; 525 } 526 527 hdrlen = (u8 *) p - (u8 *) iov->iov_base; 528 if (iov->iov_len < hdrlen) { 529 dprintk("NFS: READDIR reply header overflowed:" 530 "length %d > %Zu\n", hdrlen, iov->iov_len); 531 return -errno_NFSERR_IO; 532 } else if (iov->iov_len != hdrlen) { 533 dprintk("NFS: READDIR header is short. iovec will be shifted.\n"); 534 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen); 535 } 536 537 pglen = rcvbuf->page_len; 538 recvd = rcvbuf->len - hdrlen; 539 if (pglen > recvd) 540 pglen = recvd; 541 page = rcvbuf->pages; 542 kaddr = p = kmap_atomic(*page, KM_USER0); 543 end = (__be32 *)((char *)p + pglen); 544 entry = p; 545 for (nr = 0; *p++; nr++) { 546 if (p + 3 > end) 547 goto short_pkt; 548 p += 2; /* inode # */ 549 len = ntohl(*p++); /* string length */ 550 p += XDR_QUADLEN(len) + 2; /* name + cookie */ 551 if (len > NFS3_MAXNAMLEN) { 552 dprintk("NFS: giant filename in readdir (len %x)!\n", 553 len); 554 goto err_unmap; 555 } 556 557 if (res->plus) { 558 /* post_op_attr */ 559 if (p + 2 > end) 560 goto short_pkt; 561 if (*p++) { 562 p += 21; 563 if (p + 1 > end) 564 goto short_pkt; 565 } 566 /* post_op_fh3 */ 567 if (*p++) { 568 if (p + 1 > end) 569 goto short_pkt; 570 len = ntohl(*p++); 571 if (len > NFS3_FHSIZE) { 572 dprintk("NFS: giant filehandle in " 573 "readdir (len %x)!\n", len); 574 goto err_unmap; 575 } 576 p += XDR_QUADLEN(len); 577 } 578 } 579 580 if (p + 2 > end) 581 goto short_pkt; 582 entry = p; 583 } 584 if (!nr && (entry[0] != 0 || entry[1] == 0)) 585 goto short_pkt; 586 out: 587 kunmap_atomic(kaddr, KM_USER0); 588 return nr; 589 short_pkt: 590 entry[0] = entry[1] = 0; 591 /* truncate listing ? */ 592 if (!nr) { 593 dprintk("NFS: readdir reply truncated!\n"); 594 entry[1] = 1; 595 } 596 goto out; 597 err_unmap: 598 nr = -errno_NFSERR_IO; 599 goto out; 600 } 601 602 __be32 * 603 nfs3_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus) 604 { 605 struct nfs_entry old = *entry; 606 607 if (!*p++) { 608 if (!*p) 609 return ERR_PTR(-EAGAIN); 610 entry->eof = 1; 611 return ERR_PTR(-EBADCOOKIE); 612 } 613 614 p = xdr_decode_hyper(p, &entry->ino); 615 entry->len = ntohl(*p++); 616 entry->name = (const char *) p; 617 p += XDR_QUADLEN(entry->len); 618 entry->prev_cookie = entry->cookie; 619 p = xdr_decode_hyper(p, &entry->cookie); 620 621 if (plus) { 622 entry->fattr->valid = 0; 623 p = xdr_decode_post_op_attr(p, entry->fattr); 624 /* In fact, a post_op_fh3: */ 625 if (*p++) { 626 p = xdr_decode_fhandle(p, entry->fh); 627 /* Ugh -- server reply was truncated */ 628 if (p == NULL) { 629 dprintk("NFS: FH truncated\n"); 630 *entry = old; 631 return ERR_PTR(-EAGAIN); 632 } 633 } else 634 memset((u8*)(entry->fh), 0, sizeof(*entry->fh)); 635 } 636 637 entry->eof = !p[0] && p[1]; 638 return p; 639 } 640 641 /* 642 * Encode COMMIT arguments 643 */ 644 static int 645 nfs3_xdr_commitargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args) 646 { 647 p = xdr_encode_fhandle(p, args->fh); 648 p = xdr_encode_hyper(p, args->offset); 649 *p++ = htonl(args->count); 650 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 651 return 0; 652 } 653 654 #ifdef CONFIG_NFS_V3_ACL 655 /* 656 * Encode GETACL arguments 657 */ 658 static int 659 nfs3_xdr_getaclargs(struct rpc_rqst *req, __be32 *p, 660 struct nfs3_getaclargs *args) 661 { 662 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth; 663 unsigned int replen; 664 665 p = xdr_encode_fhandle(p, args->fh); 666 *p++ = htonl(args->mask); 667 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 668 669 if (args->mask & (NFS_ACL | NFS_DFACL)) { 670 /* Inline the page array */ 671 replen = (RPC_REPHDRSIZE + auth->au_rslack + 672 ACL3_getaclres_sz) << 2; 673 xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, 674 NFSACL_MAXPAGES << PAGE_SHIFT); 675 } 676 return 0; 677 } 678 679 /* 680 * Encode SETACL arguments 681 */ 682 static int 683 nfs3_xdr_setaclargs(struct rpc_rqst *req, __be32 *p, 684 struct nfs3_setaclargs *args) 685 { 686 struct xdr_buf *buf = &req->rq_snd_buf; 687 unsigned int base, len_in_head, len = nfsacl_size( 688 (args->mask & NFS_ACL) ? args->acl_access : NULL, 689 (args->mask & NFS_DFACL) ? args->acl_default : NULL); 690 int count, err; 691 692 p = xdr_encode_fhandle(p, NFS_FH(args->inode)); 693 *p++ = htonl(args->mask); 694 base = (char *)p - (char *)buf->head->iov_base; 695 /* put as much of the acls into head as possible. */ 696 len_in_head = min_t(unsigned int, buf->head->iov_len - base, len); 697 len -= len_in_head; 698 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p + (len_in_head >> 2)); 699 700 for (count = 0; (count << PAGE_SHIFT) < len; count++) { 701 args->pages[count] = alloc_page(GFP_KERNEL); 702 if (!args->pages[count]) { 703 while (count) 704 __free_page(args->pages[--count]); 705 return -ENOMEM; 706 } 707 } 708 xdr_encode_pages(buf, args->pages, 0, len); 709 710 err = nfsacl_encode(buf, base, args->inode, 711 (args->mask & NFS_ACL) ? 712 args->acl_access : NULL, 1, 0); 713 if (err > 0) 714 err = nfsacl_encode(buf, base + err, args->inode, 715 (args->mask & NFS_DFACL) ? 716 args->acl_default : NULL, 1, 717 NFS_ACL_DEFAULT); 718 return (err > 0) ? 0 : err; 719 } 720 #endif /* CONFIG_NFS_V3_ACL */ 721 722 /* 723 * NFS XDR decode functions 724 */ 725 726 /* 727 * Decode attrstat reply. 728 */ 729 static int 730 nfs3_xdr_attrstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr) 731 { 732 int status; 733 734 if ((status = ntohl(*p++))) 735 return -nfs_stat_to_errno(status); 736 xdr_decode_fattr(p, fattr); 737 return 0; 738 } 739 740 /* 741 * Decode status+wcc_data reply 742 * SATTR, REMOVE, RMDIR 743 */ 744 static int 745 nfs3_xdr_wccstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr) 746 { 747 int status; 748 749 if ((status = ntohl(*p++))) 750 status = -nfs_stat_to_errno(status); 751 xdr_decode_wcc_data(p, fattr); 752 return status; 753 } 754 755 static int 756 nfs3_xdr_removeres(struct rpc_rqst *req, __be32 *p, struct nfs_removeres *res) 757 { 758 return nfs3_xdr_wccstat(req, p, &res->dir_attr); 759 } 760 761 /* 762 * Decode LOOKUP reply 763 */ 764 static int 765 nfs3_xdr_lookupres(struct rpc_rqst *req, __be32 *p, struct nfs3_diropres *res) 766 { 767 int status; 768 769 if ((status = ntohl(*p++))) { 770 status = -nfs_stat_to_errno(status); 771 } else { 772 if (!(p = xdr_decode_fhandle(p, res->fh))) 773 return -errno_NFSERR_IO; 774 p = xdr_decode_post_op_attr(p, res->fattr); 775 } 776 xdr_decode_post_op_attr(p, res->dir_attr); 777 return status; 778 } 779 780 /* 781 * Decode ACCESS reply 782 */ 783 static int 784 nfs3_xdr_accessres(struct rpc_rqst *req, __be32 *p, struct nfs3_accessres *res) 785 { 786 int status = ntohl(*p++); 787 788 p = xdr_decode_post_op_attr(p, res->fattr); 789 if (status) 790 return -nfs_stat_to_errno(status); 791 res->access = ntohl(*p++); 792 return 0; 793 } 794 795 static int 796 nfs3_xdr_readlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_readlinkargs *args) 797 { 798 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth; 799 unsigned int replen; 800 801 p = xdr_encode_fhandle(p, args->fh); 802 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 803 804 /* Inline the page array */ 805 replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readlinkres_sz) << 2; 806 xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, args->pglen); 807 return 0; 808 } 809 810 /* 811 * Decode READLINK reply 812 */ 813 static int 814 nfs3_xdr_readlinkres(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr) 815 { 816 struct xdr_buf *rcvbuf = &req->rq_rcv_buf; 817 struct kvec *iov = rcvbuf->head; 818 int hdrlen, len, recvd; 819 char *kaddr; 820 int status; 821 822 status = ntohl(*p++); 823 p = xdr_decode_post_op_attr(p, fattr); 824 825 if (status != 0) 826 return -nfs_stat_to_errno(status); 827 828 /* Convert length of symlink */ 829 len = ntohl(*p++); 830 if (len >= rcvbuf->page_len || len <= 0) { 831 dprintk("nfs: server returned giant symlink!\n"); 832 return -ENAMETOOLONG; 833 } 834 835 hdrlen = (u8 *) p - (u8 *) iov->iov_base; 836 if (iov->iov_len < hdrlen) { 837 dprintk("NFS: READLINK reply header overflowed:" 838 "length %d > %Zu\n", hdrlen, iov->iov_len); 839 return -errno_NFSERR_IO; 840 } else if (iov->iov_len != hdrlen) { 841 dprintk("NFS: READLINK header is short. " 842 "iovec will be shifted.\n"); 843 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen); 844 } 845 recvd = req->rq_rcv_buf.len - hdrlen; 846 if (recvd < len) { 847 dprintk("NFS: server cheating in readlink reply: " 848 "count %u > recvd %u\n", len, recvd); 849 return -EIO; 850 } 851 852 /* NULL terminate the string we got */ 853 kaddr = (char*)kmap_atomic(rcvbuf->pages[0], KM_USER0); 854 kaddr[len+rcvbuf->page_base] = '\0'; 855 kunmap_atomic(kaddr, KM_USER0); 856 return 0; 857 } 858 859 /* 860 * Decode READ reply 861 */ 862 static int 863 nfs3_xdr_readres(struct rpc_rqst *req, __be32 *p, struct nfs_readres *res) 864 { 865 struct kvec *iov = req->rq_rcv_buf.head; 866 int status, count, ocount, recvd, hdrlen; 867 868 status = ntohl(*p++); 869 p = xdr_decode_post_op_attr(p, res->fattr); 870 871 if (status != 0) 872 return -nfs_stat_to_errno(status); 873 874 /* Decode reply could and EOF flag. NFSv3 is somewhat redundant 875 * in that it puts the count both in the res struct and in the 876 * opaque data count. */ 877 count = ntohl(*p++); 878 res->eof = ntohl(*p++); 879 ocount = ntohl(*p++); 880 881 if (ocount != count) { 882 dprintk("NFS: READ count doesn't match RPC opaque count.\n"); 883 return -errno_NFSERR_IO; 884 } 885 886 hdrlen = (u8 *) p - (u8 *) iov->iov_base; 887 if (iov->iov_len < hdrlen) { 888 dprintk("NFS: READ reply header overflowed:" 889 "length %d > %Zu\n", hdrlen, iov->iov_len); 890 return -errno_NFSERR_IO; 891 } else if (iov->iov_len != hdrlen) { 892 dprintk("NFS: READ header is short. iovec will be shifted.\n"); 893 xdr_shift_buf(&req->rq_rcv_buf, iov->iov_len - hdrlen); 894 } 895 896 recvd = req->rq_rcv_buf.len - hdrlen; 897 if (count > recvd) { 898 dprintk("NFS: server cheating in read reply: " 899 "count %d > recvd %d\n", count, recvd); 900 count = recvd; 901 res->eof = 0; 902 } 903 904 if (count < res->count) 905 res->count = count; 906 907 return count; 908 } 909 910 /* 911 * Decode WRITE response 912 */ 913 static int 914 nfs3_xdr_writeres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res) 915 { 916 int status; 917 918 status = ntohl(*p++); 919 p = xdr_decode_wcc_data(p, res->fattr); 920 921 if (status != 0) 922 return -nfs_stat_to_errno(status); 923 924 res->count = ntohl(*p++); 925 res->verf->committed = (enum nfs3_stable_how)ntohl(*p++); 926 res->verf->verifier[0] = *p++; 927 res->verf->verifier[1] = *p++; 928 929 return res->count; 930 } 931 932 /* 933 * Decode a CREATE response 934 */ 935 static int 936 nfs3_xdr_createres(struct rpc_rqst *req, __be32 *p, struct nfs3_diropres *res) 937 { 938 int status; 939 940 status = ntohl(*p++); 941 if (status == 0) { 942 if (*p++) { 943 if (!(p = xdr_decode_fhandle(p, res->fh))) 944 return -errno_NFSERR_IO; 945 p = xdr_decode_post_op_attr(p, res->fattr); 946 } else { 947 memset(res->fh, 0, sizeof(*res->fh)); 948 /* Do decode post_op_attr but set it to NULL */ 949 p = xdr_decode_post_op_attr(p, res->fattr); 950 res->fattr->valid = 0; 951 } 952 } else { 953 status = -nfs_stat_to_errno(status); 954 } 955 p = xdr_decode_wcc_data(p, res->dir_attr); 956 return status; 957 } 958 959 /* 960 * Decode RENAME reply 961 */ 962 static int 963 nfs3_xdr_renameres(struct rpc_rqst *req, __be32 *p, struct nfs3_renameres *res) 964 { 965 int status; 966 967 if ((status = ntohl(*p++)) != 0) 968 status = -nfs_stat_to_errno(status); 969 p = xdr_decode_wcc_data(p, res->fromattr); 970 p = xdr_decode_wcc_data(p, res->toattr); 971 return status; 972 } 973 974 /* 975 * Decode LINK reply 976 */ 977 static int 978 nfs3_xdr_linkres(struct rpc_rqst *req, __be32 *p, struct nfs3_linkres *res) 979 { 980 int status; 981 982 if ((status = ntohl(*p++)) != 0) 983 status = -nfs_stat_to_errno(status); 984 p = xdr_decode_post_op_attr(p, res->fattr); 985 p = xdr_decode_wcc_data(p, res->dir_attr); 986 return status; 987 } 988 989 /* 990 * Decode FSSTAT reply 991 */ 992 static int 993 nfs3_xdr_fsstatres(struct rpc_rqst *req, __be32 *p, struct nfs_fsstat *res) 994 { 995 int status; 996 997 status = ntohl(*p++); 998 999 p = xdr_decode_post_op_attr(p, res->fattr); 1000 if (status != 0) 1001 return -nfs_stat_to_errno(status); 1002 1003 p = xdr_decode_hyper(p, &res->tbytes); 1004 p = xdr_decode_hyper(p, &res->fbytes); 1005 p = xdr_decode_hyper(p, &res->abytes); 1006 p = xdr_decode_hyper(p, &res->tfiles); 1007 p = xdr_decode_hyper(p, &res->ffiles); 1008 p = xdr_decode_hyper(p, &res->afiles); 1009 1010 /* ignore invarsec */ 1011 return 0; 1012 } 1013 1014 /* 1015 * Decode FSINFO reply 1016 */ 1017 static int 1018 nfs3_xdr_fsinfores(struct rpc_rqst *req, __be32 *p, struct nfs_fsinfo *res) 1019 { 1020 int status; 1021 1022 status = ntohl(*p++); 1023 1024 p = xdr_decode_post_op_attr(p, res->fattr); 1025 if (status != 0) 1026 return -nfs_stat_to_errno(status); 1027 1028 res->rtmax = ntohl(*p++); 1029 res->rtpref = ntohl(*p++); 1030 res->rtmult = ntohl(*p++); 1031 res->wtmax = ntohl(*p++); 1032 res->wtpref = ntohl(*p++); 1033 res->wtmult = ntohl(*p++); 1034 res->dtpref = ntohl(*p++); 1035 p = xdr_decode_hyper(p, &res->maxfilesize); 1036 1037 /* ignore time_delta and properties */ 1038 res->lease_time = 0; 1039 return 0; 1040 } 1041 1042 /* 1043 * Decode PATHCONF reply 1044 */ 1045 static int 1046 nfs3_xdr_pathconfres(struct rpc_rqst *req, __be32 *p, struct nfs_pathconf *res) 1047 { 1048 int status; 1049 1050 status = ntohl(*p++); 1051 1052 p = xdr_decode_post_op_attr(p, res->fattr); 1053 if (status != 0) 1054 return -nfs_stat_to_errno(status); 1055 res->max_link = ntohl(*p++); 1056 res->max_namelen = ntohl(*p++); 1057 1058 /* ignore remaining fields */ 1059 return 0; 1060 } 1061 1062 /* 1063 * Decode COMMIT reply 1064 */ 1065 static int 1066 nfs3_xdr_commitres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res) 1067 { 1068 int status; 1069 1070 status = ntohl(*p++); 1071 p = xdr_decode_wcc_data(p, res->fattr); 1072 if (status != 0) 1073 return -nfs_stat_to_errno(status); 1074 1075 res->verf->verifier[0] = *p++; 1076 res->verf->verifier[1] = *p++; 1077 return 0; 1078 } 1079 1080 #ifdef CONFIG_NFS_V3_ACL 1081 /* 1082 * Decode GETACL reply 1083 */ 1084 static int 1085 nfs3_xdr_getaclres(struct rpc_rqst *req, __be32 *p, 1086 struct nfs3_getaclres *res) 1087 { 1088 struct xdr_buf *buf = &req->rq_rcv_buf; 1089 int status = ntohl(*p++); 1090 struct posix_acl **acl; 1091 unsigned int *aclcnt; 1092 int err, base; 1093 1094 if (status != 0) 1095 return -nfs_stat_to_errno(status); 1096 p = xdr_decode_post_op_attr(p, res->fattr); 1097 res->mask = ntohl(*p++); 1098 if (res->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT)) 1099 return -EINVAL; 1100 base = (char *)p - (char *)req->rq_rcv_buf.head->iov_base; 1101 1102 acl = (res->mask & NFS_ACL) ? &res->acl_access : NULL; 1103 aclcnt = (res->mask & NFS_ACLCNT) ? &res->acl_access_count : NULL; 1104 err = nfsacl_decode(buf, base, aclcnt, acl); 1105 1106 acl = (res->mask & NFS_DFACL) ? &res->acl_default : NULL; 1107 aclcnt = (res->mask & NFS_DFACLCNT) ? &res->acl_default_count : NULL; 1108 if (err > 0) 1109 err = nfsacl_decode(buf, base + err, aclcnt, acl); 1110 return (err > 0) ? 0 : err; 1111 } 1112 1113 /* 1114 * Decode setacl reply. 1115 */ 1116 static int 1117 nfs3_xdr_setaclres(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr) 1118 { 1119 int status = ntohl(*p++); 1120 1121 if (status) 1122 return -nfs_stat_to_errno(status); 1123 xdr_decode_post_op_attr(p, fattr); 1124 return 0; 1125 } 1126 #endif /* CONFIG_NFS_V3_ACL */ 1127 1128 #define PROC(proc, argtype, restype, timer) \ 1129 [NFS3PROC_##proc] = { \ 1130 .p_proc = NFS3PROC_##proc, \ 1131 .p_encode = (kxdrproc_t) nfs3_xdr_##argtype, \ 1132 .p_decode = (kxdrproc_t) nfs3_xdr_##restype, \ 1133 .p_arglen = NFS3_##argtype##_sz, \ 1134 .p_replen = NFS3_##restype##_sz, \ 1135 .p_timer = timer, \ 1136 .p_statidx = NFS3PROC_##proc, \ 1137 .p_name = #proc, \ 1138 } 1139 1140 struct rpc_procinfo nfs3_procedures[] = { 1141 PROC(GETATTR, fhandle, attrstat, 1), 1142 PROC(SETATTR, sattrargs, wccstat, 0), 1143 PROC(LOOKUP, diropargs, lookupres, 2), 1144 PROC(ACCESS, accessargs, accessres, 1), 1145 PROC(READLINK, readlinkargs, readlinkres, 3), 1146 PROC(READ, readargs, readres, 3), 1147 PROC(WRITE, writeargs, writeres, 4), 1148 PROC(CREATE, createargs, createres, 0), 1149 PROC(MKDIR, mkdirargs, createres, 0), 1150 PROC(SYMLINK, symlinkargs, createres, 0), 1151 PROC(MKNOD, mknodargs, createres, 0), 1152 PROC(REMOVE, removeargs, removeres, 0), 1153 PROC(RMDIR, diropargs, wccstat, 0), 1154 PROC(RENAME, renameargs, renameres, 0), 1155 PROC(LINK, linkargs, linkres, 0), 1156 PROC(READDIR, readdirargs, readdirres, 3), 1157 PROC(READDIRPLUS, readdirargs, readdirres, 3), 1158 PROC(FSSTAT, fhandle, fsstatres, 0), 1159 PROC(FSINFO, fhandle, fsinfores, 0), 1160 PROC(PATHCONF, fhandle, pathconfres, 0), 1161 PROC(COMMIT, commitargs, commitres, 5), 1162 }; 1163 1164 struct rpc_version nfs_version3 = { 1165 .number = 3, 1166 .nrprocs = ARRAY_SIZE(nfs3_procedures), 1167 .procs = nfs3_procedures 1168 }; 1169 1170 #ifdef CONFIG_NFS_V3_ACL 1171 static struct rpc_procinfo nfs3_acl_procedures[] = { 1172 [ACLPROC3_GETACL] = { 1173 .p_proc = ACLPROC3_GETACL, 1174 .p_encode = (kxdrproc_t) nfs3_xdr_getaclargs, 1175 .p_decode = (kxdrproc_t) nfs3_xdr_getaclres, 1176 .p_arglen = ACL3_getaclargs_sz, 1177 .p_replen = ACL3_getaclres_sz, 1178 .p_timer = 1, 1179 .p_name = "GETACL", 1180 }, 1181 [ACLPROC3_SETACL] = { 1182 .p_proc = ACLPROC3_SETACL, 1183 .p_encode = (kxdrproc_t) nfs3_xdr_setaclargs, 1184 .p_decode = (kxdrproc_t) nfs3_xdr_setaclres, 1185 .p_arglen = ACL3_setaclargs_sz, 1186 .p_replen = ACL3_setaclres_sz, 1187 .p_timer = 0, 1188 .p_name = "SETACL", 1189 }, 1190 }; 1191 1192 struct rpc_version nfsacl_version3 = { 1193 .number = 3, 1194 .nrprocs = sizeof(nfs3_acl_procedures)/ 1195 sizeof(nfs3_acl_procedures[0]), 1196 .procs = nfs3_acl_procedures, 1197 }; 1198 #endif /* CONFIG_NFS_V3_ACL */ 1199