1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * net/9p/protocol.c 4 * 5 * 9P Protocol Support Code 6 * 7 * Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com> 8 * 9 * Base on code from Anthony Liguori <aliguori@us.ibm.com> 10 * Copyright (C) 2008 by IBM, Corp. 11 */ 12 13 #include <linux/module.h> 14 #include <linux/errno.h> 15 #include <linux/kernel.h> 16 #include <linux/uaccess.h> 17 #include <linux/slab.h> 18 #include <linux/sched.h> 19 #include <linux/stddef.h> 20 #include <linux/types.h> 21 #include <linux/uio.h> 22 #include <net/9p/9p.h> 23 #include <net/9p/client.h> 24 #include "protocol.h" 25 26 #include <trace/events/9p.h> 27 28 static int 29 p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...); 30 31 void p9stat_free(struct p9_wstat *stbuf) 32 { 33 kfree(stbuf->name); 34 stbuf->name = NULL; 35 kfree(stbuf->uid); 36 stbuf->uid = NULL; 37 kfree(stbuf->gid); 38 stbuf->gid = NULL; 39 kfree(stbuf->muid); 40 stbuf->muid = NULL; 41 kfree(stbuf->extension); 42 stbuf->extension = NULL; 43 } 44 EXPORT_SYMBOL(p9stat_free); 45 46 size_t pdu_read(struct p9_fcall *pdu, void *data, size_t size) 47 { 48 size_t len = min(pdu->size - pdu->offset, size); 49 memcpy(data, &pdu->sdata[pdu->offset], len); 50 pdu->offset += len; 51 return size - len; 52 } 53 54 static size_t pdu_write(struct p9_fcall *pdu, const void *data, size_t size) 55 { 56 size_t len = min(pdu->capacity - pdu->size, size); 57 memcpy(&pdu->sdata[pdu->size], data, len); 58 pdu->size += len; 59 return size - len; 60 } 61 62 static size_t 63 pdu_write_u(struct p9_fcall *pdu, struct iov_iter *from, size_t size) 64 { 65 size_t len = min(pdu->capacity - pdu->size, size); 66 struct iov_iter i = *from; 67 if (!copy_from_iter_full(&pdu->sdata[pdu->size], len, &i)) 68 len = 0; 69 70 pdu->size += len; 71 return size - len; 72 } 73 74 /* 75 b - int8_t 76 w - int16_t 77 d - int32_t 78 q - int64_t 79 s - string 80 u - numeric uid 81 g - numeric gid 82 S - stat 83 Q - qid 84 D - data blob (int32_t size followed by void *, results are not freed) 85 T - array of strings (int16_t count, followed by strings) 86 R - array of qids (int16_t count, followed by qids) 87 A - stat for 9p2000.L (p9_stat_dotl) 88 ? - if optional = 1, continue parsing 89 */ 90 91 static int 92 p9pdu_vreadf(struct p9_fcall *pdu, int proto_version, const char *fmt, 93 va_list ap) 94 { 95 const char *ptr; 96 int errcode = 0; 97 98 for (ptr = fmt; *ptr; ptr++) { 99 switch (*ptr) { 100 case 'b':{ 101 int8_t *val = va_arg(ap, int8_t *); 102 if (pdu_read(pdu, val, sizeof(*val))) { 103 errcode = -EFAULT; 104 break; 105 } 106 } 107 break; 108 case 'w':{ 109 int16_t *val = va_arg(ap, int16_t *); 110 __le16 le_val; 111 if (pdu_read(pdu, &le_val, sizeof(le_val))) { 112 errcode = -EFAULT; 113 break; 114 } 115 *val = le16_to_cpu(le_val); 116 } 117 break; 118 case 'd':{ 119 int32_t *val = va_arg(ap, int32_t *); 120 __le32 le_val; 121 if (pdu_read(pdu, &le_val, sizeof(le_val))) { 122 errcode = -EFAULT; 123 break; 124 } 125 *val = le32_to_cpu(le_val); 126 } 127 break; 128 case 'q':{ 129 int64_t *val = va_arg(ap, int64_t *); 130 __le64 le_val; 131 if (pdu_read(pdu, &le_val, sizeof(le_val))) { 132 errcode = -EFAULT; 133 break; 134 } 135 *val = le64_to_cpu(le_val); 136 } 137 break; 138 case 's':{ 139 char **sptr = va_arg(ap, char **); 140 uint16_t len; 141 142 errcode = p9pdu_readf(pdu, proto_version, 143 "w", &len); 144 if (errcode) 145 break; 146 147 *sptr = kmalloc(len + 1, GFP_NOFS); 148 if (*sptr == NULL) { 149 errcode = -ENOMEM; 150 break; 151 } 152 if (pdu_read(pdu, *sptr, len)) { 153 errcode = -EFAULT; 154 kfree(*sptr); 155 *sptr = NULL; 156 } else 157 (*sptr)[len] = 0; 158 } 159 break; 160 case 'u': { 161 kuid_t *uid = va_arg(ap, kuid_t *); 162 __le32 le_val; 163 if (pdu_read(pdu, &le_val, sizeof(le_val))) { 164 errcode = -EFAULT; 165 break; 166 } 167 *uid = make_kuid(&init_user_ns, 168 le32_to_cpu(le_val)); 169 } break; 170 case 'g': { 171 kgid_t *gid = va_arg(ap, kgid_t *); 172 __le32 le_val; 173 if (pdu_read(pdu, &le_val, sizeof(le_val))) { 174 errcode = -EFAULT; 175 break; 176 } 177 *gid = make_kgid(&init_user_ns, 178 le32_to_cpu(le_val)); 179 } break; 180 case 'Q':{ 181 struct p9_qid *qid = 182 va_arg(ap, struct p9_qid *); 183 184 errcode = p9pdu_readf(pdu, proto_version, "bdq", 185 &qid->type, &qid->version, 186 &qid->path); 187 } 188 break; 189 case 'S':{ 190 struct p9_wstat *stbuf = 191 va_arg(ap, struct p9_wstat *); 192 193 memset(stbuf, 0, sizeof(struct p9_wstat)); 194 stbuf->n_uid = stbuf->n_muid = INVALID_UID; 195 stbuf->n_gid = INVALID_GID; 196 197 errcode = 198 p9pdu_readf(pdu, proto_version, 199 "wwdQdddqssss?sugu", 200 &stbuf->size, &stbuf->type, 201 &stbuf->dev, &stbuf->qid, 202 &stbuf->mode, &stbuf->atime, 203 &stbuf->mtime, &stbuf->length, 204 &stbuf->name, &stbuf->uid, 205 &stbuf->gid, &stbuf->muid, 206 &stbuf->extension, 207 &stbuf->n_uid, &stbuf->n_gid, 208 &stbuf->n_muid); 209 if (errcode) 210 p9stat_free(stbuf); 211 } 212 break; 213 case 'D':{ 214 uint32_t *count = va_arg(ap, uint32_t *); 215 void **data = va_arg(ap, void **); 216 217 errcode = 218 p9pdu_readf(pdu, proto_version, "d", count); 219 if (!errcode) { 220 *count = 221 min_t(uint32_t, *count, 222 pdu->size - pdu->offset); 223 *data = &pdu->sdata[pdu->offset]; 224 } 225 } 226 break; 227 case 'T':{ 228 uint16_t *nwname = va_arg(ap, uint16_t *); 229 char ***wnames = va_arg(ap, char ***); 230 231 errcode = p9pdu_readf(pdu, proto_version, 232 "w", nwname); 233 if (!errcode) { 234 *wnames = 235 kmalloc_array(*nwname, 236 sizeof(char *), 237 GFP_NOFS); 238 if (!*wnames) 239 errcode = -ENOMEM; 240 } 241 242 if (!errcode) { 243 int i; 244 245 for (i = 0; i < *nwname; i++) { 246 errcode = 247 p9pdu_readf(pdu, 248 proto_version, 249 "s", 250 &(*wnames)[i]); 251 if (errcode) 252 break; 253 } 254 } 255 256 if (errcode) { 257 if (*wnames) { 258 int i; 259 260 for (i = 0; i < *nwname; i++) 261 kfree((*wnames)[i]); 262 } 263 kfree(*wnames); 264 *wnames = NULL; 265 } 266 } 267 break; 268 case 'R':{ 269 uint16_t *nwqid = va_arg(ap, uint16_t *); 270 struct p9_qid **wqids = 271 va_arg(ap, struct p9_qid **); 272 273 *wqids = NULL; 274 275 errcode = 276 p9pdu_readf(pdu, proto_version, "w", nwqid); 277 if (!errcode) { 278 *wqids = 279 kmalloc_array(*nwqid, 280 sizeof(struct p9_qid), 281 GFP_NOFS); 282 if (*wqids == NULL) 283 errcode = -ENOMEM; 284 } 285 286 if (!errcode) { 287 int i; 288 289 for (i = 0; i < *nwqid; i++) { 290 errcode = 291 p9pdu_readf(pdu, 292 proto_version, 293 "Q", 294 &(*wqids)[i]); 295 if (errcode) 296 break; 297 } 298 } 299 300 if (errcode) { 301 kfree(*wqids); 302 *wqids = NULL; 303 } 304 } 305 break; 306 case 'A': { 307 struct p9_stat_dotl *stbuf = 308 va_arg(ap, struct p9_stat_dotl *); 309 310 memset(stbuf, 0, sizeof(struct p9_stat_dotl)); 311 errcode = 312 p9pdu_readf(pdu, proto_version, 313 "qQdugqqqqqqqqqqqqqqq", 314 &stbuf->st_result_mask, 315 &stbuf->qid, 316 &stbuf->st_mode, 317 &stbuf->st_uid, &stbuf->st_gid, 318 &stbuf->st_nlink, 319 &stbuf->st_rdev, &stbuf->st_size, 320 &stbuf->st_blksize, &stbuf->st_blocks, 321 &stbuf->st_atime_sec, 322 &stbuf->st_atime_nsec, 323 &stbuf->st_mtime_sec, 324 &stbuf->st_mtime_nsec, 325 &stbuf->st_ctime_sec, 326 &stbuf->st_ctime_nsec, 327 &stbuf->st_btime_sec, 328 &stbuf->st_btime_nsec, 329 &stbuf->st_gen, 330 &stbuf->st_data_version); 331 } 332 break; 333 case '?': 334 if ((proto_version != p9_proto_2000u) && 335 (proto_version != p9_proto_2000L)) 336 return 0; 337 break; 338 default: 339 BUG(); 340 break; 341 } 342 343 if (errcode) 344 break; 345 } 346 347 return errcode; 348 } 349 350 int 351 p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt, 352 va_list ap) 353 { 354 const char *ptr; 355 int errcode = 0; 356 357 for (ptr = fmt; *ptr; ptr++) { 358 switch (*ptr) { 359 case 'b':{ 360 int8_t val = va_arg(ap, int); 361 if (pdu_write(pdu, &val, sizeof(val))) 362 errcode = -EFAULT; 363 } 364 break; 365 case 'w':{ 366 __le16 val = cpu_to_le16(va_arg(ap, int)); 367 if (pdu_write(pdu, &val, sizeof(val))) 368 errcode = -EFAULT; 369 } 370 break; 371 case 'd':{ 372 __le32 val = cpu_to_le32(va_arg(ap, int32_t)); 373 if (pdu_write(pdu, &val, sizeof(val))) 374 errcode = -EFAULT; 375 } 376 break; 377 case 'q':{ 378 __le64 val = cpu_to_le64(va_arg(ap, int64_t)); 379 if (pdu_write(pdu, &val, sizeof(val))) 380 errcode = -EFAULT; 381 } 382 break; 383 case 's':{ 384 const char *sptr = va_arg(ap, const char *); 385 uint16_t len = 0; 386 if (sptr) 387 len = min_t(size_t, strlen(sptr), 388 USHRT_MAX); 389 390 errcode = p9pdu_writef(pdu, proto_version, 391 "w", len); 392 if (!errcode && pdu_write(pdu, sptr, len)) 393 errcode = -EFAULT; 394 } 395 break; 396 case 'u': { 397 kuid_t uid = va_arg(ap, kuid_t); 398 __le32 val = cpu_to_le32( 399 from_kuid(&init_user_ns, uid)); 400 if (pdu_write(pdu, &val, sizeof(val))) 401 errcode = -EFAULT; 402 } break; 403 case 'g': { 404 kgid_t gid = va_arg(ap, kgid_t); 405 __le32 val = cpu_to_le32( 406 from_kgid(&init_user_ns, gid)); 407 if (pdu_write(pdu, &val, sizeof(val))) 408 errcode = -EFAULT; 409 } break; 410 case 'Q':{ 411 const struct p9_qid *qid = 412 va_arg(ap, const struct p9_qid *); 413 errcode = 414 p9pdu_writef(pdu, proto_version, "bdq", 415 qid->type, qid->version, 416 qid->path); 417 } break; 418 case 'S':{ 419 const struct p9_wstat *stbuf = 420 va_arg(ap, const struct p9_wstat *); 421 errcode = 422 p9pdu_writef(pdu, proto_version, 423 "wwdQdddqssss?sugu", 424 stbuf->size, stbuf->type, 425 stbuf->dev, &stbuf->qid, 426 stbuf->mode, stbuf->atime, 427 stbuf->mtime, stbuf->length, 428 stbuf->name, stbuf->uid, 429 stbuf->gid, stbuf->muid, 430 stbuf->extension, stbuf->n_uid, 431 stbuf->n_gid, stbuf->n_muid); 432 } break; 433 case 'V':{ 434 uint32_t count = va_arg(ap, uint32_t); 435 struct iov_iter *from = 436 va_arg(ap, struct iov_iter *); 437 errcode = p9pdu_writef(pdu, proto_version, "d", 438 count); 439 if (!errcode && pdu_write_u(pdu, from, count)) 440 errcode = -EFAULT; 441 } 442 break; 443 case 'T':{ 444 uint16_t nwname = va_arg(ap, int); 445 const char **wnames = va_arg(ap, const char **); 446 447 errcode = p9pdu_writef(pdu, proto_version, "w", 448 nwname); 449 if (!errcode) { 450 int i; 451 452 for (i = 0; i < nwname; i++) { 453 errcode = 454 p9pdu_writef(pdu, 455 proto_version, 456 "s", 457 wnames[i]); 458 if (errcode) 459 break; 460 } 461 } 462 } 463 break; 464 case 'R':{ 465 uint16_t nwqid = va_arg(ap, int); 466 struct p9_qid *wqids = 467 va_arg(ap, struct p9_qid *); 468 469 errcode = p9pdu_writef(pdu, proto_version, "w", 470 nwqid); 471 if (!errcode) { 472 int i; 473 474 for (i = 0; i < nwqid; i++) { 475 errcode = 476 p9pdu_writef(pdu, 477 proto_version, 478 "Q", 479 &wqids[i]); 480 if (errcode) 481 break; 482 } 483 } 484 } 485 break; 486 case 'I':{ 487 struct p9_iattr_dotl *p9attr = va_arg(ap, 488 struct p9_iattr_dotl *); 489 490 errcode = p9pdu_writef(pdu, proto_version, 491 "ddugqqqqq", 492 p9attr->valid, 493 p9attr->mode, 494 p9attr->uid, 495 p9attr->gid, 496 p9attr->size, 497 p9attr->atime_sec, 498 p9attr->atime_nsec, 499 p9attr->mtime_sec, 500 p9attr->mtime_nsec); 501 } 502 break; 503 case '?': 504 if ((proto_version != p9_proto_2000u) && 505 (proto_version != p9_proto_2000L)) 506 return 0; 507 break; 508 default: 509 BUG(); 510 break; 511 } 512 513 if (errcode) 514 break; 515 } 516 517 return errcode; 518 } 519 520 int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...) 521 { 522 va_list ap; 523 int ret; 524 525 va_start(ap, fmt); 526 ret = p9pdu_vreadf(pdu, proto_version, fmt, ap); 527 va_end(ap); 528 529 return ret; 530 } 531 532 static int 533 p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...) 534 { 535 va_list ap; 536 int ret; 537 538 va_start(ap, fmt); 539 ret = p9pdu_vwritef(pdu, proto_version, fmt, ap); 540 va_end(ap); 541 542 return ret; 543 } 544 545 int p9stat_read(struct p9_client *clnt, char *buf, int len, struct p9_wstat *st) 546 { 547 struct p9_fcall fake_pdu; 548 int ret; 549 550 fake_pdu.size = len; 551 fake_pdu.capacity = len; 552 fake_pdu.sdata = buf; 553 fake_pdu.offset = 0; 554 555 ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "S", st); 556 if (ret) { 557 p9_debug(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret); 558 trace_9p_protocol_dump(clnt, &fake_pdu); 559 return ret; 560 } 561 562 return fake_pdu.offset; 563 } 564 EXPORT_SYMBOL(p9stat_read); 565 566 int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type) 567 { 568 pdu->id = type; 569 return p9pdu_writef(pdu, 0, "dbw", 0, type, tag); 570 } 571 572 int p9pdu_finalize(struct p9_client *clnt, struct p9_fcall *pdu) 573 { 574 int size = pdu->size; 575 int err; 576 577 pdu->size = 0; 578 err = p9pdu_writef(pdu, 0, "d", size); 579 pdu->size = size; 580 581 trace_9p_protocol_dump(clnt, pdu); 582 p9_debug(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n", 583 pdu->size, pdu->id, pdu->tag); 584 585 return err; 586 } 587 588 void p9pdu_reset(struct p9_fcall *pdu) 589 { 590 pdu->offset = 0; 591 pdu->size = 0; 592 } 593 594 int p9dirent_read(struct p9_client *clnt, char *buf, int len, 595 struct p9_dirent *dirent) 596 { 597 struct p9_fcall fake_pdu; 598 int ret; 599 char *nameptr; 600 601 fake_pdu.size = len; 602 fake_pdu.capacity = len; 603 fake_pdu.sdata = buf; 604 fake_pdu.offset = 0; 605 606 ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "Qqbs", &dirent->qid, 607 &dirent->d_off, &dirent->d_type, &nameptr); 608 if (ret) { 609 p9_debug(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret); 610 trace_9p_protocol_dump(clnt, &fake_pdu); 611 return ret; 612 } 613 614 ret = strscpy(dirent->d_name, nameptr, sizeof(dirent->d_name)); 615 if (ret < 0) { 616 p9_debug(P9_DEBUG_ERROR, 617 "On the wire dirent name too long: %s\n", 618 nameptr); 619 kfree(nameptr); 620 return ret; 621 } 622 kfree(nameptr); 623 624 return fake_pdu.offset; 625 } 626 EXPORT_SYMBOL(p9dirent_read); 627