Update version for v6.2.0-rc3 release
[qemu.git] / hw / 9pfs / 9p-synth.c
1 /*
2 * 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 "9p.h"
17 #include "fsdev/qemu-fsdev.h"
18 #include "9p-synth.h"
19 #include "qemu/rcu.h"
20 #include "qemu/rcu_queue.h"
21 #include "qemu/cutils.h"
22 #include "sysemu/qtest.h"
23
24 /* Root node for synth file system */
25 static V9fsSynthNode synth_root = {
26 .name = "/",
27 .actual_attr = {
28 .mode = 0555 | S_IFDIR,
29 .nlink = 1,
30 },
31 .attr = &synth_root.actual_attr,
32 };
33
34 static QemuMutex synth_mutex;
35 static int synth_node_count;
36 /* set to 1 when the synth fs is ready */
37 static int synth_fs;
38
39 static V9fsSynthNode *v9fs_add_dir_node(V9fsSynthNode *parent, int mode,
40 const char *name,
41 V9fsSynthNodeAttr *attr, int inode)
42 {
43 V9fsSynthNode *node;
44
45 /* Add directory type and remove write bits */
46 mode = ((mode & 0777) | S_IFDIR) & ~(S_IWUSR | S_IWGRP | S_IWOTH);
47 node = g_malloc0(sizeof(V9fsSynthNode));
48 if (attr) {
49 /* We are adding .. or . entries */
50 node->attr = attr;
51 node->attr->nlink++;
52 } else {
53 node->attr = &node->actual_attr;
54 node->attr->inode = inode;
55 node->attr->nlink = 1;
56 /* We don't allow write to directories */
57 node->attr->mode = mode;
58 node->attr->write = NULL;
59 node->attr->read = NULL;
60 }
61 node->private = node;
62 pstrcpy(node->name, sizeof(node->name), name);
63 QLIST_INSERT_HEAD_RCU(&parent->child, node, sibling);
64 return node;
65 }
66
67 int qemu_v9fs_synth_mkdir(V9fsSynthNode *parent, int mode,
68 const char *name, V9fsSynthNode **result)
69 {
70 int ret;
71 V9fsSynthNode *node, *tmp;
72
73 if (!synth_fs) {
74 return EAGAIN;
75 }
76 if (!name || (strlen(name) >= NAME_MAX)) {
77 return EINVAL;
78 }
79 if (!parent) {
80 parent = &synth_root;
81 }
82 QEMU_LOCK_GUARD(&synth_mutex);
83 QLIST_FOREACH(tmp, &parent->child, sibling) {
84 if (!strcmp(tmp->name, name)) {
85 ret = EEXIST;
86 return ret;
87 }
88 }
89 /* Add the name */
90 node = v9fs_add_dir_node(parent, mode, name, NULL, synth_node_count++);
91 v9fs_add_dir_node(node, parent->attr->mode, "..",
92 parent->attr, parent->attr->inode);
93 v9fs_add_dir_node(node, node->attr->mode, ".",
94 node->attr, node->attr->inode);
95 *result = node;
96 ret = 0;
97 return ret;
98 }
99
100 int qemu_v9fs_synth_add_file(V9fsSynthNode *parent, int mode,
101 const char *name, v9fs_synth_read read,
102 v9fs_synth_write write, void *arg)
103 {
104 int ret;
105 V9fsSynthNode *node, *tmp;
106
107 if (!synth_fs) {
108 return EAGAIN;
109 }
110 if (!name || (strlen(name) >= NAME_MAX)) {
111 return EINVAL;
112 }
113 if (!parent) {
114 parent = &synth_root;
115 }
116
117 QEMU_LOCK_GUARD(&synth_mutex);
118 QLIST_FOREACH(tmp, &parent->child, sibling) {
119 if (!strcmp(tmp->name, name)) {
120 ret = EEXIST;
121 return ret;
122 }
123 }
124 /* Add file type and remove write bits */
125 mode = ((mode & 0777) | S_IFREG);
126 node = g_malloc0(sizeof(V9fsSynthNode));
127 node->attr = &node->actual_attr;
128 node->attr->inode = synth_node_count++;
129 node->attr->nlink = 1;
130 node->attr->read = read;
131 node->attr->write = write;
132 node->attr->mode = mode;
133 node->private = arg;
134 pstrcpy(node->name, sizeof(node->name), name);
135 QLIST_INSERT_HEAD_RCU(&parent->child, node, sibling);
136 ret = 0;
137 return ret;
138 }
139
140 static void synth_fill_statbuf(V9fsSynthNode *node, struct stat *stbuf)
141 {
142 stbuf->st_dev = 0;
143 stbuf->st_ino = node->attr->inode;
144 stbuf->st_mode = node->attr->mode;
145 stbuf->st_nlink = node->attr->nlink;
146 stbuf->st_uid = 0;
147 stbuf->st_gid = 0;
148 stbuf->st_rdev = 0;
149 stbuf->st_size = 0;
150 stbuf->st_blksize = 0;
151 stbuf->st_blocks = 0;
152 stbuf->st_atime = 0;
153 stbuf->st_mtime = 0;
154 stbuf->st_ctime = 0;
155 }
156
157 static int synth_lstat(FsContext *fs_ctx,
158 V9fsPath *fs_path, struct stat *stbuf)
159 {
160 V9fsSynthNode *node = *(V9fsSynthNode **)fs_path->data;
161
162 synth_fill_statbuf(node, stbuf);
163 return 0;
164 }
165
166 static int synth_fstat(FsContext *fs_ctx, int fid_type,
167 V9fsFidOpenState *fs, struct stat *stbuf)
168 {
169 V9fsSynthOpenState *synth_open = fs->private;
170 synth_fill_statbuf(synth_open->node, stbuf);
171 return 0;
172 }
173
174 static int synth_opendir(FsContext *ctx,
175 V9fsPath *fs_path, V9fsFidOpenState *fs)
176 {
177 V9fsSynthOpenState *synth_open;
178 V9fsSynthNode *node = *(V9fsSynthNode **)fs_path->data;
179
180 synth_open = g_malloc(sizeof(*synth_open));
181 synth_open->node = node;
182 node->open_count++;
183 fs->private = synth_open;
184 return 0;
185 }
186
187 static int synth_closedir(FsContext *ctx, V9fsFidOpenState *fs)
188 {
189 V9fsSynthOpenState *synth_open = fs->private;
190 V9fsSynthNode *node = synth_open->node;
191
192 node->open_count--;
193 g_free(synth_open);
194 fs->private = NULL;
195 return 0;
196 }
197
198 static off_t synth_telldir(FsContext *ctx, V9fsFidOpenState *fs)
199 {
200 V9fsSynthOpenState *synth_open = fs->private;
201 return synth_open->offset;
202 }
203
204 static void synth_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
205 {
206 V9fsSynthOpenState *synth_open = fs->private;
207 synth_open->offset = off;
208 }
209
210 static void synth_rewinddir(FsContext *ctx, V9fsFidOpenState *fs)
211 {
212 synth_seekdir(ctx, fs, 0);
213 }
214
215 static void synth_direntry(V9fsSynthNode *node,
216 struct dirent *entry, off_t off)
217 {
218 strcpy(entry->d_name, node->name);
219 entry->d_ino = node->attr->inode;
220 entry->d_off = off + 1;
221 }
222
223 static struct dirent *synth_get_dentry(V9fsSynthNode *dir,
224 struct dirent *entry, off_t off)
225 {
226 int i = 0;
227 V9fsSynthNode *node;
228
229 rcu_read_lock();
230 QLIST_FOREACH(node, &dir->child, sibling) {
231 /* This is the off child of the directory */
232 if (i == off) {
233 break;
234 }
235 i++;
236 }
237 rcu_read_unlock();
238 if (!node) {
239 /* end of directory */
240 return NULL;
241 }
242 synth_direntry(node, entry, off);
243 return entry;
244 }
245
246 static struct dirent *synth_readdir(FsContext *ctx, V9fsFidOpenState *fs)
247 {
248 struct dirent *entry;
249 V9fsSynthOpenState *synth_open = fs->private;
250 V9fsSynthNode *node = synth_open->node;
251 entry = synth_get_dentry(node, &synth_open->dent, synth_open->offset);
252 if (entry) {
253 synth_open->offset++;
254 }
255 return entry;
256 }
257
258 static int synth_open(FsContext *ctx, V9fsPath *fs_path,
259 int flags, V9fsFidOpenState *fs)
260 {
261 V9fsSynthOpenState *synth_open;
262 V9fsSynthNode *node = *(V9fsSynthNode **)fs_path->data;
263
264 synth_open = g_malloc(sizeof(*synth_open));
265 synth_open->node = node;
266 node->open_count++;
267 fs->private = synth_open;
268 return 0;
269 }
270
271 static int synth_open2(FsContext *fs_ctx, V9fsPath *dir_path,
272 const char *name, int flags,
273 FsCred *credp, V9fsFidOpenState *fs)
274 {
275 errno = ENOSYS;
276 return -1;
277 }
278
279 static int synth_close(FsContext *ctx, V9fsFidOpenState *fs)
280 {
281 V9fsSynthOpenState *synth_open = fs->private;
282 V9fsSynthNode *node = synth_open->node;
283
284 node->open_count--;
285 g_free(synth_open);
286 fs->private = NULL;
287 return 0;
288 }
289
290 static ssize_t synth_pwritev(FsContext *ctx, V9fsFidOpenState *fs,
291 const struct iovec *iov,
292 int iovcnt, off_t offset)
293 {
294 int i, count = 0, wcount;
295 V9fsSynthOpenState *synth_open = fs->private;
296 V9fsSynthNode *node = synth_open->node;
297 if (!node->attr->write) {
298 errno = EPERM;
299 return -1;
300 }
301 for (i = 0; i < iovcnt; i++) {
302 wcount = node->attr->write(iov[i].iov_base, iov[i].iov_len,
303 offset, node->private);
304 offset += wcount;
305 count += wcount;
306 /* If we wrote less than requested. we are done */
307 if (wcount < iov[i].iov_len) {
308 break;
309 }
310 }
311 return count;
312 }
313
314 static ssize_t synth_preadv(FsContext *ctx, V9fsFidOpenState *fs,
315 const struct iovec *iov,
316 int iovcnt, off_t offset)
317 {
318 int i, count = 0, rcount;
319 V9fsSynthOpenState *synth_open = fs->private;
320 V9fsSynthNode *node = synth_open->node;
321 if (!node->attr->read) {
322 errno = EPERM;
323 return -1;
324 }
325 for (i = 0; i < iovcnt; i++) {
326 rcount = node->attr->read(iov[i].iov_base, iov[i].iov_len,
327 offset, node->private);
328 offset += rcount;
329 count += rcount;
330 /* If we read less than requested. we are done */
331 if (rcount < iov[i].iov_len) {
332 break;
333 }
334 }
335 return count;
336 }
337
338 static int synth_truncate(FsContext *ctx, V9fsPath *path, off_t offset)
339 {
340 errno = ENOSYS;
341 return -1;
342 }
343
344 static int synth_chmod(FsContext *fs_ctx, V9fsPath *path, FsCred *credp)
345 {
346 errno = EPERM;
347 return -1;
348 }
349
350 static int synth_mknod(FsContext *fs_ctx, V9fsPath *path,
351 const char *buf, FsCred *credp)
352 {
353 errno = EPERM;
354 return -1;
355 }
356
357 static int synth_mkdir(FsContext *fs_ctx, V9fsPath *path,
358 const char *buf, FsCred *credp)
359 {
360 errno = EPERM;
361 return -1;
362 }
363
364 static ssize_t synth_readlink(FsContext *fs_ctx, V9fsPath *path,
365 char *buf, size_t bufsz)
366 {
367 errno = ENOSYS;
368 return -1;
369 }
370
371 static int synth_symlink(FsContext *fs_ctx, const char *oldpath,
372 V9fsPath *newpath, const char *buf, FsCred *credp)
373 {
374 errno = EPERM;
375 return -1;
376 }
377
378 static int synth_link(FsContext *fs_ctx, V9fsPath *oldpath,
379 V9fsPath *newpath, const char *buf)
380 {
381 errno = EPERM;
382 return -1;
383 }
384
385 static int synth_rename(FsContext *ctx, const char *oldpath,
386 const char *newpath)
387 {
388 errno = EPERM;
389 return -1;
390 }
391
392 static int synth_chown(FsContext *fs_ctx, V9fsPath *path, FsCred *credp)
393 {
394 errno = EPERM;
395 return -1;
396 }
397
398 static int synth_utimensat(FsContext *fs_ctx, V9fsPath *path,
399 const struct timespec *buf)
400 {
401 errno = EPERM;
402 return 0;
403 }
404
405 static int synth_remove(FsContext *ctx, const char *path)
406 {
407 errno = EPERM;
408 return -1;
409 }
410
411 static int synth_fsync(FsContext *ctx, int fid_type,
412 V9fsFidOpenState *fs, int datasync)
413 {
414 errno = ENOSYS;
415 return 0;
416 }
417
418 static int synth_statfs(FsContext *s, V9fsPath *fs_path,
419 struct statfs *stbuf)
420 {
421 stbuf->f_type = 0xABCD;
422 stbuf->f_bsize = 512;
423 stbuf->f_blocks = 0;
424 stbuf->f_files = synth_node_count;
425 stbuf->f_namelen = NAME_MAX;
426 return 0;
427 }
428
429 static ssize_t synth_lgetxattr(FsContext *ctx, V9fsPath *path,
430 const char *name, void *value, size_t size)
431 {
432 errno = ENOTSUP;
433 return -1;
434 }
435
436 static ssize_t synth_llistxattr(FsContext *ctx, V9fsPath *path,
437 void *value, size_t size)
438 {
439 errno = ENOTSUP;
440 return -1;
441 }
442
443 static int synth_lsetxattr(FsContext *ctx, V9fsPath *path,
444 const char *name, void *value,
445 size_t size, int flags)
446 {
447 errno = ENOTSUP;
448 return -1;
449 }
450
451 static int synth_lremovexattr(FsContext *ctx,
452 V9fsPath *path, const char *name)
453 {
454 errno = ENOTSUP;
455 return -1;
456 }
457
458 static int synth_name_to_path(FsContext *ctx, V9fsPath *dir_path,
459 const char *name, V9fsPath *target)
460 {
461 V9fsSynthNode *node;
462 V9fsSynthNode *dir_node;
463
464 /* "." and ".." are not allowed */
465 if (!strcmp(name, ".") || !strcmp(name, "..")) {
466 errno = EINVAL;
467 return -1;
468
469 }
470 if (!dir_path) {
471 dir_node = &synth_root;
472 } else {
473 dir_node = *(V9fsSynthNode **)dir_path->data;
474 }
475 if (!strcmp(name, "/")) {
476 node = dir_node;
477 goto out;
478 }
479 /* search for the name in the childern */
480 rcu_read_lock();
481 QLIST_FOREACH(node, &dir_node->child, sibling) {
482 if (!strcmp(node->name, name)) {
483 break;
484 }
485 }
486 rcu_read_unlock();
487
488 if (!node) {
489 errno = ENOENT;
490 return -1;
491 }
492 out:
493 /* Copy the node pointer to fid */
494 g_free(target->data);
495 target->data = g_memdup(&node, sizeof(void *));
496 target->size = sizeof(void *);
497 return 0;
498 }
499
500 static int synth_renameat(FsContext *ctx, V9fsPath *olddir,
501 const char *old_name, V9fsPath *newdir,
502 const char *new_name)
503 {
504 errno = EPERM;
505 return -1;
506 }
507
508 static int synth_unlinkat(FsContext *ctx, V9fsPath *dir,
509 const char *name, int flags)
510 {
511 errno = EPERM;
512 return -1;
513 }
514
515 static ssize_t v9fs_synth_qtest_write(void *buf, int len, off_t offset,
516 void *arg)
517 {
518 return 1;
519 }
520
521 static ssize_t v9fs_synth_qtest_flush_write(void *buf, int len, off_t offset,
522 void *arg)
523 {
524 bool should_block = !!*(uint8_t *)buf;
525
526 if (should_block) {
527 /* This will cause the server to call us again until we're cancelled */
528 errno = EINTR;
529 return -1;
530 }
531
532 return 1;
533 }
534
535 static int synth_init(FsContext *ctx, Error **errp)
536 {
537 QLIST_INIT(&synth_root.child);
538 qemu_mutex_init(&synth_mutex);
539
540 /* Add "." and ".." entries for root */
541 v9fs_add_dir_node(&synth_root, synth_root.attr->mode,
542 "..", synth_root.attr, synth_root.attr->inode);
543 v9fs_add_dir_node(&synth_root, synth_root.attr->mode,
544 ".", synth_root.attr, synth_root.attr->inode);
545
546 /* Mark the subsystem is ready for use */
547 synth_fs = 1;
548
549 if (qtest_enabled()) {
550 V9fsSynthNode *node = NULL;
551 int i, ret;
552
553 /* Directory hierarchy for WALK test */
554 for (i = 0; i < P9_MAXWELEM; i++) {
555 char *name = g_strdup_printf(QTEST_V9FS_SYNTH_WALK_FILE, i);
556
557 ret = qemu_v9fs_synth_mkdir(node, 0700, name, &node);
558 assert(!ret);
559 g_free(name);
560 }
561
562 /* File for LOPEN test */
563 ret = qemu_v9fs_synth_add_file(NULL, 0, QTEST_V9FS_SYNTH_LOPEN_FILE,
564 NULL, NULL, ctx);
565 assert(!ret);
566
567 /* File for WRITE test */
568 ret = qemu_v9fs_synth_add_file(NULL, 0, QTEST_V9FS_SYNTH_WRITE_FILE,
569 NULL, v9fs_synth_qtest_write, ctx);
570 assert(!ret);
571
572 /* File for FLUSH test */
573 ret = qemu_v9fs_synth_add_file(NULL, 0, QTEST_V9FS_SYNTH_FLUSH_FILE,
574 NULL, v9fs_synth_qtest_flush_write,
575 ctx);
576 assert(!ret);
577
578 /* Directory for READDIR test */
579 {
580 V9fsSynthNode *dir = NULL;
581 ret = qemu_v9fs_synth_mkdir(
582 NULL, 0700, QTEST_V9FS_SYNTH_READDIR_DIR, &dir
583 );
584 assert(!ret);
585 for (i = 0; i < QTEST_V9FS_SYNTH_READDIR_NFILES; ++i) {
586 char *name = g_strdup_printf(
587 QTEST_V9FS_SYNTH_READDIR_FILE, i
588 );
589 ret = qemu_v9fs_synth_add_file(
590 dir, 0, name, NULL, NULL, ctx
591 );
592 assert(!ret);
593 g_free(name);
594 }
595 }
596 }
597
598 return 0;
599 }
600
601 FileOperations synth_ops = {
602 .init = synth_init,
603 .lstat = synth_lstat,
604 .readlink = synth_readlink,
605 .close = synth_close,
606 .closedir = synth_closedir,
607 .open = synth_open,
608 .opendir = synth_opendir,
609 .rewinddir = synth_rewinddir,
610 .telldir = synth_telldir,
611 .readdir = synth_readdir,
612 .seekdir = synth_seekdir,
613 .preadv = synth_preadv,
614 .pwritev = synth_pwritev,
615 .chmod = synth_chmod,
616 .mknod = synth_mknod,
617 .mkdir = synth_mkdir,
618 .fstat = synth_fstat,
619 .open2 = synth_open2,
620 .symlink = synth_symlink,
621 .link = synth_link,
622 .truncate = synth_truncate,
623 .rename = synth_rename,
624 .chown = synth_chown,
625 .utimensat = synth_utimensat,
626 .remove = synth_remove,
627 .fsync = synth_fsync,
628 .statfs = synth_statfs,
629 .lgetxattr = synth_lgetxattr,
630 .llistxattr = synth_llistxattr,
631 .lsetxattr = synth_lsetxattr,
632 .lremovexattr = synth_lremovexattr,
633 .name_to_path = synth_name_to_path,
634 .renameat = synth_renameat,
635 .unlinkat = synth_unlinkat,
636 };