1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * 9P Protocol Support Code 4 * 5 * Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com> 6 * 7 * Base on code from Anthony Liguori <aliguori@us.ibm.com> 8 * Copyright (C) 2008 by IBM, Corp. 9 */ 10 11 #include <linux/module.h> 12 #include <linux/errno.h> 13 #include <linux/kernel.h> 14 #include <linux/uaccess.h> 15 #include <linux/slab.h> 16 #include <linux/sched.h> 17 #include <linux/stddef.h> 18 #include <linux/types.h> 19 #include <linux/uio.h> 20 #include <net/9p/9p.h> 21 #include <net/9p/client.h> 22 #include "protocol.h" 23 24 #include <trace/events/9p.h> 25 26 /* len[2] text[len] */ 27 #define P9_STRLEN(s) \ 28 (2 + min_t(size_t, s ? strlen(s) : 0, USHRT_MAX)) 29 30 /** 31 * p9_msg_buf_size - Returns a buffer size sufficiently large to hold the 32 * intended 9p message. 33 * @c: client 34 * @type: message type 35 * @fmt: format template for assembling request message 36 * (see p9pdu_vwritef) 37 * @ap: variable arguments to be fed to passed format template 38 * (see p9pdu_vwritef) 39 * 40 * Note: Even for response types (P9_R*) the format template and variable 41 * arguments must always be for the originating request type (P9_T*). 42 */ 43 size_t p9_msg_buf_size(struct p9_client *c, enum p9_msg_t type, 44 const char *fmt, va_list ap) 45 { 46 /* size[4] type[1] tag[2] */ 47 const int hdr = 4 + 1 + 2; 48 /* ename[s] errno[4] */ 49 const int rerror_size = hdr + P9_ERRMAX + 4; 50 /* ecode[4] */ 51 const int rlerror_size = hdr + 4; 52 const int err_size = 53 c->proto_version == p9_proto_2000L ? rlerror_size : rerror_size; 54 55 static_assert(NAME_MAX <= 4*1024, "p9_msg_buf_size() currently assumes " 56 "a max. allowed directory entry name length of 4k"); 57 58 switch (type) { 59 60 /* message types not used at all */ 61 case P9_TERROR: 62 case P9_TLERROR: 63 case P9_TAUTH: 64 case P9_RAUTH: 65 BUG(); 66 67 /* variable length & potentially large message types */ 68 case P9_TATTACH: 69 BUG_ON(strcmp("ddss?u", fmt)); 70 va_arg(ap, int32_t); 71 va_arg(ap, int32_t); 72 { 73 const char *uname = va_arg(ap, const char *); 74 const char *aname = va_arg(ap, const char *); 75 /* fid[4] afid[4] uname[s] aname[s] n_uname[4] */ 76 return hdr + 4 + 4 + P9_STRLEN(uname) + P9_STRLEN(aname) + 4; 77 } 78 case P9_TWALK: 79 BUG_ON(strcmp("ddT", fmt)); 80 va_arg(ap, int32_t); 81 va_arg(ap, int32_t); 82 { 83 uint i, nwname = va_arg(ap, int); 84 size_t wname_all; 85 const char **wnames = va_arg(ap, const char **); 86 for (i = 0, wname_all = 0; i < nwname; ++i) { 87 wname_all += P9_STRLEN(wnames[i]); 88 } 89 /* fid[4] newfid[4] nwname[2] nwname*(wname[s]) */ 90 return hdr + 4 + 4 + 2 + wname_all; 91 } 92 case P9_RWALK: 93 BUG_ON(strcmp("ddT", fmt)); 94 va_arg(ap, int32_t); 95 va_arg(ap, int32_t); 96 { 97 uint nwname = va_arg(ap, int); 98 /* nwqid[2] nwqid*(wqid[13]) */ 99 return max_t(size_t, hdr + 2 + nwname * 13, err_size); 100 } 101 case P9_TCREATE: 102 BUG_ON(strcmp("dsdb?s", fmt)); 103 va_arg(ap, int32_t); 104 { 105 const char *name = va_arg(ap, const char *); 106 if (c->proto_version == p9_proto_legacy) { 107 /* fid[4] name[s] perm[4] mode[1] */ 108 return hdr + 4 + P9_STRLEN(name) + 4 + 1; 109 } else { 110 va_arg(ap, int32_t); 111 va_arg(ap, int); 112 { 113 const char *ext = va_arg(ap, const char *); 114 /* fid[4] name[s] perm[4] mode[1] extension[s] */ 115 return hdr + 4 + P9_STRLEN(name) + 4 + 1 + P9_STRLEN(ext); 116 } 117 } 118 } 119 case P9_TLCREATE: 120 BUG_ON(strcmp("dsddg", fmt)); 121 va_arg(ap, int32_t); 122 { 123 const char *name = va_arg(ap, const char *); 124 /* fid[4] name[s] flags[4] mode[4] gid[4] */ 125 return hdr + 4 + P9_STRLEN(name) + 4 + 4 + 4; 126 } 127 case P9_RREAD: 128 case P9_RREADDIR: 129 BUG_ON(strcmp("dqd", fmt)); 130 va_arg(ap, int32_t); 131 va_arg(ap, int64_t); 132 { 133 const int32_t count = va_arg(ap, int32_t); 134 /* count[4] data[count] */ 135 return max_t(size_t, hdr + 4 + count, err_size); 136 } 137 case P9_TWRITE: 138 BUG_ON(strcmp("dqV", fmt)); 139 va_arg(ap, int32_t); 140 va_arg(ap, int64_t); 141 { 142 const int32_t count = va_arg(ap, int32_t); 143 /* fid[4] offset[8] count[4] data[count] */ 144 return hdr + 4 + 8 + 4 + count; 145 } 146 case P9_TRENAMEAT: 147 BUG_ON(strcmp("dsds", fmt)); 148 va_arg(ap, int32_t); 149 { 150 const char *oldname, *newname; 151 oldname = va_arg(ap, const char *); 152 va_arg(ap, int32_t); 153 newname = va_arg(ap, const char *); 154 /* olddirfid[4] oldname[s] newdirfid[4] newname[s] */ 155 return hdr + 4 + P9_STRLEN(oldname) + 4 + P9_STRLEN(newname); 156 } 157 case P9_TSYMLINK: 158 BUG_ON(strcmp("dssg", fmt)); 159 va_arg(ap, int32_t); 160 { 161 const char *name = va_arg(ap, const char *); 162 const char *symtgt = va_arg(ap, const char *); 163 /* fid[4] name[s] symtgt[s] gid[4] */ 164 return hdr + 4 + P9_STRLEN(name) + P9_STRLEN(symtgt) + 4; 165 } 166 167 case P9_RERROR: 168 return rerror_size; 169 case P9_RLERROR: 170 return rlerror_size; 171 172 /* small message types */ 173 case P9_TWSTAT: 174 case P9_RSTAT: 175 case P9_RREADLINK: 176 case P9_TXATTRWALK: 177 case P9_TXATTRCREATE: 178 case P9_TLINK: 179 case P9_TMKDIR: 180 case P9_TMKNOD: 181 case P9_TRENAME: 182 case P9_TUNLINKAT: 183 case P9_TLOCK: 184 return 8 * 1024; 185 186 /* tiny message types */ 187 default: 188 return 4 * 1024; 189 190 } 191 } 192 193 static int 194 p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...); 195 196 void p9stat_free(struct p9_wstat *stbuf) 197 { 198 kfree(stbuf->name); 199 stbuf->name = NULL; 200 kfree(stbuf->uid); 201 stbuf->uid = NULL; 202 kfree(stbuf->gid); 203 stbuf->gid = NULL; 204 kfree(stbuf->muid); 205 stbuf->muid = NULL; 206 kfree(stbuf->extension); 207 stbuf->extension = NULL; 208 } 209 EXPORT_SYMBOL(p9stat_free); 210 211 size_t pdu_read(struct p9_fcall *pdu, void *data, size_t size) 212 { 213 size_t len = min(pdu->size - pdu->offset, size); 214 215 memcpy(data, &pdu->sdata[pdu->offset], len); 216 pdu->offset += len; 217 return size - len; 218 } 219 220 static size_t pdu_write(struct p9_fcall *pdu, const void *data, size_t size) 221 { 222 size_t len = min(pdu->capacity - pdu->size, size); 223 224 memcpy(&pdu->sdata[pdu->size], data, len); 225 pdu->size += len; 226 return size - len; 227 } 228 229 static size_t 230 pdu_write_u(struct p9_fcall *pdu, struct iov_iter *from, size_t size) 231 { 232 size_t len = min(pdu->capacity - pdu->size, size); 233 234 if (!copy_from_iter_full(&pdu->sdata[pdu->size], len, from)) 235 len = 0; 236 237 pdu->size += len; 238 return size - len; 239 } 240 241 /* b - int8_t 242 * w - int16_t 243 * d - int32_t 244 * q - int64_t 245 * s - string 246 * u - numeric uid 247 * g - numeric gid 248 * S - stat 249 * Q - qid 250 * D - data blob (int32_t size followed by void *, results are not freed) 251 * T - array of strings (int16_t count, followed by strings) 252 * R - array of qids (int16_t count, followed by qids) 253 * A - stat for 9p2000.L (p9_stat_dotl) 254 * ? - if optional = 1, continue parsing 255 */ 256 257 static int 258 p9pdu_vreadf(struct p9_fcall *pdu, int proto_version, const char *fmt, 259 va_list ap) 260 { 261 const char *ptr; 262 int errcode = 0; 263 264 for (ptr = fmt; *ptr; ptr++) { 265 switch (*ptr) { 266 case 'b':{ 267 int8_t *val = va_arg(ap, int8_t *); 268 if (pdu_read(pdu, val, sizeof(*val))) { 269 errcode = -EFAULT; 270 break; 271 } 272 } 273 break; 274 case 'w':{ 275 int16_t *val = va_arg(ap, int16_t *); 276 __le16 le_val; 277 if (pdu_read(pdu, &le_val, sizeof(le_val))) { 278 errcode = -EFAULT; 279 break; 280 } 281 *val = le16_to_cpu(le_val); 282 } 283 break; 284 case 'd':{ 285 int32_t *val = va_arg(ap, int32_t *); 286 __le32 le_val; 287 if (pdu_read(pdu, &le_val, sizeof(le_val))) { 288 errcode = -EFAULT; 289 break; 290 } 291 *val = le32_to_cpu(le_val); 292 } 293 break; 294 case 'q':{ 295 int64_t *val = va_arg(ap, int64_t *); 296 __le64 le_val; 297 if (pdu_read(pdu, &le_val, sizeof(le_val))) { 298 errcode = -EFAULT; 299 break; 300 } 301 *val = le64_to_cpu(le_val); 302 } 303 break; 304 case 's':{ 305 char **sptr = va_arg(ap, char **); 306 uint16_t len; 307 308 errcode = p9pdu_readf(pdu, proto_version, 309 "w", &len); 310 if (errcode) 311 break; 312 313 *sptr = kmalloc(len + 1, GFP_NOFS); 314 if (*sptr == NULL) { 315 errcode = -ENOMEM; 316 break; 317 } 318 if (pdu_read(pdu, *sptr, len)) { 319 errcode = -EFAULT; 320 kfree(*sptr); 321 *sptr = NULL; 322 } else 323 (*sptr)[len] = 0; 324 } 325 break; 326 case 'u': { 327 kuid_t *uid = va_arg(ap, kuid_t *); 328 __le32 le_val; 329 if (pdu_read(pdu, &le_val, sizeof(le_val))) { 330 errcode = -EFAULT; 331 break; 332 } 333 *uid = make_kuid(&init_user_ns, 334 le32_to_cpu(le_val)); 335 } break; 336 case 'g': { 337 kgid_t *gid = va_arg(ap, kgid_t *); 338 __le32 le_val; 339 if (pdu_read(pdu, &le_val, sizeof(le_val))) { 340 errcode = -EFAULT; 341 break; 342 } 343 *gid = make_kgid(&init_user_ns, 344 le32_to_cpu(le_val)); 345 } break; 346 case 'Q':{ 347 struct p9_qid *qid = 348 va_arg(ap, struct p9_qid *); 349 350 errcode = p9pdu_readf(pdu, proto_version, "bdq", 351 &qid->type, &qid->version, 352 &qid->path); 353 } 354 break; 355 case 'S':{ 356 struct p9_wstat *stbuf = 357 va_arg(ap, struct p9_wstat *); 358 359 memset(stbuf, 0, sizeof(struct p9_wstat)); 360 stbuf->n_uid = stbuf->n_muid = INVALID_UID; 361 stbuf->n_gid = INVALID_GID; 362 363 errcode = 364 p9pdu_readf(pdu, proto_version, 365 "wwdQdddqssss?sugu", 366 &stbuf->size, &stbuf->type, 367 &stbuf->dev, &stbuf->qid, 368 &stbuf->mode, &stbuf->atime, 369 &stbuf->mtime, &stbuf->length, 370 &stbuf->name, &stbuf->uid, 371 &stbuf->gid, &stbuf->muid, 372 &stbuf->extension, 373 &stbuf->n_uid, &stbuf->n_gid, 374 &stbuf->n_muid); 375 if (errcode) 376 p9stat_free(stbuf); 377 } 378 break; 379 case 'D':{ 380 uint32_t *count = va_arg(ap, uint32_t *); 381 void **data = va_arg(ap, void **); 382 383 errcode = 384 p9pdu_readf(pdu, proto_version, "d", count); 385 if (!errcode) { 386 *count = 387 min_t(uint32_t, *count, 388 pdu->size - pdu->offset); 389 *data = &pdu->sdata[pdu->offset]; 390 } 391 } 392 break; 393 case 'T':{ 394 uint16_t *nwname = va_arg(ap, uint16_t *); 395 char ***wnames = va_arg(ap, char ***); 396 397 errcode = p9pdu_readf(pdu, proto_version, 398 "w", nwname); 399 if (!errcode) { 400 *wnames = 401 kmalloc_array(*nwname, 402 sizeof(char *), 403 GFP_NOFS); 404 if (!*wnames) 405 errcode = -ENOMEM; 406 } 407 408 if (!errcode) { 409 int i; 410 411 for (i = 0; i < *nwname; i++) { 412 errcode = 413 p9pdu_readf(pdu, 414 proto_version, 415 "s", 416 &(*wnames)[i]); 417 if (errcode) 418 break; 419 } 420 } 421 422 if (errcode) { 423 if (*wnames) { 424 int i; 425 426 for (i = 0; i < *nwname; i++) 427 kfree((*wnames)[i]); 428 } 429 kfree(*wnames); 430 *wnames = NULL; 431 } 432 } 433 break; 434 case 'R':{ 435 uint16_t *nwqid = va_arg(ap, uint16_t *); 436 struct p9_qid **wqids = 437 va_arg(ap, struct p9_qid **); 438 439 *wqids = NULL; 440 441 errcode = 442 p9pdu_readf(pdu, proto_version, "w", nwqid); 443 if (!errcode) { 444 *wqids = 445 kmalloc_array(*nwqid, 446 sizeof(struct p9_qid), 447 GFP_NOFS); 448 if (*wqids == NULL) 449 errcode = -ENOMEM; 450 } 451 452 if (!errcode) { 453 int i; 454 455 for (i = 0; i < *nwqid; i++) { 456 errcode = 457 p9pdu_readf(pdu, 458 proto_version, 459 "Q", 460 &(*wqids)[i]); 461 if (errcode) 462 break; 463 } 464 } 465 466 if (errcode) { 467 kfree(*wqids); 468 *wqids = NULL; 469 } 470 } 471 break; 472 case 'A': { 473 struct p9_stat_dotl *stbuf = 474 va_arg(ap, struct p9_stat_dotl *); 475 476 memset(stbuf, 0, sizeof(struct p9_stat_dotl)); 477 errcode = 478 p9pdu_readf(pdu, proto_version, 479 "qQdugqqqqqqqqqqqqqqq", 480 &stbuf->st_result_mask, 481 &stbuf->qid, 482 &stbuf->st_mode, 483 &stbuf->st_uid, &stbuf->st_gid, 484 &stbuf->st_nlink, 485 &stbuf->st_rdev, &stbuf->st_size, 486 &stbuf->st_blksize, &stbuf->st_blocks, 487 &stbuf->st_atime_sec, 488 &stbuf->st_atime_nsec, 489 &stbuf->st_mtime_sec, 490 &stbuf->st_mtime_nsec, 491 &stbuf->st_ctime_sec, 492 &stbuf->st_ctime_nsec, 493 &stbuf->st_btime_sec, 494 &stbuf->st_btime_nsec, 495 &stbuf->st_gen, 496 &stbuf->st_data_version); 497 } 498 break; 499 case '?': 500 if ((proto_version != p9_proto_2000u) && 501 (proto_version != p9_proto_2000L)) 502 return 0; 503 break; 504 default: 505 BUG(); 506 break; 507 } 508 509 if (errcode) 510 break; 511 } 512 513 return errcode; 514 } 515 516 int 517 p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt, 518 va_list ap) 519 { 520 const char *ptr; 521 int errcode = 0; 522 523 for (ptr = fmt; *ptr; ptr++) { 524 switch (*ptr) { 525 case 'b':{ 526 int8_t val = va_arg(ap, int); 527 if (pdu_write(pdu, &val, sizeof(val))) 528 errcode = -EFAULT; 529 } 530 break; 531 case 'w':{ 532 __le16 val = cpu_to_le16(va_arg(ap, int)); 533 if (pdu_write(pdu, &val, sizeof(val))) 534 errcode = -EFAULT; 535 } 536 break; 537 case 'd':{ 538 __le32 val = cpu_to_le32(va_arg(ap, int32_t)); 539 if (pdu_write(pdu, &val, sizeof(val))) 540 errcode = -EFAULT; 541 } 542 break; 543 case 'q':{ 544 __le64 val = cpu_to_le64(va_arg(ap, int64_t)); 545 if (pdu_write(pdu, &val, sizeof(val))) 546 errcode = -EFAULT; 547 } 548 break; 549 case 's':{ 550 const char *sptr = va_arg(ap, const char *); 551 uint16_t len = 0; 552 if (sptr) 553 len = min_t(size_t, strlen(sptr), 554 USHRT_MAX); 555 556 errcode = p9pdu_writef(pdu, proto_version, 557 "w", len); 558 if (!errcode && pdu_write(pdu, sptr, len)) 559 errcode = -EFAULT; 560 } 561 break; 562 case 'u': { 563 kuid_t uid = va_arg(ap, kuid_t); 564 __le32 val = cpu_to_le32( 565 from_kuid(&init_user_ns, uid)); 566 if (pdu_write(pdu, &val, sizeof(val))) 567 errcode = -EFAULT; 568 } break; 569 case 'g': { 570 kgid_t gid = va_arg(ap, kgid_t); 571 __le32 val = cpu_to_le32( 572 from_kgid(&init_user_ns, gid)); 573 if (pdu_write(pdu, &val, sizeof(val))) 574 errcode = -EFAULT; 575 } break; 576 case 'Q':{ 577 const struct p9_qid *qid = 578 va_arg(ap, const struct p9_qid *); 579 errcode = 580 p9pdu_writef(pdu, proto_version, "bdq", 581 qid->type, qid->version, 582 qid->path); 583 } break; 584 case 'S':{ 585 const struct p9_wstat *stbuf = 586 va_arg(ap, const struct p9_wstat *); 587 errcode = 588 p9pdu_writef(pdu, proto_version, 589 "wwdQdddqssss?sugu", 590 stbuf->size, stbuf->type, 591 stbuf->dev, &stbuf->qid, 592 stbuf->mode, stbuf->atime, 593 stbuf->mtime, stbuf->length, 594 stbuf->name, stbuf->uid, 595 stbuf->gid, stbuf->muid, 596 stbuf->extension, stbuf->n_uid, 597 stbuf->n_gid, stbuf->n_muid); 598 } break; 599 case 'V':{ 600 uint32_t count = va_arg(ap, uint32_t); 601 struct iov_iter *from = 602 va_arg(ap, struct iov_iter *); 603 errcode = p9pdu_writef(pdu, proto_version, "d", 604 count); 605 if (!errcode && pdu_write_u(pdu, from, count)) 606 errcode = -EFAULT; 607 } 608 break; 609 case 'T':{ 610 uint16_t nwname = va_arg(ap, int); 611 const char **wnames = va_arg(ap, const char **); 612 613 errcode = p9pdu_writef(pdu, proto_version, "w", 614 nwname); 615 if (!errcode) { 616 int i; 617 618 for (i = 0; i < nwname; i++) { 619 errcode = 620 p9pdu_writef(pdu, 621 proto_version, 622 "s", 623 wnames[i]); 624 if (errcode) 625 break; 626 } 627 } 628 } 629 break; 630 case 'R':{ 631 uint16_t nwqid = va_arg(ap, int); 632 struct p9_qid *wqids = 633 va_arg(ap, struct p9_qid *); 634 635 errcode = p9pdu_writef(pdu, proto_version, "w", 636 nwqid); 637 if (!errcode) { 638 int i; 639 640 for (i = 0; i < nwqid; i++) { 641 errcode = 642 p9pdu_writef(pdu, 643 proto_version, 644 "Q", 645 &wqids[i]); 646 if (errcode) 647 break; 648 } 649 } 650 } 651 break; 652 case 'I':{ 653 struct p9_iattr_dotl *p9attr = va_arg(ap, 654 struct p9_iattr_dotl *); 655 656 errcode = p9pdu_writef(pdu, proto_version, 657 "ddugqqqqq", 658 p9attr->valid, 659 p9attr->mode, 660 p9attr->uid, 661 p9attr->gid, 662 p9attr->size, 663 p9attr->atime_sec, 664 p9attr->atime_nsec, 665 p9attr->mtime_sec, 666 p9attr->mtime_nsec); 667 } 668 break; 669 case '?': 670 if ((proto_version != p9_proto_2000u) && 671 (proto_version != p9_proto_2000L)) 672 return 0; 673 break; 674 default: 675 BUG(); 676 break; 677 } 678 679 if (errcode) 680 break; 681 } 682 683 return errcode; 684 } 685 686 int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...) 687 { 688 va_list ap; 689 int ret; 690 691 va_start(ap, fmt); 692 ret = p9pdu_vreadf(pdu, proto_version, fmt, ap); 693 va_end(ap); 694 695 return ret; 696 } 697 698 static int 699 p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...) 700 { 701 va_list ap; 702 int ret; 703 704 va_start(ap, fmt); 705 ret = p9pdu_vwritef(pdu, proto_version, fmt, ap); 706 va_end(ap); 707 708 return ret; 709 } 710 711 int p9stat_read(struct p9_client *clnt, char *buf, int len, struct p9_wstat *st) 712 { 713 struct p9_fcall fake_pdu; 714 int ret; 715 716 fake_pdu.size = len; 717 fake_pdu.capacity = len; 718 fake_pdu.sdata = buf; 719 fake_pdu.offset = 0; 720 721 ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "S", st); 722 if (ret) { 723 p9_debug(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret); 724 trace_9p_protocol_dump(clnt, &fake_pdu); 725 return ret; 726 } 727 728 return fake_pdu.offset; 729 } 730 EXPORT_SYMBOL(p9stat_read); 731 732 int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type) 733 { 734 pdu->id = type; 735 return p9pdu_writef(pdu, 0, "dbw", 0, type, tag); 736 } 737 738 int p9pdu_finalize(struct p9_client *clnt, struct p9_fcall *pdu) 739 { 740 int size = pdu->size; 741 int err; 742 743 pdu->size = 0; 744 err = p9pdu_writef(pdu, 0, "d", size); 745 pdu->size = size; 746 747 trace_9p_protocol_dump(clnt, pdu); 748 p9_debug(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n", 749 pdu->size, pdu->id, pdu->tag); 750 751 return err; 752 } 753 754 void p9pdu_reset(struct p9_fcall *pdu) 755 { 756 pdu->offset = 0; 757 pdu->size = 0; 758 } 759 760 int p9dirent_read(struct p9_client *clnt, char *buf, int len, 761 struct p9_dirent *dirent) 762 { 763 struct p9_fcall fake_pdu; 764 int ret; 765 char *nameptr; 766 767 fake_pdu.size = len; 768 fake_pdu.capacity = len; 769 fake_pdu.sdata = buf; 770 fake_pdu.offset = 0; 771 772 ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "Qqbs", &dirent->qid, 773 &dirent->d_off, &dirent->d_type, &nameptr); 774 if (ret) { 775 p9_debug(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret); 776 trace_9p_protocol_dump(clnt, &fake_pdu); 777 return ret; 778 } 779 780 ret = strscpy(dirent->d_name, nameptr, sizeof(dirent->d_name)); 781 if (ret < 0) { 782 p9_debug(P9_DEBUG_ERROR, 783 "On the wire dirent name too long: %s\n", 784 nameptr); 785 kfree(nameptr); 786 return ret; 787 } 788 kfree(nameptr); 789 790 return fake_pdu.offset; 791 } 792 EXPORT_SYMBOL(p9dirent_read); 793