hw/9pfs/9p-synth.c

   1 /*
   2  * Virtio 9p synthetic file system support
   3  *
   4  * Copyright IBM, Corp. 2011
   5  *
   6  * Authors:
   7  *  Malahal Naineni <malahal@us.ibm.com>
   8  *  Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
   9  *
  10  * This work is licensed under the terms of the GNU GPL, version 2.  See
  11  * the COPYING file in the top-level directory.
  12  *
  13  */
  14
  15 #include "qemu/osdep.h"
  16 #include "hw/virtio/virtio.h"
  17 #include "9p.h"
  18 #include "9p-xattr.h"
  19 #include "fsdev/qemu-fsdev.h"
  20 #include "9p-synth.h"
  21 #include "qemu/rcu.h"
  22 #include "qemu/rcu_queue.h"
  23 #include "qemu/cutils.h"
  24
  25 /* Root node for synth file system */
  26 static V9fsSynthNode v9fs_synth_root = {
  27     .name = "/",
  28     .actual_attr = {
  29         .mode = 0555 | S_IFDIR,
  30         .nlink = 1,
  31     },
  32     .attr = &v9fs_synth_root.actual_attr,
  33 };
  34
  35 static QemuMutex  v9fs_synth_mutex;
  36 static int v9fs_synth_node_count;
  37 /* set to 1 when the synth fs is ready */
  38 static int v9fs_synth_fs;
  39
  40 static V9fsSynthNode *v9fs_add_dir_node(V9fsSynthNode *parent, int mode,
  41                                         const char *name,
  42                                         V9fsSynthNodeAttr *attr, int inode)
  43 {
  44     V9fsSynthNode *node;
  45
  46     /* Add directory type and remove write bits */
  47     mode = ((mode & 0777) | S_IFDIR) & ~(S_IWUSR | S_IWGRP | S_IWOTH);
  48     node = g_malloc0(sizeof(V9fsSynthNode));
  49     if (attr) {
  50         /* We are adding .. or . entries */
  51         node->attr = attr;
  52         node->attr->nlink++;
  53     } else {
  54         node->attr = &node->actual_attr;
  55         node->attr->inode = inode;
  56         node->attr->nlink = 1;
  57         /* We don't allow write to directories */
  58         node->attr->mode   = mode;
  59         node->attr->write = NULL;
  60         node->attr->read  = NULL;
  61     }
  62     node->private = node;
  63     pstrcpy(node->name, sizeof(node->name), name);
  64     QLIST_INSERT_HEAD_RCU(&parent->child, node, sibling);
  65     return node;
  66 }
  67
  68 int qemu_v9fs_synth_mkdir(V9fsSynthNode *parent, int mode,
  69                           const char *name, V9fsSynthNode **result)
  70 {
  71     int ret;
  72     V9fsSynthNode *node, *tmp;
  73
  74     if (!v9fs_synth_fs) {
  75         return EAGAIN;
  76     }
  77     if (!name || (strlen(name) >= NAME_MAX)) {
  78         return EINVAL;
  79     }
  80     if (!parent) {
  81         parent = &v9fs_synth_root;
  82     }
  83     qemu_mutex_lock(&v9fs_synth_mutex);
  84     QLIST_FOREACH(tmp, &parent->child, sibling) {
  85         if (!strcmp(tmp->name, name)) {
  86             ret = EEXIST;
  87             goto err_out;
  88         }
  89     }
  90     /* Add the name */
  91     node = v9fs_add_dir_node(parent, mode, name, NULL, v9fs_synth_node_count++);
  92     v9fs_add_dir_node(node, parent->attr->mode, "..",
  93                       parent->attr, parent->attr->inode);
  94     v9fs_add_dir_node(node, node->attr->mode, ".",
  95                       node->attr, node->attr->inode);
  96     *result = node;
  97     ret = 0;
  98 err_out:
  99     qemu_mutex_unlock(&v9fs_synth_mutex);
 100     return ret;
 101 }
 102
 103 int qemu_v9fs_synth_add_file(V9fsSynthNode *parent, int mode,
 104                              const char *name, v9fs_synth_read read,
 105                              v9fs_synth_write write, void *arg)
 106 {
 107     int ret;
 108     V9fsSynthNode *node, *tmp;
 109
 110     if (!v9fs_synth_fs) {
 111         return EAGAIN;
 112     }
 113     if (!name || (strlen(name) >= NAME_MAX)) {
 114         return EINVAL;
 115     }
 116     if (!parent) {
 117         parent = &v9fs_synth_root;
 118     }
 119
 120     qemu_mutex_lock(&v9fs_synth_mutex);
 121     QLIST_FOREACH(tmp, &parent->child, sibling) {
 122         if (!strcmp(tmp->name, name)) {
 123             ret = EEXIST;
 124             goto err_out;
 125         }
 126     }
 127     /* Add file type and remove write bits */
 128     mode = ((mode & 0777) | S_IFREG);
 129     node = g_malloc0(sizeof(V9fsSynthNode));
 130     node->attr         = &node->actual_attr;
 131     node->attr->inode  = v9fs_synth_node_count++;
 132     node->attr->nlink  = 1;
 133     node->attr->read   = read;
 134     node->attr->write  = write;
 135     node->attr->mode   = mode;
 136     node->private      = arg;
 137     pstrcpy(node->name, sizeof(node->name), name);
 138     QLIST_INSERT_HEAD_RCU(&parent->child, node, sibling);
 139     ret = 0;
 140 err_out:
 141     qemu_mutex_unlock(&v9fs_synth_mutex);
 142     return ret;
 143 }
 144
 145 static void v9fs_synth_fill_statbuf(V9fsSynthNode *node, struct stat *stbuf)
 146 {
 147     stbuf->st_dev = 0;
 148     stbuf->st_ino = node->attr->inode;
 149     stbuf->st_mode = node->attr->mode;
 150     stbuf->st_nlink = node->attr->nlink;
 151     stbuf->st_uid = 0;
 152     stbuf->st_gid = 0;
 153     stbuf->st_rdev = 0;
 154     stbuf->st_size = 0;
 155     stbuf->st_blksize = 0;
 156     stbuf->st_blocks = 0;
 157     stbuf->st_atime = 0;
 158     stbuf->st_mtime = 0;
 159     stbuf->st_ctime = 0;
 160 }
 161
 162 static int v9fs_synth_lstat(FsContext *fs_ctx,
 163                             V9fsPath *fs_path, struct stat *stbuf)
 164 {
 165     V9fsSynthNode *node = *(V9fsSynthNode **)fs_path->data;
 166
 167     v9fs_synth_fill_statbuf(node, stbuf);
 168     return 0;
 169 }
 170
 171 static int v9fs_synth_fstat(FsContext *fs_ctx, int fid_type,
 172                             V9fsFidOpenState *fs, struct stat *stbuf)
 173 {
 174     V9fsSynthOpenState *synth_open = fs->private;
 175     v9fs_synth_fill_statbuf(synth_open->node, stbuf);
 176     return 0;
 177 }
 178
 179 static int v9fs_synth_opendir(FsContext *ctx,
 180                              V9fsPath *fs_path, V9fsFidOpenState *fs)
 181 {
 182     V9fsSynthOpenState *synth_open;
 183     V9fsSynthNode *node = *(V9fsSynthNode **)fs_path->data;
 184
 185     synth_open = g_malloc(sizeof(*synth_open));
 186     synth_open->node = node;
 187     node->open_count++;
 188     fs->private = synth_open;
 189     return 0;
 190 }
 191
 192 static int v9fs_synth_closedir(FsContext *ctx, V9fsFidOpenState *fs)
 193 {
 194     V9fsSynthOpenState *synth_open = fs->private;
 195     V9fsSynthNode *node = synth_open->node;
 196
 197     node->open_count--;
 198     g_free(synth_open);
 199     fs->private = NULL;
 200     return 0;
 201 }
 202
 203 static off_t v9fs_synth_telldir(FsContext *ctx, V9fsFidOpenState *fs)
 204 {
 205     V9fsSynthOpenState *synth_open = fs->private;
 206     return synth_open->offset;
 207 }
 208
 209 static void v9fs_synth_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
 210 {
 211     V9fsSynthOpenState *synth_open = fs->private;
 212     synth_open->offset = off;
 213 }
 214
 215 static void v9fs_synth_rewinddir(FsContext *ctx, V9fsFidOpenState *fs)
 216 {
 217     v9fs_synth_seekdir(ctx, fs, 0);
 218 }
 219
 220 static void v9fs_synth_direntry(V9fsSynthNode *node,
 221                                 struct dirent *entry, off_t off)
 222 {
 223     strcpy(entry->d_name, node->name);
 224     entry->d_ino = node->attr->inode;
 225     entry->d_off = off + 1;
 226 }
 227
 228 static int v9fs_synth_get_dentry(V9fsSynthNode *dir, struct dirent *entry,
 229                                  struct dirent **result, off_t off)
 230 {
 231     int i = 0;
 232     V9fsSynthNode *node;
 233
 234     rcu_read_lock();
 235     QLIST_FOREACH(node, &dir->child, sibling) {
 236         /* This is the off child of the directory */
 237         if (i == off) {
 238             break;
 239         }
 240         i++;
 241     }
 242     rcu_read_unlock();
 243     if (!node) {
 244         /* end of directory */
 245         *result = NULL;
 246         return 0;
 247     }
 248     v9fs_synth_direntry(node, entry, off);
 249     *result = entry;
 250     return 0;
 251 }
 252
 253 static int v9fs_synth_readdir_r(FsContext *ctx, V9fsFidOpenState *fs,
 254                                 struct dirent *entry, struct dirent **result)
 255 {
 256     int ret;
 257     V9fsSynthOpenState *synth_open = fs->private;
 258     V9fsSynthNode *node = synth_open->node;
 259     ret = v9fs_synth_get_dentry(node, entry, result, synth_open->offset);
 260     if (!ret && *result != NULL) {
 261         synth_open->offset++;
 262     }
 263     return ret;
 264 }
 265
 266 static int v9fs_synth_open(FsContext *ctx, V9fsPath *fs_path,
 267                            int flags, V9fsFidOpenState *fs)
 268 {
 269     V9fsSynthOpenState *synth_open;
 270     V9fsSynthNode *node = *(V9fsSynthNode **)fs_path->data;
 271
 272     synth_open = g_malloc(sizeof(*synth_open));
 273     synth_open->node = node;
 274     node->open_count++;
 275     fs->private = synth_open;
 276     return 0;
 277 }
 278
 279 static int v9fs_synth_open2(FsContext *fs_ctx, V9fsPath *dir_path,
 280                             const char *name, int flags,
 281                             FsCred *credp, V9fsFidOpenState *fs)
 282 {
 283     errno = ENOSYS;
 284     return -1;
 285 }
 286
 287 static int v9fs_synth_close(FsContext *ctx, V9fsFidOpenState *fs)
 288 {
 289     V9fsSynthOpenState *synth_open = fs->private;
 290     V9fsSynthNode *node = synth_open->node;
 291
 292     node->open_count--;
 293     g_free(synth_open);
 294     fs->private = NULL;
 295     return 0;
 296 }
 297
 298 static ssize_t v9fs_synth_pwritev(FsContext *ctx, V9fsFidOpenState *fs,
 299                                   const struct iovec *iov,
 300                                   int iovcnt, off_t offset)
 301 {
 302     int i, count = 0, wcount;
 303     V9fsSynthOpenState *synth_open = fs->private;
 304     V9fsSynthNode *node = synth_open->node;
 305     if (!node->attr->write) {
 306         errno = EPERM;
 307         return -1;
 308     }
 309     for (i = 0; i < iovcnt; i++) {
 310         wcount = node->attr->write(iov[i].iov_base, iov[i].iov_len,
 311                                    offset, node->private);
 312         offset += wcount;
 313         count  += wcount;
 314         /* If we wrote less than requested. we are done */
 315         if (wcount < iov[i].iov_len) {
 316             break;
 317         }
 318     }
 319     return count;
 320 }
 321
 322 static ssize_t v9fs_synth_preadv(FsContext *ctx, V9fsFidOpenState *fs,
 323                                  const struct iovec *iov,
 324                                  int iovcnt, off_t offset)
 325 {
 326     int i, count = 0, rcount;
 327     V9fsSynthOpenState *synth_open = fs->private;
 328     V9fsSynthNode *node = synth_open->node;
 329     if (!node->attr->read) {
 330         errno = EPERM;
 331         return -1;
 332     }
 333     for (i = 0; i < iovcnt; i++) {
 334         rcount = node->attr->read(iov[i].iov_base, iov[i].iov_len,
 335                                   offset, node->private);
 336         offset += rcount;
 337         count  += rcount;
 338         /* If we read less than requested. we are done */
 339         if (rcount < iov[i].iov_len) {
 340             break;
 341         }
 342     }
 343     return count;
 344 }
 345
 346 static int v9fs_synth_truncate(FsContext *ctx, V9fsPath *path, off_t offset)
 347 {
 348     errno = ENOSYS;
 349     return -1;
 350 }
 351
 352 static int v9fs_synth_chmod(FsContext *fs_ctx, V9fsPath *path, FsCred *credp)
 353 {
 354     errno = EPERM;
 355     return -1;
 356 }
 357
 358 static int v9fs_synth_mknod(FsContext *fs_ctx, V9fsPath *path,
 359                        const char *buf, FsCred *credp)
 360 {
 361     errno = EPERM;
 362     return -1;
 363 }
 364
 365 static int v9fs_synth_mkdir(FsContext *fs_ctx, V9fsPath *path,
 366                        const char *buf, FsCred *credp)
 367 {
 368     errno = EPERM;
 369     return -1;
 370 }
 371
 372 static ssize_t v9fs_synth_readlink(FsContext *fs_ctx, V9fsPath *path,
 373                                    char *buf, size_t bufsz)
 374 {
 375     errno = ENOSYS;
 376     return -1;
 377 }
 378
 379 static int v9fs_synth_symlink(FsContext *fs_ctx, const char *oldpath,
 380                               V9fsPath *newpath, const char *buf, FsCred *credp)
 381 {
 382     errno = EPERM;
 383     return -1;
 384 }
 385
 386 static int v9fs_synth_link(FsContext *fs_ctx, V9fsPath *oldpath,
 387                            V9fsPath *newpath, const char *buf)
 388 {
 389     errno = EPERM;
 390     return -1;
 391 }
 392
 393 static int v9fs_synth_rename(FsContext *ctx, const char *oldpath,
 394                              const char *newpath)
 395 {
 396     errno = EPERM;
 397     return -1;
 398 }
 399
 400 static int v9fs_synth_chown(FsContext *fs_ctx, V9fsPath *path, FsCred *credp)
 401 {
 402     errno = EPERM;
 403     return -1;
 404 }
 405
 406 static int v9fs_synth_utimensat(FsContext *fs_ctx, V9fsPath *path,
 407                                 const struct timespec *buf)
 408 {
 409     errno = EPERM;
 410     return 0;
 411 }
 412
 413 static int v9fs_synth_remove(FsContext *ctx, const char *path)
 414 {
 415     errno = EPERM;
 416     return -1;
 417 }
 418
 419 static int v9fs_synth_fsync(FsContext *ctx, int fid_type,
 420                             V9fsFidOpenState *fs, int datasync)
 421 {
 422     errno = ENOSYS;
 423     return 0;
 424 }
 425
 426 static int v9fs_synth_statfs(FsContext *s, V9fsPath *fs_path,
 427                              struct statfs *stbuf)
 428 {
 429     stbuf->f_type = 0xABCD;
 430     stbuf->f_bsize = 512;
 431     stbuf->f_blocks = 0;
 432     stbuf->f_files = v9fs_synth_node_count;
 433     stbuf->f_namelen = NAME_MAX;
 434     return 0;
 435 }
 436
 437 static ssize_t v9fs_synth_lgetxattr(FsContext *ctx, V9fsPath *path,
 438                                     const char *name, void *value, size_t size)
 439 {
 440     errno = ENOTSUP;
 441     return -1;
 442 }
 443
 444 static ssize_t v9fs_synth_llistxattr(FsContext *ctx, V9fsPath *path,
 445                                      void *value, size_t size)
 446 {
 447     errno = ENOTSUP;
 448     return -1;
 449 }
 450
 451 static int v9fs_synth_lsetxattr(FsContext *ctx, V9fsPath *path,
 452                                 const char *name, void *value,
 453                                 size_t size, int flags)
 454 {
 455     errno = ENOTSUP;
 456     return -1;
 457 }
 458
 459 static int v9fs_synth_lremovexattr(FsContext *ctx,
 460                                    V9fsPath *path, const char *name)
 461 {
 462     errno = ENOTSUP;
 463     return -1;
 464 }
 465
 466 static int v9fs_synth_name_to_path(FsContext *ctx, V9fsPath *dir_path,
 467                                    const char *name, V9fsPath *target)
 468 {
 469     V9fsSynthNode *node;
 470     V9fsSynthNode *dir_node;
 471
 472     /* "." and ".." are not allowed */
 473     if (!strcmp(name, ".") || !strcmp(name, "..")) {
 474         errno = EINVAL;
 475         return -1;
 476
 477     }
 478     if (!dir_path) {
 479         dir_node = &v9fs_synth_root;
 480     } else {
 481         dir_node = *(V9fsSynthNode **)dir_path->data;
 482     }
 483     if (!strcmp(name, "/")) {
 484         node = dir_node;
 485         goto out;
 486     }
 487     /* search for the name in the childern */
 488     rcu_read_lock();
 489     QLIST_FOREACH(node, &dir_node->child, sibling) {
 490         if (!strcmp(node->name, name)) {
 491             break;
 492         }
 493     }
 494     rcu_read_unlock();
 495
 496     if (!node) {
 497         errno = ENOENT;
 498         return -1;
 499     }
 500 out:
 501     /* Copy the node pointer to fid */
 502     target->data = g_malloc(sizeof(void *));
 503     memcpy(target->data, &node, sizeof(void *));
 504     target->size = sizeof(void *);
 505     return 0;
 506 }
 507
 508 static int v9fs_synth_renameat(FsContext *ctx, V9fsPath *olddir,
 509                                const char *old_name, V9fsPath *newdir,
 510                                const char *new_name)
 511 {
 512     errno = EPERM;
 513     return -1;
 514 }
 515
 516 static int v9fs_synth_unlinkat(FsContext *ctx, V9fsPath *dir,
 517                                const char *name, int flags)
 518 {
 519     errno = EPERM;
 520     return -1;
 521 }
 522
 523 static int v9fs_synth_init(FsContext *ctx)
 524 {
 525     QLIST_INIT(&v9fs_synth_root.child);
 526     qemu_mutex_init(&v9fs_synth_mutex);
 527
 528     /* Add "." and ".." entries for root */
 529     v9fs_add_dir_node(&v9fs_synth_root, v9fs_synth_root.attr->mode,
 530                       "..", v9fs_synth_root.attr, v9fs_synth_root.attr->inode);
 531     v9fs_add_dir_node(&v9fs_synth_root, v9fs_synth_root.attr->mode,
 532                       ".", v9fs_synth_root.attr, v9fs_synth_root.attr->inode);
 533
 534     /* Mark the subsystem is ready for use */
 535     v9fs_synth_fs = 1;
 536     return 0;
 537 }
 538
 539 FileOperations synth_ops = {
 540     .init         = v9fs_synth_init,
 541     .lstat        = v9fs_synth_lstat,
 542     .readlink     = v9fs_synth_readlink,
 543     .close        = v9fs_synth_close,
 544     .closedir     = v9fs_synth_closedir,
 545     .open         = v9fs_synth_open,
 546     .opendir      = v9fs_synth_opendir,
 547     .rewinddir    = v9fs_synth_rewinddir,
 548     .telldir      = v9fs_synth_telldir,
 549     .readdir_r    = v9fs_synth_readdir_r,
 550     .seekdir      = v9fs_synth_seekdir,
 551     .preadv       = v9fs_synth_preadv,
 552     .pwritev      = v9fs_synth_pwritev,
 553     .chmod        = v9fs_synth_chmod,
 554     .mknod        = v9fs_synth_mknod,
 555     .mkdir        = v9fs_synth_mkdir,
 556     .fstat        = v9fs_synth_fstat,
 557     .open2        = v9fs_synth_open2,
 558     .symlink      = v9fs_synth_symlink,
 559     .link         = v9fs_synth_link,
 560     .truncate     = v9fs_synth_truncate,
 561     .rename       = v9fs_synth_rename,
 562     .chown        = v9fs_synth_chown,
 563     .utimensat    = v9fs_synth_utimensat,
 564     .remove       = v9fs_synth_remove,
 565     .fsync        = v9fs_synth_fsync,
 566     .statfs       = v9fs_synth_statfs,
 567     .lgetxattr    = v9fs_synth_lgetxattr,
 568     .llistxattr   = v9fs_synth_llistxattr,
 569     .lsetxattr    = v9fs_synth_lsetxattr,
 570     .lremovexattr = v9fs_synth_lremovexattr,
 571     .name_to_path = v9fs_synth_name_to_path,
 572     .renameat     = v9fs_synth_renameat,
 573     .unlinkat     = v9fs_synth_unlinkat,
 574 };