net/9p/protocol.c

   1 /*
   2  * net/9p/protocol.c
   3  *
   4  * 9P Protocol Support Code
   5  *
   6  *  Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
   7  *
   8  *  Base on code from Anthony Liguori <aliguori@us.ibm.com>
   9  *  Copyright (C) 2008 by IBM, Corp.
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License version 2
  13  *  as published by the Free Software Foundation.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to:
  22  *  Free Software Foundation
  23  *  51 Franklin Street, Fifth Floor
  24  *  Boston, MA  02111-1301  USA
  25  *
  26  */
  27
  28 #include <linux/module.h>
  29 #include <linux/errno.h>
  30 #include <linux/uaccess.h>
  31 #include <linux/sched.h>
  32 #include <linux/types.h>
  33 #include <net/9p/9p.h>
  34 #include <net/9p/client.h>
  35 #include "protocol.h"
  36
  37 #ifndef MIN
  38 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
  39 #endif
  40
  41 #ifndef MAX
  42 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
  43 #endif
  44
  45 #ifndef offset_of
  46 #define offset_of(type, memb) \
  47         ((unsigned long)(&((type *)0)->memb))
  48 #endif
  49 #ifndef container_of
  50 #define container_of(obj, type, memb) \
  51         ((type *)(((char *)obj) - offset_of(type, memb)))
  52 #endif
  53
  54 static int
  55 p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...);
  56
  57 #ifdef CONFIG_NET_9P_DEBUG
  58 void
  59 p9pdu_dump(int way, struct p9_fcall *pdu)
  60 {
  61         int i, n;
  62         u8 *data = pdu->sdata;
  63         int datalen = pdu->size;
  64         char buf[255];
  65         int buflen = 255;
  66
  67         i = n = 0;
  68         if (datalen > (buflen-16))
  69                 datalen = buflen-16;
  70         while (i < datalen) {
  71                 n += scnprintf(buf + n, buflen - n, "%02x ", data[i]);
  72                 if (i%4 == 3)
  73                         n += scnprintf(buf + n, buflen - n, " ");
  74                 if (i%32 == 31)
  75                         n += scnprintf(buf + n, buflen - n, "\n");
  76
  77                 i++;
  78         }
  79         n += scnprintf(buf + n, buflen - n, "\n");
  80
  81         if (way)
  82                 P9_DPRINTK(P9_DEBUG_PKT, "[[[(%d) %s\n", datalen, buf);
  83         else
  84                 P9_DPRINTK(P9_DEBUG_PKT, "]]](%d) %s\n", datalen, buf);
  85 }
  86 #else
  87 void
  88 p9pdu_dump(int way, struct p9_fcall *pdu)
  89 {
  90 }
  91 #endif
  92 EXPORT_SYMBOL(p9pdu_dump);
  93
  94 void p9stat_free(struct p9_wstat *stbuf)
  95 {
  96         kfree(stbuf->name);
  97         kfree(stbuf->uid);
  98         kfree(stbuf->gid);
  99         kfree(stbuf->muid);
 100         kfree(stbuf->extension);
 101 }
 102 EXPORT_SYMBOL(p9stat_free);
 103
 104 static size_t pdu_read(struct p9_fcall *pdu, void *data, size_t size)
 105 {
 106         size_t len = MIN(pdu->size - pdu->offset, size);
 107         memcpy(data, &pdu->sdata[pdu->offset], len);
 108         pdu->offset += len;
 109         return size - len;
 110 }
 111
 112 static size_t pdu_write(struct p9_fcall *pdu, const void *data, size_t size)
 113 {
 114         size_t len = MIN(pdu->capacity - pdu->size, size);
 115         memcpy(&pdu->sdata[pdu->size], data, len);
 116         pdu->size += len;
 117         return size - len;
 118 }
 119
 120 static size_t
 121 pdu_write_u(struct p9_fcall *pdu, const char __user *udata, size_t size)
 122 {
 123         size_t len = MIN(pdu->capacity - pdu->size, size);
 124         int err = copy_from_user(&pdu->sdata[pdu->size], udata, len);
 125         if (err)
 126                 printk(KERN_WARNING "pdu_write_u returning: %d\n", err);
 127
 128         pdu->size += len;
 129         return size - len;
 130 }
 131
 132 /*
 133         b - int8_t
 134         w - int16_t
 135         d - int32_t
 136         q - int64_t
 137         s - string
 138         S - stat
 139         Q - qid
 140         D - data blob (int32_t size followed by void *, results are not freed)
 141         T - array of strings (int16_t count, followed by strings)
 142         R - array of qids (int16_t count, followed by qids)
 143         ? - if optional = 1, continue parsing
 144 */
 145
 146 static int
 147 p9pdu_vreadf(struct p9_fcall *pdu, int proto_version, const char *fmt,
 148         va_list ap)
 149 {
 150         const char *ptr;
 151         int errcode = 0;
 152
 153         for (ptr = fmt; *ptr; ptr++) {
 154                 switch (*ptr) {
 155                 case 'b':{
 156                                 int8_t *val = va_arg(ap, int8_t *);
 157                                 if (pdu_read(pdu, val, sizeof(*val))) {
 158                                         errcode = -EFAULT;
 159                                         break;
 160                                 }
 161                         }
 162                         break;
 163                 case 'w':{
 164                                 int16_t *val = va_arg(ap, int16_t *);
 165                                 __le16 le_val;
 166                                 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
 167                                         errcode = -EFAULT;
 168                                         break;
 169                                 }
 170                                 *val = le16_to_cpu(le_val);
 171                         }
 172                         break;
 173                 case 'd':{
 174                                 int32_t *val = va_arg(ap, int32_t *);
 175                                 __le32 le_val;
 176                                 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
 177                                         errcode = -EFAULT;
 178                                         break;
 179                                 }
 180                                 *val = le32_to_cpu(le_val);
 181                         }
 182                         break;
 183                 case 'q':{
 184                                 int64_t *val = va_arg(ap, int64_t *);
 185                                 __le64 le_val;
 186                                 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
 187                                         errcode = -EFAULT;
 188                                         break;
 189                                 }
 190                                 *val = le64_to_cpu(le_val);
 191                         }
 192                         break;
 193                 case 's':{
 194                                 char **sptr = va_arg(ap, char **);
 195                                 int16_t len;
 196                                 int size;
 197
 198                                 errcode = p9pdu_readf(pdu, proto_version,
 199                                                                 "w", &len);
 200                                 if (errcode)
 201                                         break;
 202
 203                                 size = MAX(len, 0);
 204
 205                                 *sptr = kmalloc(size + 1, GFP_KERNEL);
 206                                 if (*sptr == NULL) {
 207                                         errcode = -EFAULT;
 208                                         break;
 209                                 }
 210                                 if (pdu_read(pdu, *sptr, size)) {
 211                                         errcode = -EFAULT;
 212                                         kfree(*sptr);
 213                                         *sptr = NULL;
 214                                 } else
 215                                         (*sptr)[size] = 0;
 216                         }
 217                         break;
 218                 case 'Q':{
 219                                 struct p9_qid *qid =
 220                                     va_arg(ap, struct p9_qid *);
 221
 222                                 errcode = p9pdu_readf(pdu, proto_version, "bdq",
 223                                                       &qid->type, &qid->version,
 224                                                       &qid->path);
 225                         }
 226                         break;
 227                 case 'S':{
 228                                 struct p9_wstat *stbuf =
 229                                     va_arg(ap, struct p9_wstat *);
 230
 231                                 memset(stbuf, 0, sizeof(struct p9_wstat));
 232                                 stbuf->n_uid = stbuf->n_gid = stbuf->n_muid =
 233                                                                         -1;
 234                                 errcode =
 235                                     p9pdu_readf(pdu, proto_version,
 236                                                 "wwdQdddqssss?sddd",
 237                                                 &stbuf->size, &stbuf->type,
 238                                                 &stbuf->dev, &stbuf->qid,
 239                                                 &stbuf->mode, &stbuf->atime,
 240                                                 &stbuf->mtime, &stbuf->length,
 241                                                 &stbuf->name, &stbuf->uid,
 242                                                 &stbuf->gid, &stbuf->muid,
 243                                                 &stbuf->extension,
 244                                                 &stbuf->n_uid, &stbuf->n_gid,
 245                                                 &stbuf->n_muid);
 246                                 if (errcode)
 247                                         p9stat_free(stbuf);
 248                         }
 249                         break;
 250                 case 'D':{
 251                                 int32_t *count = va_arg(ap, int32_t *);
 252                                 void **data = va_arg(ap, void **);
 253
 254                                 errcode =
 255                                     p9pdu_readf(pdu, proto_version, "d", count);
 256                                 if (!errcode) {
 257                                         *count =
 258                                             MIN(*count,
 259                                                 pdu->size - pdu->offset);
 260                                         *data = &pdu->sdata[pdu->offset];
 261                                 }
 262                         }
 263                         break;
 264                 case 'T':{
 265                                 int16_t *nwname = va_arg(ap, int16_t *);
 266                                 char ***wnames = va_arg(ap, char ***);
 267
 268                                 errcode = p9pdu_readf(pdu, proto_version,
 269                                                                 "w", nwname);
 270                                 if (!errcode) {
 271                                         *wnames =
 272                                             kmalloc(sizeof(char *) * *nwname,
 273                                                     GFP_KERNEL);
 274                                         if (!*wnames)
 275                                                 errcode = -ENOMEM;
 276                                 }
 277
 278                                 if (!errcode) {
 279                                         int i;
 280
 281                                         for (i = 0; i < *nwname; i++) {
 282                                                 errcode =
 283                                                     p9pdu_readf(pdu,
 284                                                                 proto_version,
 285                                                                 "s",
 286                                                                 &(*wnames)[i]);
 287                                                 if (errcode)
 288                                                         break;
 289                                         }
 290                                 }
 291
 292                                 if (errcode) {
 293                                         if (*wnames) {
 294                                                 int i;
 295
 296                                                 for (i = 0; i < *nwname; i++)
 297                                                         kfree((*wnames)[i]);
 298                                         }
 299                                         kfree(*wnames);
 300                                         *wnames = NULL;
 301                                 }
 302                         }
 303                         break;
 304                 case 'R':{
 305                                 int16_t *nwqid = va_arg(ap, int16_t *);
 306                                 struct p9_qid **wqids =
 307                                     va_arg(ap, struct p9_qid **);
 308
 309                                 *wqids = NULL;
 310
 311                                 errcode =
 312                                     p9pdu_readf(pdu, proto_version, "w", nwqid);
 313                                 if (!errcode) {
 314                                         *wqids =
 315                                             kmalloc(*nwqid *
 316                                                     sizeof(struct p9_qid),
 317                                                     GFP_KERNEL);
 318                                         if (*wqids == NULL)
 319                                                 errcode = -ENOMEM;
 320                                 }
 321
 322                                 if (!errcode) {
 323                                         int i;
 324
 325                                         for (i = 0; i < *nwqid; i++) {
 326                                                 errcode =
 327                                                     p9pdu_readf(pdu,
 328                                                                 proto_version,
 329                                                                 "Q",
 330                                                                 &(*wqids)[i]);
 331                                                 if (errcode)
 332                                                         break;
 333                                         }
 334                                 }
 335
 336                                 if (errcode) {
 337                                         kfree(*wqids);
 338                                         *wqids = NULL;
 339                                 }
 340                         }
 341                         break;
 342                 case '?':
 343                         if (proto_version != p9_proto_2000u)
 344                                 return 0;
 345                         break;
 346                 default:
 347                         BUG();
 348                         break;
 349                 }
 350
 351                 if (errcode)
 352                         break;
 353         }
 354
 355         return errcode;
 356 }
 357
 358 int
 359 p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt,
 360         va_list ap)
 361 {
 362         const char *ptr;
 363         int errcode = 0;
 364
 365         for (ptr = fmt; *ptr; ptr++) {
 366                 switch (*ptr) {
 367                 case 'b':{
 368                                 int8_t val = va_arg(ap, int);
 369                                 if (pdu_write(pdu, &val, sizeof(val)))
 370                                         errcode = -EFAULT;
 371                         }
 372                         break;
 373                 case 'w':{
 374                                 __le16 val = cpu_to_le16(va_arg(ap, int));
 375                                 if (pdu_write(pdu, &val, sizeof(val)))
 376                                         errcode = -EFAULT;
 377                         }
 378                         break;
 379                 case 'd':{
 380                                 __le32 val = cpu_to_le32(va_arg(ap, int32_t));
 381                                 if (pdu_write(pdu, &val, sizeof(val)))
 382                                         errcode = -EFAULT;
 383                         }
 384                         break;
 385                 case 'q':{
 386                                 __le64 val = cpu_to_le64(va_arg(ap, int64_t));
 387                                 if (pdu_write(pdu, &val, sizeof(val)))
 388                                         errcode = -EFAULT;
 389                         }
 390                         break;
 391                 case 's':{
 392                                 const char *sptr = va_arg(ap, const char *);
 393                                 int16_t len = 0;
 394                                 if (sptr)
 395                                         len = MIN(strlen(sptr), USHORT_MAX);
 396
 397                                 errcode = p9pdu_writef(pdu, proto_version,
 398                                                                 "w", len);
 399                                 if (!errcode && pdu_write(pdu, sptr, len))
 400                                         errcode = -EFAULT;
 401                         }
 402                         break;
 403                 case 'Q':{
 404                                 const struct p9_qid *qid =
 405                                     va_arg(ap, const struct p9_qid *);
 406                                 errcode =
 407                                     p9pdu_writef(pdu, proto_version, "bdq",
 408                                                  qid->type, qid->version,
 409                                                  qid->path);
 410                         } break;
 411                 case 'S':{
 412                                 const struct p9_wstat *stbuf =
 413                                     va_arg(ap, const struct p9_wstat *);
 414                                 errcode =
 415                                     p9pdu_writef(pdu, proto_version,
 416                                                  "wwdQdddqssss?sddd",
 417                                                  stbuf->size, stbuf->type,
 418                                                  stbuf->dev, &stbuf->qid,
 419                                                  stbuf->mode, stbuf->atime,
 420                                                  stbuf->mtime, stbuf->length,
 421                                                  stbuf->name, stbuf->uid,
 422                                                  stbuf->gid, stbuf->muid,
 423                                                  stbuf->extension, stbuf->n_uid,
 424                                                  stbuf->n_gid, stbuf->n_muid);
 425                         } break;
 426                 case 'D':{
 427                                 int32_t count = va_arg(ap, int32_t);
 428                                 const void *data = va_arg(ap, const void *);
 429
 430                                 errcode = p9pdu_writef(pdu, proto_version, "d",
 431                                                                         count);
 432                                 if (!errcode && pdu_write(pdu, data, count))
 433                                         errcode = -EFAULT;
 434                         }
 435                         break;
 436                 case 'U':{
 437                                 int32_t count = va_arg(ap, int32_t);
 438                                 const char __user *udata =
 439                                                 va_arg(ap, const void __user *);
 440                                 errcode = p9pdu_writef(pdu, proto_version, "d",
 441                                                                         count);
 442                                 if (!errcode && pdu_write_u(pdu, udata, count))
 443                                         errcode = -EFAULT;
 444                         }
 445                         break;
 446                 case 'T':{
 447                                 int16_t nwname = va_arg(ap, int);
 448                                 const char **wnames = va_arg(ap, const char **);
 449
 450                                 errcode = p9pdu_writef(pdu, proto_version, "w",
 451                                                                         nwname);
 452                                 if (!errcode) {
 453                                         int i;
 454
 455                                         for (i = 0; i < nwname; i++) {
 456                                                 errcode =
 457                                                     p9pdu_writef(pdu,
 458                                                                 proto_version,
 459                                                                  "s",
 460                                                                  wnames[i]);
 461                                                 if (errcode)
 462                                                         break;
 463                                         }
 464                                 }
 465                         }
 466                         break;
 467                 case 'R':{
 468                                 int16_t nwqid = va_arg(ap, int);
 469                                 struct p9_qid *wqids =
 470                                     va_arg(ap, struct p9_qid *);
 471
 472                                 errcode = p9pdu_writef(pdu, proto_version, "w",
 473                                                                         nwqid);
 474                                 if (!errcode) {
 475                                         int i;
 476
 477                                         for (i = 0; i < nwqid; i++) {
 478                                                 errcode =
 479                                                     p9pdu_writef(pdu,
 480                                                                 proto_version,
 481                                                                  "Q",
 482                                                                  &wqids[i]);
 483                                                 if (errcode)
 484                                                         break;
 485                                         }
 486                                 }
 487                         }
 488                         break;
 489                 case '?':
 490                         if (proto_version != p9_proto_2000u)
 491                                 return 0;
 492                         break;
 493                 default:
 494                         BUG();
 495                         break;
 496                 }
 497
 498                 if (errcode)
 499                         break;
 500         }
 501
 502         return errcode;
 503 }
 504
 505 int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
 506 {
 507         va_list ap;
 508         int ret;
 509
 510         va_start(ap, fmt);
 511         ret = p9pdu_vreadf(pdu, proto_version, fmt, ap);
 512         va_end(ap);
 513
 514         return ret;
 515 }
 516
 517 static int
 518 p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
 519 {
 520         va_list ap;
 521         int ret;
 522
 523         va_start(ap, fmt);
 524         ret = p9pdu_vwritef(pdu, proto_version, fmt, ap);
 525         va_end(ap);
 526
 527         return ret;
 528 }
 529
 530 int p9stat_read(char *buf, int len, struct p9_wstat *st, int proto_version)
 531 {
 532         struct p9_fcall fake_pdu;
 533         int ret;
 534
 535         fake_pdu.size = len;
 536         fake_pdu.capacity = len;
 537         fake_pdu.sdata = buf;
 538         fake_pdu.offset = 0;
 539
 540         ret = p9pdu_readf(&fake_pdu, proto_version, "S", st);
 541         if (ret) {
 542                 P9_DPRINTK(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
 543                 p9pdu_dump(1, &fake_pdu);
 544         }
 545
 546         return ret;
 547 }
 548 EXPORT_SYMBOL(p9stat_read);
 549
 550 int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type)
 551 {
 552         return p9pdu_writef(pdu, 0, "dbw", 0, type, tag);
 553 }
 554
 555 int p9pdu_finalize(struct p9_fcall *pdu)
 556 {
 557         int size = pdu->size;
 558         int err;
 559
 560         pdu->size = 0;
 561         err = p9pdu_writef(pdu, 0, "d", size);
 562         pdu->size = size;
 563
 564 #ifdef CONFIG_NET_9P_DEBUG
 565         if ((p9_debug_level & P9_DEBUG_PKT) == P9_DEBUG_PKT)
 566                 p9pdu_dump(0, pdu);
 567 #endif
 568
 569         P9_DPRINTK(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n", pdu->size,
 570                                                         pdu->id, pdu->tag);
 571
 572         return err;
 573 }
 574
 575 void p9pdu_reset(struct p9_fcall *pdu)
 576 {
 577         pdu->offset = 0;
 578         pdu->size = 0;
 579 }