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