sm501: Add missing arbitration control register
[qemu.git] / hw / 9pfs / 9p-local.c
1 /*
2 * 9p Posix callback
3 *
4 * Copyright IBM, Corp. 2010
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
11 *
12 */
13
14 #include "qemu/osdep.h"
15 #include "9p.h"
16 #include "9p-local.h"
17 #include "9p-xattr.h"
18 #include "9p-util.h"
19 #include "fsdev/qemu-fsdev.h" /* local_ops */
20 #include <arpa/inet.h>
21 #include <pwd.h>
22 #include <grp.h>
23 #include <sys/socket.h>
24 #include <sys/un.h>
25 #include "qemu/xattr.h"
26 #include "qemu/cutils.h"
27 #include "qemu/error-report.h"
28 #include <libgen.h>
29 #include <linux/fs.h>
30 #ifdef CONFIG_LINUX_MAGIC_H
31 #include <linux/magic.h>
32 #endif
33 #include <sys/ioctl.h>
34
35 #ifndef XFS_SUPER_MAGIC
36 #define XFS_SUPER_MAGIC 0x58465342
37 #endif
38 #ifndef EXT2_SUPER_MAGIC
39 #define EXT2_SUPER_MAGIC 0xEF53
40 #endif
41 #ifndef REISERFS_SUPER_MAGIC
42 #define REISERFS_SUPER_MAGIC 0x52654973
43 #endif
44 #ifndef BTRFS_SUPER_MAGIC
45 #define BTRFS_SUPER_MAGIC 0x9123683E
46 #endif
47
48 typedef struct {
49 int mountfd;
50 } LocalData;
51
52 int local_open_nofollow(FsContext *fs_ctx, const char *path, int flags,
53 mode_t mode)
54 {
55 LocalData *data = fs_ctx->private;
56
57 /* All paths are relative to the path data->mountfd points to */
58 while (*path == '/') {
59 path++;
60 }
61
62 return relative_openat_nofollow(data->mountfd, path, flags, mode);
63 }
64
65 int local_opendir_nofollow(FsContext *fs_ctx, const char *path)
66 {
67 return local_open_nofollow(fs_ctx, path, O_DIRECTORY | O_RDONLY, 0);
68 }
69
70 static void renameat_preserve_errno(int odirfd, const char *opath, int ndirfd,
71 const char *npath)
72 {
73 int serrno = errno;
74 renameat(odirfd, opath, ndirfd, npath);
75 errno = serrno;
76 }
77
78 static void unlinkat_preserve_errno(int dirfd, const char *path, int flags)
79 {
80 int serrno = errno;
81 unlinkat(dirfd, path, flags);
82 errno = serrno;
83 }
84
85 #define VIRTFS_META_DIR ".virtfs_metadata"
86
87 static FILE *local_fopenat(int dirfd, const char *name, const char *mode)
88 {
89 int fd, o_mode = 0;
90 FILE *fp;
91 int flags;
92 /*
93 * only supports two modes
94 */
95 if (mode[0] == 'r') {
96 flags = O_RDONLY;
97 } else if (mode[0] == 'w') {
98 flags = O_WRONLY | O_TRUNC | O_CREAT;
99 o_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
100 } else {
101 return NULL;
102 }
103 fd = openat_file(dirfd, name, flags, o_mode);
104 if (fd == -1) {
105 return NULL;
106 }
107 fp = fdopen(fd, mode);
108 if (!fp) {
109 close(fd);
110 }
111 return fp;
112 }
113
114 #define ATTR_MAX 100
115 static void local_mapped_file_attr(int dirfd, const char *name,
116 struct stat *stbuf)
117 {
118 FILE *fp;
119 char buf[ATTR_MAX];
120 int map_dirfd;
121
122 map_dirfd = openat_dir(dirfd, VIRTFS_META_DIR);
123 if (map_dirfd == -1) {
124 return;
125 }
126
127 fp = local_fopenat(map_dirfd, name, "r");
128 close_preserve_errno(map_dirfd);
129 if (!fp) {
130 return;
131 }
132 memset(buf, 0, ATTR_MAX);
133 while (fgets(buf, ATTR_MAX, fp)) {
134 if (!strncmp(buf, "virtfs.uid", 10)) {
135 stbuf->st_uid = atoi(buf+11);
136 } else if (!strncmp(buf, "virtfs.gid", 10)) {
137 stbuf->st_gid = atoi(buf+11);
138 } else if (!strncmp(buf, "virtfs.mode", 11)) {
139 stbuf->st_mode = atoi(buf+12);
140 } else if (!strncmp(buf, "virtfs.rdev", 11)) {
141 stbuf->st_rdev = atoi(buf+12);
142 }
143 memset(buf, 0, ATTR_MAX);
144 }
145 fclose(fp);
146 }
147
148 static int local_lstat(FsContext *fs_ctx, V9fsPath *fs_path, struct stat *stbuf)
149 {
150 int err = -1;
151 char *dirpath = g_path_get_dirname(fs_path->data);
152 char *name = g_path_get_basename(fs_path->data);
153 int dirfd;
154
155 dirfd = local_opendir_nofollow(fs_ctx, dirpath);
156 if (dirfd == -1) {
157 goto out;
158 }
159
160 err = fstatat(dirfd, name, stbuf, AT_SYMLINK_NOFOLLOW);
161 if (err) {
162 goto err_out;
163 }
164 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
165 /* Actual credentials are part of extended attrs */
166 uid_t tmp_uid;
167 gid_t tmp_gid;
168 mode_t tmp_mode;
169 dev_t tmp_dev;
170
171 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.uid", &tmp_uid,
172 sizeof(uid_t)) > 0) {
173 stbuf->st_uid = le32_to_cpu(tmp_uid);
174 }
175 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.gid", &tmp_gid,
176 sizeof(gid_t)) > 0) {
177 stbuf->st_gid = le32_to_cpu(tmp_gid);
178 }
179 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.mode", &tmp_mode,
180 sizeof(mode_t)) > 0) {
181 stbuf->st_mode = le32_to_cpu(tmp_mode);
182 }
183 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.rdev", &tmp_dev,
184 sizeof(dev_t)) > 0) {
185 stbuf->st_rdev = le64_to_cpu(tmp_dev);
186 }
187 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
188 local_mapped_file_attr(dirfd, name, stbuf);
189 }
190
191 err_out:
192 close_preserve_errno(dirfd);
193 out:
194 g_free(name);
195 g_free(dirpath);
196 return err;
197 }
198
199 static int local_set_mapped_file_attrat(int dirfd, const char *name,
200 FsCred *credp)
201 {
202 FILE *fp;
203 int ret;
204 char buf[ATTR_MAX];
205 int uid = -1, gid = -1, mode = -1, rdev = -1;
206 int map_dirfd;
207
208 ret = mkdirat(dirfd, VIRTFS_META_DIR, 0700);
209 if (ret < 0 && errno != EEXIST) {
210 return -1;
211 }
212
213 map_dirfd = openat_dir(dirfd, VIRTFS_META_DIR);
214 if (map_dirfd == -1) {
215 return -1;
216 }
217
218 fp = local_fopenat(map_dirfd, name, "r");
219 if (!fp) {
220 if (errno == ENOENT) {
221 goto update_map_file;
222 } else {
223 close_preserve_errno(map_dirfd);
224 return -1;
225 }
226 }
227 memset(buf, 0, ATTR_MAX);
228 while (fgets(buf, ATTR_MAX, fp)) {
229 if (!strncmp(buf, "virtfs.uid", 10)) {
230 uid = atoi(buf + 11);
231 } else if (!strncmp(buf, "virtfs.gid", 10)) {
232 gid = atoi(buf + 11);
233 } else if (!strncmp(buf, "virtfs.mode", 11)) {
234 mode = atoi(buf + 12);
235 } else if (!strncmp(buf, "virtfs.rdev", 11)) {
236 rdev = atoi(buf + 12);
237 }
238 memset(buf, 0, ATTR_MAX);
239 }
240 fclose(fp);
241
242 update_map_file:
243 fp = local_fopenat(map_dirfd, name, "w");
244 close_preserve_errno(map_dirfd);
245 if (!fp) {
246 return -1;
247 }
248
249 if (credp->fc_uid != -1) {
250 uid = credp->fc_uid;
251 }
252 if (credp->fc_gid != -1) {
253 gid = credp->fc_gid;
254 }
255 if (credp->fc_mode != -1) {
256 mode = credp->fc_mode;
257 }
258 if (credp->fc_rdev != -1) {
259 rdev = credp->fc_rdev;
260 }
261
262 if (uid != -1) {
263 fprintf(fp, "virtfs.uid=%d\n", uid);
264 }
265 if (gid != -1) {
266 fprintf(fp, "virtfs.gid=%d\n", gid);
267 }
268 if (mode != -1) {
269 fprintf(fp, "virtfs.mode=%d\n", mode);
270 }
271 if (rdev != -1) {
272 fprintf(fp, "virtfs.rdev=%d\n", rdev);
273 }
274 fclose(fp);
275
276 return 0;
277 }
278
279 static int fchmodat_nofollow(int dirfd, const char *name, mode_t mode)
280 {
281 int fd, ret;
282
283 /* FIXME: this should be handled with fchmodat(AT_SYMLINK_NOFOLLOW).
284 * Unfortunately, the linux kernel doesn't implement it yet. As an
285 * alternative, let's open the file and use fchmod() instead. This
286 * may fail depending on the permissions of the file, but it is the
287 * best we can do to avoid TOCTTOU. We first try to open read-only
288 * in case name points to a directory. If that fails, we try write-only
289 * in case name doesn't point to a directory.
290 */
291 fd = openat_file(dirfd, name, O_RDONLY, 0);
292 if (fd == -1) {
293 /* In case the file is writable-only and isn't a directory. */
294 if (errno == EACCES) {
295 fd = openat_file(dirfd, name, O_WRONLY, 0);
296 }
297 if (fd == -1 && errno == EISDIR) {
298 errno = EACCES;
299 }
300 }
301 if (fd == -1) {
302 return -1;
303 }
304 ret = fchmod(fd, mode);
305 close_preserve_errno(fd);
306 return ret;
307 }
308
309 static int local_set_xattrat(int dirfd, const char *path, FsCred *credp)
310 {
311 int err;
312
313 if (credp->fc_uid != -1) {
314 uint32_t tmp_uid = cpu_to_le32(credp->fc_uid);
315 err = fsetxattrat_nofollow(dirfd, path, "user.virtfs.uid", &tmp_uid,
316 sizeof(uid_t), 0);
317 if (err) {
318 return err;
319 }
320 }
321 if (credp->fc_gid != -1) {
322 uint32_t tmp_gid = cpu_to_le32(credp->fc_gid);
323 err = fsetxattrat_nofollow(dirfd, path, "user.virtfs.gid", &tmp_gid,
324 sizeof(gid_t), 0);
325 if (err) {
326 return err;
327 }
328 }
329 if (credp->fc_mode != -1) {
330 uint32_t tmp_mode = cpu_to_le32(credp->fc_mode);
331 err = fsetxattrat_nofollow(dirfd, path, "user.virtfs.mode", &tmp_mode,
332 sizeof(mode_t), 0);
333 if (err) {
334 return err;
335 }
336 }
337 if (credp->fc_rdev != -1) {
338 uint64_t tmp_rdev = cpu_to_le64(credp->fc_rdev);
339 err = fsetxattrat_nofollow(dirfd, path, "user.virtfs.rdev", &tmp_rdev,
340 sizeof(dev_t), 0);
341 if (err) {
342 return err;
343 }
344 }
345 return 0;
346 }
347
348 static int local_set_cred_passthrough(FsContext *fs_ctx, int dirfd,
349 const char *name, FsCred *credp)
350 {
351 if (fchownat(dirfd, name, credp->fc_uid, credp->fc_gid,
352 AT_SYMLINK_NOFOLLOW) < 0) {
353 /*
354 * If we fail to change ownership and if we are
355 * using security model none. Ignore the error
356 */
357 if ((fs_ctx->export_flags & V9FS_SEC_MASK) != V9FS_SM_NONE) {
358 return -1;
359 }
360 }
361
362 return fchmodat_nofollow(dirfd, name, credp->fc_mode & 07777);
363 }
364
365 static ssize_t local_readlink(FsContext *fs_ctx, V9fsPath *fs_path,
366 char *buf, size_t bufsz)
367 {
368 ssize_t tsize = -1;
369
370 if ((fs_ctx->export_flags & V9FS_SM_MAPPED) ||
371 (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE)) {
372 int fd;
373
374 fd = local_open_nofollow(fs_ctx, fs_path->data, O_RDONLY, 0);
375 if (fd == -1) {
376 return -1;
377 }
378 do {
379 tsize = read(fd, (void *)buf, bufsz);
380 } while (tsize == -1 && errno == EINTR);
381 close_preserve_errno(fd);
382 } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
383 (fs_ctx->export_flags & V9FS_SM_NONE)) {
384 char *dirpath = g_path_get_dirname(fs_path->data);
385 char *name = g_path_get_basename(fs_path->data);
386 int dirfd;
387
388 dirfd = local_opendir_nofollow(fs_ctx, dirpath);
389 if (dirfd == -1) {
390 goto out;
391 }
392
393 tsize = readlinkat(dirfd, name, buf, bufsz);
394 close_preserve_errno(dirfd);
395 out:
396 g_free(name);
397 g_free(dirpath);
398 }
399 return tsize;
400 }
401
402 static int local_close(FsContext *ctx, V9fsFidOpenState *fs)
403 {
404 return close(fs->fd);
405 }
406
407 static int local_closedir(FsContext *ctx, V9fsFidOpenState *fs)
408 {
409 return closedir(fs->dir.stream);
410 }
411
412 static int local_open(FsContext *ctx, V9fsPath *fs_path,
413 int flags, V9fsFidOpenState *fs)
414 {
415 int fd;
416
417 fd = local_open_nofollow(ctx, fs_path->data, flags, 0);
418 if (fd == -1) {
419 return -1;
420 }
421 fs->fd = fd;
422 return fs->fd;
423 }
424
425 static int local_opendir(FsContext *ctx,
426 V9fsPath *fs_path, V9fsFidOpenState *fs)
427 {
428 int dirfd;
429 DIR *stream;
430
431 dirfd = local_opendir_nofollow(ctx, fs_path->data);
432 if (dirfd == -1) {
433 return -1;
434 }
435
436 stream = fdopendir(dirfd);
437 if (!stream) {
438 close(dirfd);
439 return -1;
440 }
441 fs->dir.stream = stream;
442 return 0;
443 }
444
445 static void local_rewinddir(FsContext *ctx, V9fsFidOpenState *fs)
446 {
447 rewinddir(fs->dir.stream);
448 }
449
450 static off_t local_telldir(FsContext *ctx, V9fsFidOpenState *fs)
451 {
452 return telldir(fs->dir.stream);
453 }
454
455 static struct dirent *local_readdir(FsContext *ctx, V9fsFidOpenState *fs)
456 {
457 struct dirent *entry;
458
459 again:
460 entry = readdir(fs->dir.stream);
461 if (!entry) {
462 return NULL;
463 }
464
465 if (ctx->export_flags & V9FS_SM_MAPPED) {
466 entry->d_type = DT_UNKNOWN;
467 } else if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
468 if (!strcmp(entry->d_name, VIRTFS_META_DIR)) {
469 /* skp the meta data directory */
470 goto again;
471 }
472 entry->d_type = DT_UNKNOWN;
473 }
474
475 return entry;
476 }
477
478 static void local_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
479 {
480 seekdir(fs->dir.stream, off);
481 }
482
483 static ssize_t local_preadv(FsContext *ctx, V9fsFidOpenState *fs,
484 const struct iovec *iov,
485 int iovcnt, off_t offset)
486 {
487 #ifdef CONFIG_PREADV
488 return preadv(fs->fd, iov, iovcnt, offset);
489 #else
490 int err = lseek(fs->fd, offset, SEEK_SET);
491 if (err == -1) {
492 return err;
493 } else {
494 return readv(fs->fd, iov, iovcnt);
495 }
496 #endif
497 }
498
499 static ssize_t local_pwritev(FsContext *ctx, V9fsFidOpenState *fs,
500 const struct iovec *iov,
501 int iovcnt, off_t offset)
502 {
503 ssize_t ret;
504 #ifdef CONFIG_PREADV
505 ret = pwritev(fs->fd, iov, iovcnt, offset);
506 #else
507 int err = lseek(fs->fd, offset, SEEK_SET);
508 if (err == -1) {
509 return err;
510 } else {
511 ret = writev(fs->fd, iov, iovcnt);
512 }
513 #endif
514 #ifdef CONFIG_SYNC_FILE_RANGE
515 if (ret > 0 && ctx->export_flags & V9FS_IMMEDIATE_WRITEOUT) {
516 /*
517 * Initiate a writeback. This is not a data integrity sync.
518 * We want to ensure that we don't leave dirty pages in the cache
519 * after write when writeout=immediate is sepcified.
520 */
521 sync_file_range(fs->fd, offset, ret,
522 SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE);
523 }
524 #endif
525 return ret;
526 }
527
528 static int local_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
529 {
530 char *dirpath = g_path_get_dirname(fs_path->data);
531 char *name = g_path_get_basename(fs_path->data);
532 int ret = -1;
533 int dirfd;
534
535 dirfd = local_opendir_nofollow(fs_ctx, dirpath);
536 if (dirfd == -1) {
537 goto out;
538 }
539
540 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
541 ret = local_set_xattrat(dirfd, name, credp);
542 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
543 ret = local_set_mapped_file_attrat(dirfd, name, credp);
544 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
545 fs_ctx->export_flags & V9FS_SM_NONE) {
546 ret = fchmodat_nofollow(dirfd, name, credp->fc_mode);
547 }
548 close_preserve_errno(dirfd);
549
550 out:
551 g_free(dirpath);
552 g_free(name);
553 return ret;
554 }
555
556 static int local_mknod(FsContext *fs_ctx, V9fsPath *dir_path,
557 const char *name, FsCred *credp)
558 {
559 int err = -1;
560 int dirfd;
561
562 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
563 if (dirfd == -1) {
564 return -1;
565 }
566
567 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
568 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
569 err = mknodat(dirfd, name, SM_LOCAL_MODE_BITS | S_IFREG, 0);
570 if (err == -1) {
571 goto out;
572 }
573
574 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
575 err = local_set_xattrat(dirfd, name, credp);
576 } else {
577 err = local_set_mapped_file_attrat(dirfd, name, credp);
578 }
579 if (err == -1) {
580 goto err_end;
581 }
582 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
583 fs_ctx->export_flags & V9FS_SM_NONE) {
584 err = mknodat(dirfd, name, credp->fc_mode, credp->fc_rdev);
585 if (err == -1) {
586 goto out;
587 }
588 err = local_set_cred_passthrough(fs_ctx, dirfd, name, credp);
589 if (err == -1) {
590 goto err_end;
591 }
592 }
593 goto out;
594
595 err_end:
596 unlinkat_preserve_errno(dirfd, name, 0);
597 out:
598 close_preserve_errno(dirfd);
599 return err;
600 }
601
602 static int local_mkdir(FsContext *fs_ctx, V9fsPath *dir_path,
603 const char *name, FsCred *credp)
604 {
605 int err = -1;
606 int dirfd;
607
608 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
609 if (dirfd == -1) {
610 return -1;
611 }
612
613 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
614 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
615 err = mkdirat(dirfd, name, SM_LOCAL_DIR_MODE_BITS);
616 if (err == -1) {
617 goto out;
618 }
619 credp->fc_mode = credp->fc_mode | S_IFDIR;
620
621 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
622 err = local_set_xattrat(dirfd, name, credp);
623 } else {
624 err = local_set_mapped_file_attrat(dirfd, name, credp);
625 }
626 if (err == -1) {
627 goto err_end;
628 }
629 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
630 fs_ctx->export_flags & V9FS_SM_NONE) {
631 err = mkdirat(dirfd, name, credp->fc_mode);
632 if (err == -1) {
633 goto out;
634 }
635 err = local_set_cred_passthrough(fs_ctx, dirfd, name, credp);
636 if (err == -1) {
637 goto err_end;
638 }
639 }
640 goto out;
641
642 err_end:
643 unlinkat_preserve_errno(dirfd, name, AT_REMOVEDIR);
644 out:
645 close_preserve_errno(dirfd);
646 return err;
647 }
648
649 static int local_fstat(FsContext *fs_ctx, int fid_type,
650 V9fsFidOpenState *fs, struct stat *stbuf)
651 {
652 int err, fd;
653
654 if (fid_type == P9_FID_DIR) {
655 fd = dirfd(fs->dir.stream);
656 } else {
657 fd = fs->fd;
658 }
659
660 err = fstat(fd, stbuf);
661 if (err) {
662 return err;
663 }
664 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
665 /* Actual credentials are part of extended attrs */
666 uid_t tmp_uid;
667 gid_t tmp_gid;
668 mode_t tmp_mode;
669 dev_t tmp_dev;
670
671 if (fgetxattr(fd, "user.virtfs.uid", &tmp_uid, sizeof(uid_t)) > 0) {
672 stbuf->st_uid = le32_to_cpu(tmp_uid);
673 }
674 if (fgetxattr(fd, "user.virtfs.gid", &tmp_gid, sizeof(gid_t)) > 0) {
675 stbuf->st_gid = le32_to_cpu(tmp_gid);
676 }
677 if (fgetxattr(fd, "user.virtfs.mode", &tmp_mode, sizeof(mode_t)) > 0) {
678 stbuf->st_mode = le32_to_cpu(tmp_mode);
679 }
680 if (fgetxattr(fd, "user.virtfs.rdev", &tmp_dev, sizeof(dev_t)) > 0) {
681 stbuf->st_rdev = le64_to_cpu(tmp_dev);
682 }
683 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
684 errno = EOPNOTSUPP;
685 return -1;
686 }
687 return err;
688 }
689
690 static int local_open2(FsContext *fs_ctx, V9fsPath *dir_path, const char *name,
691 int flags, FsCred *credp, V9fsFidOpenState *fs)
692 {
693 int fd = -1;
694 int err = -1;
695 int dirfd;
696
697 /*
698 * Mark all the open to not follow symlinks
699 */
700 flags |= O_NOFOLLOW;
701
702 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
703 if (dirfd == -1) {
704 return -1;
705 }
706
707 /* Determine the security model */
708 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
709 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
710 fd = openat_file(dirfd, name, flags, SM_LOCAL_MODE_BITS);
711 if (fd == -1) {
712 goto out;
713 }
714 credp->fc_mode = credp->fc_mode|S_IFREG;
715 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
716 /* Set cleint credentials in xattr */
717 err = local_set_xattrat(dirfd, name, credp);
718 } else {
719 err = local_set_mapped_file_attrat(dirfd, name, credp);
720 }
721 if (err == -1) {
722 goto err_end;
723 }
724 } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
725 (fs_ctx->export_flags & V9FS_SM_NONE)) {
726 fd = openat_file(dirfd, name, flags, credp->fc_mode);
727 if (fd == -1) {
728 goto out;
729 }
730 err = local_set_cred_passthrough(fs_ctx, dirfd, name, credp);
731 if (err == -1) {
732 goto err_end;
733 }
734 }
735 err = fd;
736 fs->fd = fd;
737 goto out;
738
739 err_end:
740 unlinkat_preserve_errno(dirfd, name,
741 flags & O_DIRECTORY ? AT_REMOVEDIR : 0);
742 close_preserve_errno(fd);
743 out:
744 close_preserve_errno(dirfd);
745 return err;
746 }
747
748
749 static int local_symlink(FsContext *fs_ctx, const char *oldpath,
750 V9fsPath *dir_path, const char *name, FsCred *credp)
751 {
752 int err = -1;
753 int dirfd;
754
755 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
756 if (dirfd == -1) {
757 return -1;
758 }
759
760 /* Determine the security model */
761 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
762 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
763 int fd;
764 ssize_t oldpath_size, write_size;
765
766 fd = openat_file(dirfd, name, O_CREAT | O_EXCL | O_RDWR,
767 SM_LOCAL_MODE_BITS);
768 if (fd == -1) {
769 goto out;
770 }
771 /* Write the oldpath (target) to the file. */
772 oldpath_size = strlen(oldpath);
773 do {
774 write_size = write(fd, (void *)oldpath, oldpath_size);
775 } while (write_size == -1 && errno == EINTR);
776 close_preserve_errno(fd);
777
778 if (write_size != oldpath_size) {
779 goto err_end;
780 }
781 /* Set cleint credentials in symlink's xattr */
782 credp->fc_mode = credp->fc_mode | S_IFLNK;
783
784 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
785 err = local_set_xattrat(dirfd, name, credp);
786 } else {
787 err = local_set_mapped_file_attrat(dirfd, name, credp);
788 }
789 if (err == -1) {
790 goto err_end;
791 }
792 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
793 fs_ctx->export_flags & V9FS_SM_NONE) {
794 err = symlinkat(oldpath, dirfd, name);
795 if (err) {
796 goto out;
797 }
798 err = fchownat(dirfd, name, credp->fc_uid, credp->fc_gid,
799 AT_SYMLINK_NOFOLLOW);
800 if (err == -1) {
801 /*
802 * If we fail to change ownership and if we are
803 * using security model none. Ignore the error
804 */
805 if ((fs_ctx->export_flags & V9FS_SEC_MASK) != V9FS_SM_NONE) {
806 goto err_end;
807 } else {
808 err = 0;
809 }
810 }
811 }
812 goto out;
813
814 err_end:
815 unlinkat_preserve_errno(dirfd, name, 0);
816 out:
817 close_preserve_errno(dirfd);
818 return err;
819 }
820
821 static int local_link(FsContext *ctx, V9fsPath *oldpath,
822 V9fsPath *dirpath, const char *name)
823 {
824 char *odirpath = g_path_get_dirname(oldpath->data);
825 char *oname = g_path_get_basename(oldpath->data);
826 int ret = -1;
827 int odirfd, ndirfd;
828
829 odirfd = local_opendir_nofollow(ctx, odirpath);
830 if (odirfd == -1) {
831 goto out;
832 }
833
834 ndirfd = local_opendir_nofollow(ctx, dirpath->data);
835 if (ndirfd == -1) {
836 close_preserve_errno(odirfd);
837 goto out;
838 }
839
840 ret = linkat(odirfd, oname, ndirfd, name, 0);
841 if (ret < 0) {
842 goto out_close;
843 }
844
845 /* now link the virtfs_metadata files */
846 if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
847 int omap_dirfd, nmap_dirfd;
848
849 ret = mkdirat(ndirfd, VIRTFS_META_DIR, 0700);
850 if (ret < 0 && errno != EEXIST) {
851 goto err_undo_link;
852 }
853
854 omap_dirfd = openat_dir(odirfd, VIRTFS_META_DIR);
855 if (omap_dirfd == -1) {
856 goto err;
857 }
858
859 nmap_dirfd = openat_dir(ndirfd, VIRTFS_META_DIR);
860 if (nmap_dirfd == -1) {
861 close_preserve_errno(omap_dirfd);
862 goto err;
863 }
864
865 ret = linkat(omap_dirfd, oname, nmap_dirfd, name, 0);
866 close_preserve_errno(nmap_dirfd);
867 close_preserve_errno(omap_dirfd);
868 if (ret < 0 && errno != ENOENT) {
869 goto err_undo_link;
870 }
871
872 ret = 0;
873 }
874 goto out_close;
875
876 err:
877 ret = -1;
878 err_undo_link:
879 unlinkat_preserve_errno(ndirfd, name, 0);
880 out_close:
881 close_preserve_errno(ndirfd);
882 close_preserve_errno(odirfd);
883 out:
884 g_free(oname);
885 g_free(odirpath);
886 return ret;
887 }
888
889 static int local_truncate(FsContext *ctx, V9fsPath *fs_path, off_t size)
890 {
891 int fd, ret;
892
893 fd = local_open_nofollow(ctx, fs_path->data, O_WRONLY, 0);
894 if (fd == -1) {
895 return -1;
896 }
897 ret = ftruncate(fd, size);
898 close_preserve_errno(fd);
899 return ret;
900 }
901
902 static int local_chown(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
903 {
904 char *dirpath = g_path_get_dirname(fs_path->data);
905 char *name = g_path_get_basename(fs_path->data);
906 int ret = -1;
907 int dirfd;
908
909 dirfd = local_opendir_nofollow(fs_ctx, dirpath);
910 if (dirfd == -1) {
911 goto out;
912 }
913
914 if ((credp->fc_uid == -1 && credp->fc_gid == -1) ||
915 (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
916 (fs_ctx->export_flags & V9FS_SM_NONE)) {
917 ret = fchownat(dirfd, name, credp->fc_uid, credp->fc_gid,
918 AT_SYMLINK_NOFOLLOW);
919 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
920 ret = local_set_xattrat(dirfd, name, credp);
921 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
922 ret = local_set_mapped_file_attrat(dirfd, name, credp);
923 }
924
925 close_preserve_errno(dirfd);
926 out:
927 g_free(name);
928 g_free(dirpath);
929 return ret;
930 }
931
932 static int local_utimensat(FsContext *s, V9fsPath *fs_path,
933 const struct timespec *buf)
934 {
935 char *dirpath = g_path_get_dirname(fs_path->data);
936 char *name = g_path_get_basename(fs_path->data);
937 int dirfd, ret = -1;
938
939 dirfd = local_opendir_nofollow(s, dirpath);
940 if (dirfd == -1) {
941 goto out;
942 }
943
944 ret = utimensat(dirfd, name, buf, AT_SYMLINK_NOFOLLOW);
945 close_preserve_errno(dirfd);
946 out:
947 g_free(dirpath);
948 g_free(name);
949 return ret;
950 }
951
952 static int local_unlinkat_common(FsContext *ctx, int dirfd, const char *name,
953 int flags)
954 {
955 int ret = -1;
956
957 if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
958 int map_dirfd;
959
960 if (flags == AT_REMOVEDIR) {
961 int fd;
962
963 fd = openat_dir(dirfd, name);
964 if (fd == -1) {
965 goto err_out;
966 }
967 /*
968 * If directory remove .virtfs_metadata contained in the
969 * directory
970 */
971 ret = unlinkat(fd, VIRTFS_META_DIR, AT_REMOVEDIR);
972 close_preserve_errno(fd);
973 if (ret < 0 && errno != ENOENT) {
974 /*
975 * We didn't had the .virtfs_metadata file. May be file created
976 * in non-mapped mode ?. Ignore ENOENT.
977 */
978 goto err_out;
979 }
980 }
981 /*
982 * Now remove the name from parent directory
983 * .virtfs_metadata directory.
984 */
985 map_dirfd = openat_dir(dirfd, VIRTFS_META_DIR);
986 ret = unlinkat(map_dirfd, name, 0);
987 close_preserve_errno(map_dirfd);
988 if (ret < 0 && errno != ENOENT) {
989 /*
990 * We didn't had the .virtfs_metadata file. May be file created
991 * in non-mapped mode ?. Ignore ENOENT.
992 */
993 goto err_out;
994 }
995 }
996
997 ret = unlinkat(dirfd, name, flags);
998 err_out:
999 return ret;
1000 }
1001
1002 static int local_remove(FsContext *ctx, const char *path)
1003 {
1004 struct stat stbuf;
1005 char *dirpath = g_path_get_dirname(path);
1006 char *name = g_path_get_basename(path);
1007 int flags = 0;
1008 int dirfd;
1009 int err = -1;
1010
1011 dirfd = local_opendir_nofollow(ctx, dirpath);
1012 if (dirfd == -1) {
1013 goto out;
1014 }
1015
1016 if (fstatat(dirfd, path, &stbuf, AT_SYMLINK_NOFOLLOW) < 0) {
1017 goto err_out;
1018 }
1019
1020 if (S_ISDIR(stbuf.st_mode)) {
1021 flags |= AT_REMOVEDIR;
1022 }
1023
1024 err = local_unlinkat_common(ctx, dirfd, name, flags);
1025 err_out:
1026 close_preserve_errno(dirfd);
1027 out:
1028 g_free(name);
1029 g_free(dirpath);
1030 return err;
1031 }
1032
1033 static int local_fsync(FsContext *ctx, int fid_type,
1034 V9fsFidOpenState *fs, int datasync)
1035 {
1036 int fd;
1037
1038 if (fid_type == P9_FID_DIR) {
1039 fd = dirfd(fs->dir.stream);
1040 } else {
1041 fd = fs->fd;
1042 }
1043
1044 if (datasync) {
1045 return qemu_fdatasync(fd);
1046 } else {
1047 return fsync(fd);
1048 }
1049 }
1050
1051 static int local_statfs(FsContext *s, V9fsPath *fs_path, struct statfs *stbuf)
1052 {
1053 int fd, ret;
1054
1055 fd = local_open_nofollow(s, fs_path->data, O_RDONLY, 0);
1056 if (fd == -1) {
1057 return -1;
1058 }
1059 ret = fstatfs(fd, stbuf);
1060 close_preserve_errno(fd);
1061 return ret;
1062 }
1063
1064 static ssize_t local_lgetxattr(FsContext *ctx, V9fsPath *fs_path,
1065 const char *name, void *value, size_t size)
1066 {
1067 char *path = fs_path->data;
1068
1069 return v9fs_get_xattr(ctx, path, name, value, size);
1070 }
1071
1072 static ssize_t local_llistxattr(FsContext *ctx, V9fsPath *fs_path,
1073 void *value, size_t size)
1074 {
1075 char *path = fs_path->data;
1076
1077 return v9fs_list_xattr(ctx, path, value, size);
1078 }
1079
1080 static int local_lsetxattr(FsContext *ctx, V9fsPath *fs_path, const char *name,
1081 void *value, size_t size, int flags)
1082 {
1083 char *path = fs_path->data;
1084
1085 return v9fs_set_xattr(ctx, path, name, value, size, flags);
1086 }
1087
1088 static int local_lremovexattr(FsContext *ctx, V9fsPath *fs_path,
1089 const char *name)
1090 {
1091 char *path = fs_path->data;
1092
1093 return v9fs_remove_xattr(ctx, path, name);
1094 }
1095
1096 static int local_name_to_path(FsContext *ctx, V9fsPath *dir_path,
1097 const char *name, V9fsPath *target)
1098 {
1099 if (dir_path) {
1100 v9fs_path_sprintf(target, "%s/%s", dir_path->data, name);
1101 } else if (strcmp(name, "/")) {
1102 v9fs_path_sprintf(target, "%s", name);
1103 } else {
1104 /* We want the path of the export root to be relative, otherwise
1105 * "*at()" syscalls would treat it as "/" in the host.
1106 */
1107 v9fs_path_sprintf(target, "%s", ".");
1108 }
1109 return 0;
1110 }
1111
1112 static int local_renameat(FsContext *ctx, V9fsPath *olddir,
1113 const char *old_name, V9fsPath *newdir,
1114 const char *new_name)
1115 {
1116 int ret;
1117 int odirfd, ndirfd;
1118
1119 odirfd = local_opendir_nofollow(ctx, olddir->data);
1120 if (odirfd == -1) {
1121 return -1;
1122 }
1123
1124 ndirfd = local_opendir_nofollow(ctx, newdir->data);
1125 if (ndirfd == -1) {
1126 close_preserve_errno(odirfd);
1127 return -1;
1128 }
1129
1130 ret = renameat(odirfd, old_name, ndirfd, new_name);
1131 if (ret < 0) {
1132 goto out;
1133 }
1134
1135 if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
1136 int omap_dirfd, nmap_dirfd;
1137
1138 ret = mkdirat(ndirfd, VIRTFS_META_DIR, 0700);
1139 if (ret < 0 && errno != EEXIST) {
1140 goto err_undo_rename;
1141 }
1142
1143 omap_dirfd = openat_dir(odirfd, VIRTFS_META_DIR);
1144 if (omap_dirfd == -1) {
1145 goto err;
1146 }
1147
1148 nmap_dirfd = openat_dir(ndirfd, VIRTFS_META_DIR);
1149 if (nmap_dirfd == -1) {
1150 close_preserve_errno(omap_dirfd);
1151 goto err;
1152 }
1153
1154 /* rename the .virtfs_metadata files */
1155 ret = renameat(omap_dirfd, old_name, nmap_dirfd, new_name);
1156 close_preserve_errno(nmap_dirfd);
1157 close_preserve_errno(omap_dirfd);
1158 if (ret < 0 && errno != ENOENT) {
1159 goto err_undo_rename;
1160 }
1161
1162 ret = 0;
1163 }
1164 goto out;
1165
1166 err:
1167 ret = -1;
1168 err_undo_rename:
1169 renameat_preserve_errno(ndirfd, new_name, odirfd, old_name);
1170 out:
1171 close_preserve_errno(ndirfd);
1172 close_preserve_errno(odirfd);
1173 return ret;
1174 }
1175
1176 static void v9fs_path_init_dirname(V9fsPath *path, const char *str)
1177 {
1178 path->data = g_path_get_dirname(str);
1179 path->size = strlen(path->data) + 1;
1180 }
1181
1182 static int local_rename(FsContext *ctx, const char *oldpath,
1183 const char *newpath)
1184 {
1185 int err;
1186 char *oname = g_path_get_basename(oldpath);
1187 char *nname = g_path_get_basename(newpath);
1188 V9fsPath olddir, newdir;
1189
1190 v9fs_path_init_dirname(&olddir, oldpath);
1191 v9fs_path_init_dirname(&newdir, newpath);
1192
1193 err = local_renameat(ctx, &olddir, oname, &newdir, nname);
1194
1195 v9fs_path_free(&newdir);
1196 v9fs_path_free(&olddir);
1197 g_free(nname);
1198 g_free(oname);
1199
1200 return err;
1201 }
1202
1203 static int local_unlinkat(FsContext *ctx, V9fsPath *dir,
1204 const char *name, int flags)
1205 {
1206 int ret;
1207 int dirfd;
1208
1209 dirfd = local_opendir_nofollow(ctx, dir->data);
1210 if (dirfd == -1) {
1211 return -1;
1212 }
1213
1214 ret = local_unlinkat_common(ctx, dirfd, name, flags);
1215 close_preserve_errno(dirfd);
1216 return ret;
1217 }
1218
1219 static int local_ioc_getversion(FsContext *ctx, V9fsPath *path,
1220 mode_t st_mode, uint64_t *st_gen)
1221 {
1222 #ifdef FS_IOC_GETVERSION
1223 int err;
1224 V9fsFidOpenState fid_open;
1225
1226 /*
1227 * Do not try to open special files like device nodes, fifos etc
1228 * We can get fd for regular files and directories only
1229 */
1230 if (!S_ISREG(st_mode) && !S_ISDIR(st_mode)) {
1231 errno = ENOTTY;
1232 return -1;
1233 }
1234 err = local_open(ctx, path, O_RDONLY, &fid_open);
1235 if (err < 0) {
1236 return err;
1237 }
1238 err = ioctl(fid_open.fd, FS_IOC_GETVERSION, st_gen);
1239 local_close(ctx, &fid_open);
1240 return err;
1241 #else
1242 errno = ENOTTY;
1243 return -1;
1244 #endif
1245 }
1246
1247 static int local_init(FsContext *ctx)
1248 {
1249 struct statfs stbuf;
1250 LocalData *data = g_malloc(sizeof(*data));
1251
1252 data->mountfd = open(ctx->fs_root, O_DIRECTORY | O_RDONLY);
1253 if (data->mountfd == -1) {
1254 goto err;
1255 }
1256
1257 #ifdef FS_IOC_GETVERSION
1258 /*
1259 * use ioc_getversion only if the ioctl is definied
1260 */
1261 if (fstatfs(data->mountfd, &stbuf) < 0) {
1262 close_preserve_errno(data->mountfd);
1263 goto err;
1264 }
1265 switch (stbuf.f_type) {
1266 case EXT2_SUPER_MAGIC:
1267 case BTRFS_SUPER_MAGIC:
1268 case REISERFS_SUPER_MAGIC:
1269 case XFS_SUPER_MAGIC:
1270 ctx->exops.get_st_gen = local_ioc_getversion;
1271 break;
1272 }
1273 #endif
1274
1275 if (ctx->export_flags & V9FS_SM_PASSTHROUGH) {
1276 ctx->xops = passthrough_xattr_ops;
1277 } else if (ctx->export_flags & V9FS_SM_MAPPED) {
1278 ctx->xops = mapped_xattr_ops;
1279 } else if (ctx->export_flags & V9FS_SM_NONE) {
1280 ctx->xops = none_xattr_ops;
1281 } else if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
1282 /*
1283 * xattr operation for mapped-file and passthrough
1284 * remain same.
1285 */
1286 ctx->xops = passthrough_xattr_ops;
1287 }
1288 ctx->export_flags |= V9FS_PATHNAME_FSCONTEXT;
1289
1290 ctx->private = data;
1291 return 0;
1292
1293 err:
1294 g_free(data);
1295 return -1;
1296 }
1297
1298 static void local_cleanup(FsContext *ctx)
1299 {
1300 LocalData *data = ctx->private;
1301
1302 close(data->mountfd);
1303 g_free(data);
1304 }
1305
1306 static int local_parse_opts(QemuOpts *opts, struct FsDriverEntry *fse)
1307 {
1308 const char *sec_model = qemu_opt_get(opts, "security_model");
1309 const char *path = qemu_opt_get(opts, "path");
1310 Error *err = NULL;
1311
1312 if (!sec_model) {
1313 error_report("Security model not specified, local fs needs security model");
1314 error_printf("valid options are:"
1315 "\tsecurity_model=[passthrough|mapped-xattr|mapped-file|none]\n");
1316 return -1;
1317 }
1318
1319 if (!strcmp(sec_model, "passthrough")) {
1320 fse->export_flags |= V9FS_SM_PASSTHROUGH;
1321 } else if (!strcmp(sec_model, "mapped") ||
1322 !strcmp(sec_model, "mapped-xattr")) {
1323 fse->export_flags |= V9FS_SM_MAPPED;
1324 } else if (!strcmp(sec_model, "none")) {
1325 fse->export_flags |= V9FS_SM_NONE;
1326 } else if (!strcmp(sec_model, "mapped-file")) {
1327 fse->export_flags |= V9FS_SM_MAPPED_FILE;
1328 } else {
1329 error_report("Invalid security model %s specified", sec_model);
1330 error_printf("valid options are:"
1331 "\t[passthrough|mapped-xattr|mapped-file|none]\n");
1332 return -1;
1333 }
1334
1335 if (!path) {
1336 error_report("fsdev: No path specified");
1337 return -1;
1338 }
1339
1340 fsdev_throttle_parse_opts(opts, &fse->fst, &err);
1341 if (err) {
1342 error_reportf_err(err, "Throttle configuration is not valid: ");
1343 return -1;
1344 }
1345
1346 fse->path = g_strdup(path);
1347
1348 return 0;
1349 }
1350
1351 FileOperations local_ops = {
1352 .parse_opts = local_parse_opts,
1353 .init = local_init,
1354 .cleanup = local_cleanup,
1355 .lstat = local_lstat,
1356 .readlink = local_readlink,
1357 .close = local_close,
1358 .closedir = local_closedir,
1359 .open = local_open,
1360 .opendir = local_opendir,
1361 .rewinddir = local_rewinddir,
1362 .telldir = local_telldir,
1363 .readdir = local_readdir,
1364 .seekdir = local_seekdir,
1365 .preadv = local_preadv,
1366 .pwritev = local_pwritev,
1367 .chmod = local_chmod,
1368 .mknod = local_mknod,
1369 .mkdir = local_mkdir,
1370 .fstat = local_fstat,
1371 .open2 = local_open2,
1372 .symlink = local_symlink,
1373 .link = local_link,
1374 .truncate = local_truncate,
1375 .rename = local_rename,
1376 .chown = local_chown,
1377 .utimensat = local_utimensat,
1378 .remove = local_remove,
1379 .fsync = local_fsync,
1380 .statfs = local_statfs,
1381 .lgetxattr = local_lgetxattr,
1382 .llistxattr = local_llistxattr,
1383 .lsetxattr = local_lsetxattr,
1384 .lremovexattr = local_lremovexattr,
1385 .name_to_path = local_name_to_path,
1386 .renameat = local_renameat,
1387 .unlinkat = local_unlinkat,
1388 };