1
2
3
4
5
6
7
8
9
10
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"
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
48typedef struct {
49 int mountfd;
50} LocalData;
51
52int local_open_nofollow(FsContext *fs_ctx, const char *path, int flags,
53 mode_t mode)
54{
55 LocalData *data = fs_ctx->private;
56
57
58 while (*path == '/') {
59 path++;
60 }
61
62 return relative_openat_nofollow(data->mountfd, path, flags, mode);
63}
64
65int 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
70static 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
78static 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
87static 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
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
115static 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
148static 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
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
191err_out:
192 close_preserve_errno(dirfd);
193out:
194 g_free(name);
195 g_free(dirpath);
196 return err;
197}
198
199static 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
242update_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
279static int fchmodat_nofollow(int dirfd, const char *name, mode_t mode)
280{
281 int fd, ret;
282
283
284
285
286
287
288
289
290
291 fd = openat_file(dirfd, name, O_RDONLY, 0);
292 if (fd == -1) {
293
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
309static 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
348static 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
355
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
365static 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
402static int local_close(FsContext *ctx, V9fsFidOpenState *fs)
403{
404 return close(fs->fd);
405}
406
407static int local_closedir(FsContext *ctx, V9fsFidOpenState *fs)
408{
409 return closedir(fs->dir.stream);
410}
411
412static 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
425static 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
445static void local_rewinddir(FsContext *ctx, V9fsFidOpenState *fs)
446{
447 rewinddir(fs->dir.stream);
448}
449
450static off_t local_telldir(FsContext *ctx, V9fsFidOpenState *fs)
451{
452 return telldir(fs->dir.stream);
453}
454
455static struct dirent *local_readdir(FsContext *ctx, V9fsFidOpenState *fs)
456{
457 struct dirent *entry;
458
459again:
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
470 goto again;
471 }
472 entry->d_type = DT_UNKNOWN;
473 }
474
475 return entry;
476}
477
478static void local_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
479{
480 seekdir(fs->dir.stream, off);
481}
482
483static 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
499static 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;
505#ifdef CONFIG_PREADV
506 ret = pwritev(fs->fd, iov, iovcnt, offset);
507#else
508 int err = lseek(fs->fd, offset, SEEK_SET);
509 if (err == -1) {
510 return err;
511 } else {
512 ret = writev(fs->fd, iov, iovcnt);
513 }
514#endif
515#ifdef CONFIG_SYNC_FILE_RANGE
516 if (ret > 0 && ctx->export_flags & V9FS_IMMEDIATE_WRITEOUT) {
517
518
519
520
521
522 sync_file_range(fs->fd, offset, ret,
523 SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE);
524 }
525#endif
526 return ret;
527}
528
529static int local_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
530{
531 char *dirpath = g_path_get_dirname(fs_path->data);
532 char *name = g_path_get_basename(fs_path->data);
533 int ret = -1;
534 int dirfd;
535
536 dirfd = local_opendir_nofollow(fs_ctx, dirpath);
537 if (dirfd == -1) {
538 goto out;
539 }
540
541 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
542 ret = local_set_xattrat(dirfd, name, credp);
543 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
544 ret = local_set_mapped_file_attrat(dirfd, name, credp);
545 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
546 fs_ctx->export_flags & V9FS_SM_NONE) {
547 ret = fchmodat_nofollow(dirfd, name, credp->fc_mode);
548 }
549 close_preserve_errno(dirfd);
550
551out:
552 g_free(dirpath);
553 g_free(name);
554 return ret;
555}
556
557static int local_mknod(FsContext *fs_ctx, V9fsPath *dir_path,
558 const char *name, FsCred *credp)
559{
560 int err = -1;
561 int dirfd;
562
563 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
564 if (dirfd == -1) {
565 return -1;
566 }
567
568 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
569 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
570 err = mknodat(dirfd, name, SM_LOCAL_MODE_BITS | S_IFREG, 0);
571 if (err == -1) {
572 goto out;
573 }
574
575 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
576 err = local_set_xattrat(dirfd, name, credp);
577 } else {
578 err = local_set_mapped_file_attrat(dirfd, name, credp);
579 }
580 if (err == -1) {
581 goto err_end;
582 }
583 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
584 fs_ctx->export_flags & V9FS_SM_NONE) {
585 err = mknodat(dirfd, name, credp->fc_mode, credp->fc_rdev);
586 if (err == -1) {
587 goto out;
588 }
589 err = local_set_cred_passthrough(fs_ctx, dirfd, name, credp);
590 if (err == -1) {
591 goto err_end;
592 }
593 }
594 goto out;
595
596err_end:
597 unlinkat_preserve_errno(dirfd, name, 0);
598out:
599 close_preserve_errno(dirfd);
600 return err;
601}
602
603static int local_mkdir(FsContext *fs_ctx, V9fsPath *dir_path,
604 const char *name, FsCred *credp)
605{
606 int err = -1;
607 int dirfd;
608
609 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
610 if (dirfd == -1) {
611 return -1;
612 }
613
614 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
615 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
616 err = mkdirat(dirfd, name, SM_LOCAL_DIR_MODE_BITS);
617 if (err == -1) {
618 goto out;
619 }
620 credp->fc_mode = credp->fc_mode | S_IFDIR;
621
622 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
623 err = local_set_xattrat(dirfd, name, credp);
624 } else {
625 err = local_set_mapped_file_attrat(dirfd, name, credp);
626 }
627 if (err == -1) {
628 goto err_end;
629 }
630 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
631 fs_ctx->export_flags & V9FS_SM_NONE) {
632 err = mkdirat(dirfd, name, credp->fc_mode);
633 if (err == -1) {
634 goto out;
635 }
636 err = local_set_cred_passthrough(fs_ctx, dirfd, name, credp);
637 if (err == -1) {
638 goto err_end;
639 }
640 }
641 goto out;
642
643err_end:
644 unlinkat_preserve_errno(dirfd, name, AT_REMOVEDIR);
645out:
646 close_preserve_errno(dirfd);
647 return err;
648}
649
650static int local_fstat(FsContext *fs_ctx, int fid_type,
651 V9fsFidOpenState *fs, struct stat *stbuf)
652{
653 int err, fd;
654
655 if (fid_type == P9_FID_DIR) {
656 fd = dirfd(fs->dir.stream);
657 } else {
658 fd = fs->fd;
659 }
660
661 err = fstat(fd, stbuf);
662 if (err) {
663 return err;
664 }
665 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
666
667 uid_t tmp_uid;
668 gid_t tmp_gid;
669 mode_t tmp_mode;
670 dev_t tmp_dev;
671
672 if (fgetxattr(fd, "user.virtfs.uid", &tmp_uid, sizeof(uid_t)) > 0) {
673 stbuf->st_uid = le32_to_cpu(tmp_uid);
674 }
675 if (fgetxattr(fd, "user.virtfs.gid", &tmp_gid, sizeof(gid_t)) > 0) {
676 stbuf->st_gid = le32_to_cpu(tmp_gid);
677 }
678 if (fgetxattr(fd, "user.virtfs.mode", &tmp_mode, sizeof(mode_t)) > 0) {
679 stbuf->st_mode = le32_to_cpu(tmp_mode);
680 }
681 if (fgetxattr(fd, "user.virtfs.rdev", &tmp_dev, sizeof(dev_t)) > 0) {
682 stbuf->st_rdev = le64_to_cpu(tmp_dev);
683 }
684 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
685 errno = EOPNOTSUPP;
686 return -1;
687 }
688 return err;
689}
690
691static int local_open2(FsContext *fs_ctx, V9fsPath *dir_path, const char *name,
692 int flags, FsCred *credp, V9fsFidOpenState *fs)
693{
694 int fd = -1;
695 int err = -1;
696 int dirfd;
697
698
699
700
701 flags |= O_NOFOLLOW;
702
703 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
704 if (dirfd == -1) {
705 return -1;
706 }
707
708
709 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
710 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
711 fd = openat_file(dirfd, name, flags, SM_LOCAL_MODE_BITS);
712 if (fd == -1) {
713 goto out;
714 }
715 credp->fc_mode = credp->fc_mode|S_IFREG;
716 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
717
718 err = local_set_xattrat(dirfd, name, credp);
719 } else {
720 err = local_set_mapped_file_attrat(dirfd, name, credp);
721 }
722 if (err == -1) {
723 goto err_end;
724 }
725 } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
726 (fs_ctx->export_flags & V9FS_SM_NONE)) {
727 fd = openat_file(dirfd, name, flags, credp->fc_mode);
728 if (fd == -1) {
729 goto out;
730 }
731 err = local_set_cred_passthrough(fs_ctx, dirfd, name, credp);
732 if (err == -1) {
733 goto err_end;
734 }
735 }
736 err = fd;
737 fs->fd = fd;
738 goto out;
739
740err_end:
741 unlinkat_preserve_errno(dirfd, name,
742 flags & O_DIRECTORY ? AT_REMOVEDIR : 0);
743 close_preserve_errno(fd);
744out:
745 close_preserve_errno(dirfd);
746 return err;
747}
748
749
750static int local_symlink(FsContext *fs_ctx, const char *oldpath,
751 V9fsPath *dir_path, const char *name, FsCred *credp)
752{
753 int err = -1;
754 int dirfd;
755
756 dirfd = local_opendir_nofollow(fs_ctx, dir_path->data);
757 if (dirfd == -1) {
758 return -1;
759 }
760
761
762 if (fs_ctx->export_flags & V9FS_SM_MAPPED ||
763 fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
764 int fd;
765 ssize_t oldpath_size, write_size;
766
767 fd = openat_file(dirfd, name, O_CREAT | O_EXCL | O_RDWR,
768 SM_LOCAL_MODE_BITS);
769 if (fd == -1) {
770 goto out;
771 }
772
773 oldpath_size = strlen(oldpath);
774 do {
775 write_size = write(fd, (void *)oldpath, oldpath_size);
776 } while (write_size == -1 && errno == EINTR);
777 close_preserve_errno(fd);
778
779 if (write_size != oldpath_size) {
780 goto err_end;
781 }
782
783 credp->fc_mode = credp->fc_mode | S_IFLNK;
784
785 if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
786 err = local_set_xattrat(dirfd, name, credp);
787 } else {
788 err = local_set_mapped_file_attrat(dirfd, name, credp);
789 }
790 if (err == -1) {
791 goto err_end;
792 }
793 } else if (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH ||
794 fs_ctx->export_flags & V9FS_SM_NONE) {
795 err = symlinkat(oldpath, dirfd, name);
796 if (err) {
797 goto out;
798 }
799 err = fchownat(dirfd, name, credp->fc_uid, credp->fc_gid,
800 AT_SYMLINK_NOFOLLOW);
801 if (err == -1) {
802
803
804
805
806 if ((fs_ctx->export_flags & V9FS_SEC_MASK) != V9FS_SM_NONE) {
807 goto err_end;
808 } else {
809 err = 0;
810 }
811 }
812 }
813 goto out;
814
815err_end:
816 unlinkat_preserve_errno(dirfd, name, 0);
817out:
818 close_preserve_errno(dirfd);
819 return err;
820}
821
822static int local_link(FsContext *ctx, V9fsPath *oldpath,
823 V9fsPath *dirpath, const char *name)
824{
825 char *odirpath = g_path_get_dirname(oldpath->data);
826 char *oname = g_path_get_basename(oldpath->data);
827 int ret = -1;
828 int odirfd, ndirfd;
829
830 odirfd = local_opendir_nofollow(ctx, odirpath);
831 if (odirfd == -1) {
832 goto out;
833 }
834
835 ndirfd = local_opendir_nofollow(ctx, dirpath->data);
836 if (ndirfd == -1) {
837 close_preserve_errno(odirfd);
838 goto out;
839 }
840
841 ret = linkat(odirfd, oname, ndirfd, name, 0);
842 if (ret < 0) {
843 goto out_close;
844 }
845
846
847 if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
848 int omap_dirfd, nmap_dirfd;
849
850 ret = mkdirat(ndirfd, VIRTFS_META_DIR, 0700);
851 if (ret < 0 && errno != EEXIST) {
852 goto err_undo_link;
853 }
854
855 omap_dirfd = openat_dir(odirfd, VIRTFS_META_DIR);
856 if (omap_dirfd == -1) {
857 goto err;
858 }
859
860 nmap_dirfd = openat_dir(ndirfd, VIRTFS_META_DIR);
861 if (nmap_dirfd == -1) {
862 close_preserve_errno(omap_dirfd);
863 goto err;
864 }
865
866 ret = linkat(omap_dirfd, oname, nmap_dirfd, name, 0);
867 close_preserve_errno(nmap_dirfd);
868 close_preserve_errno(omap_dirfd);
869 if (ret < 0 && errno != ENOENT) {
870 goto err_undo_link;
871 }
872
873 ret = 0;
874 }
875 goto out_close;
876
877err:
878 ret = -1;
879err_undo_link:
880 unlinkat_preserve_errno(ndirfd, name, 0);
881out_close:
882 close_preserve_errno(ndirfd);
883 close_preserve_errno(odirfd);
884out:
885 g_free(oname);
886 g_free(odirpath);
887 return ret;
888}
889
890static int local_truncate(FsContext *ctx, V9fsPath *fs_path, off_t size)
891{
892 int fd, ret;
893
894 fd = local_open_nofollow(ctx, fs_path->data, O_WRONLY, 0);
895 if (fd == -1) {
896 return -1;
897 }
898 ret = ftruncate(fd, size);
899 close_preserve_errno(fd);
900 return ret;
901}
902
903static int local_chown(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
904{
905 char *dirpath = g_path_get_dirname(fs_path->data);
906 char *name = g_path_get_basename(fs_path->data);
907 int ret = -1;
908 int dirfd;
909
910 dirfd = local_opendir_nofollow(fs_ctx, dirpath);
911 if (dirfd == -1) {
912 goto out;
913 }
914
915 if ((credp->fc_uid == -1 && credp->fc_gid == -1) ||
916 (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
917 (fs_ctx->export_flags & V9FS_SM_NONE)) {
918 ret = fchownat(dirfd, name, credp->fc_uid, credp->fc_gid,
919 AT_SYMLINK_NOFOLLOW);
920 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
921 ret = local_set_xattrat(dirfd, name, credp);
922 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
923 ret = local_set_mapped_file_attrat(dirfd, name, credp);
924 }
925
926 close_preserve_errno(dirfd);
927out:
928 g_free(name);
929 g_free(dirpath);
930 return ret;
931}
932
933static int local_utimensat(FsContext *s, V9fsPath *fs_path,
934 const struct timespec *buf)
935{
936 char *dirpath = g_path_get_dirname(fs_path->data);
937 char *name = g_path_get_basename(fs_path->data);
938 int dirfd, ret = -1;
939
940 dirfd = local_opendir_nofollow(s, dirpath);
941 if (dirfd == -1) {
942 goto out;
943 }
944
945 ret = utimensat(dirfd, name, buf, AT_SYMLINK_NOFOLLOW);
946 close_preserve_errno(dirfd);
947out:
948 g_free(dirpath);
949 g_free(name);
950 return ret;
951}
952
953static int local_unlinkat_common(FsContext *ctx, int dirfd, const char *name,
954 int flags)
955{
956 int ret = -1;
957
958 if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
959 int map_dirfd;
960
961 if (flags == AT_REMOVEDIR) {
962 int fd;
963
964 fd = openat_dir(dirfd, name);
965 if (fd == -1) {
966 goto err_out;
967 }
968
969
970
971
972 ret = unlinkat(fd, VIRTFS_META_DIR, AT_REMOVEDIR);
973 close_preserve_errno(fd);
974 if (ret < 0 && errno != ENOENT) {
975
976
977
978
979 goto err_out;
980 }
981 }
982
983
984
985
986 map_dirfd = openat_dir(dirfd, VIRTFS_META_DIR);
987 ret = unlinkat(map_dirfd, name, 0);
988 close_preserve_errno(map_dirfd);
989 if (ret < 0 && errno != ENOENT) {
990
991
992
993
994 goto err_out;
995 }
996 }
997
998 ret = unlinkat(dirfd, name, flags);
999err_out:
1000 return ret;
1001}
1002
1003static int local_remove(FsContext *ctx, const char *path)
1004{
1005 struct stat stbuf;
1006 char *dirpath = g_path_get_dirname(path);
1007 char *name = g_path_get_basename(path);
1008 int flags = 0;
1009 int dirfd;
1010 int err = -1;
1011
1012 dirfd = local_opendir_nofollow(ctx, dirpath);
1013 if (dirfd == -1) {
1014 goto out;
1015 }
1016
1017 if (fstatat(dirfd, path, &stbuf, AT_SYMLINK_NOFOLLOW) < 0) {
1018 goto err_out;
1019 }
1020
1021 if (S_ISDIR(stbuf.st_mode)) {
1022 flags |= AT_REMOVEDIR;
1023 }
1024
1025 err = local_unlinkat_common(ctx, dirfd, name, flags);
1026err_out:
1027 close_preserve_errno(dirfd);
1028out:
1029 g_free(name);
1030 g_free(dirpath);
1031 return err;
1032}
1033
1034static int local_fsync(FsContext *ctx, int fid_type,
1035 V9fsFidOpenState *fs, int datasync)
1036{
1037 int fd;
1038
1039 if (fid_type == P9_FID_DIR) {
1040 fd = dirfd(fs->dir.stream);
1041 } else {
1042 fd = fs->fd;
1043 }
1044
1045 if (datasync) {
1046 return qemu_fdatasync(fd);
1047 } else {
1048 return fsync(fd);
1049 }
1050}
1051
1052static int local_statfs(FsContext *s, V9fsPath *fs_path, struct statfs *stbuf)
1053{
1054 int fd, ret;
1055
1056 fd = local_open_nofollow(s, fs_path->data, O_RDONLY, 0);
1057 if (fd == -1) {
1058 return -1;
1059 }
1060 ret = fstatfs(fd, stbuf);
1061 close_preserve_errno(fd);
1062 return ret;
1063}
1064
1065static ssize_t local_lgetxattr(FsContext *ctx, V9fsPath *fs_path,
1066 const char *name, void *value, size_t size)
1067{
1068 char *path = fs_path->data;
1069
1070 return v9fs_get_xattr(ctx, path, name, value, size);
1071}
1072
1073static ssize_t local_llistxattr(FsContext *ctx, V9fsPath *fs_path,
1074 void *value, size_t size)
1075{
1076 char *path = fs_path->data;
1077
1078 return v9fs_list_xattr(ctx, path, value, size);
1079}
1080
1081static int local_lsetxattr(FsContext *ctx, V9fsPath *fs_path, const char *name,
1082 void *value, size_t size, int flags)
1083{
1084 char *path = fs_path->data;
1085
1086 return v9fs_set_xattr(ctx, path, name, value, size, flags);
1087}
1088
1089static int local_lremovexattr(FsContext *ctx, V9fsPath *fs_path,
1090 const char *name)
1091{
1092 char *path = fs_path->data;
1093
1094 return v9fs_remove_xattr(ctx, path, name);
1095}
1096
1097static int local_name_to_path(FsContext *ctx, V9fsPath *dir_path,
1098 const char *name, V9fsPath *target)
1099{
1100 if (dir_path) {
1101 v9fs_path_sprintf(target, "%s/%s", dir_path->data, name);
1102 } else {
1103 v9fs_path_sprintf(target, "%s", name);
1104 }
1105 return 0;
1106}
1107
1108static int local_renameat(FsContext *ctx, V9fsPath *olddir,
1109 const char *old_name, V9fsPath *newdir,
1110 const char *new_name)
1111{
1112 int ret;
1113 int odirfd, ndirfd;
1114
1115 odirfd = local_opendir_nofollow(ctx, olddir->data);
1116 if (odirfd == -1) {
1117 return -1;
1118 }
1119
1120 ndirfd = local_opendir_nofollow(ctx, newdir->data);
1121 if (ndirfd == -1) {
1122 close_preserve_errno(odirfd);
1123 return -1;
1124 }
1125
1126 ret = renameat(odirfd, old_name, ndirfd, new_name);
1127 if (ret < 0) {
1128 goto out;
1129 }
1130
1131 if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
1132 int omap_dirfd, nmap_dirfd;
1133
1134 ret = mkdirat(ndirfd, VIRTFS_META_DIR, 0700);
1135 if (ret < 0 && errno != EEXIST) {
1136 goto err_undo_rename;
1137 }
1138
1139 omap_dirfd = openat_dir(odirfd, VIRTFS_META_DIR);
1140 if (omap_dirfd == -1) {
1141 goto err;
1142 }
1143
1144 nmap_dirfd = openat_dir(ndirfd, VIRTFS_META_DIR);
1145 if (nmap_dirfd == -1) {
1146 close_preserve_errno(omap_dirfd);
1147 goto err;
1148 }
1149
1150
1151 ret = renameat(omap_dirfd, old_name, nmap_dirfd, new_name);
1152 close_preserve_errno(nmap_dirfd);
1153 close_preserve_errno(omap_dirfd);
1154 if (ret < 0 && errno != ENOENT) {
1155 goto err_undo_rename;
1156 }
1157
1158 ret = 0;
1159 }
1160 goto out;
1161
1162err:
1163 ret = -1;
1164err_undo_rename:
1165 renameat_preserve_errno(ndirfd, new_name, odirfd, old_name);
1166out:
1167 close_preserve_errno(ndirfd);
1168 close_preserve_errno(odirfd);
1169 return ret;
1170}
1171
1172static void v9fs_path_init_dirname(V9fsPath *path, const char *str)
1173{
1174 path->data = g_path_get_dirname(str);
1175 path->size = strlen(path->data) + 1;
1176}
1177
1178static int local_rename(FsContext *ctx, const char *oldpath,
1179 const char *newpath)
1180{
1181 int err;
1182 char *oname = g_path_get_basename(oldpath);
1183 char *nname = g_path_get_basename(newpath);
1184 V9fsPath olddir, newdir;
1185
1186 v9fs_path_init_dirname(&olddir, oldpath);
1187 v9fs_path_init_dirname(&newdir, newpath);
1188
1189 err = local_renameat(ctx, &olddir, oname, &newdir, nname);
1190
1191 v9fs_path_free(&newdir);
1192 v9fs_path_free(&olddir);
1193 g_free(nname);
1194 g_free(oname);
1195
1196 return err;
1197}
1198
1199static int local_unlinkat(FsContext *ctx, V9fsPath *dir,
1200 const char *name, int flags)
1201{
1202 int ret;
1203 int dirfd;
1204
1205 dirfd = local_opendir_nofollow(ctx, dir->data);
1206 if (dirfd == -1) {
1207 return -1;
1208 }
1209
1210 ret = local_unlinkat_common(ctx, dirfd, name, flags);
1211 close_preserve_errno(dirfd);
1212 return ret;
1213}
1214
1215static int local_ioc_getversion(FsContext *ctx, V9fsPath *path,
1216 mode_t st_mode, uint64_t *st_gen)
1217{
1218#ifdef FS_IOC_GETVERSION
1219 int err;
1220 V9fsFidOpenState fid_open;
1221
1222
1223
1224
1225
1226 if (!S_ISREG(st_mode) && !S_ISDIR(st_mode)) {
1227 errno = ENOTTY;
1228 return -1;
1229 }
1230 err = local_open(ctx, path, O_RDONLY, &fid_open);
1231 if (err < 0) {
1232 return err;
1233 }
1234 err = ioctl(fid_open.fd, FS_IOC_GETVERSION, st_gen);
1235 local_close(ctx, &fid_open);
1236 return err;
1237#else
1238 errno = ENOTTY;
1239 return -1;
1240#endif
1241}
1242
1243static int local_init(FsContext *ctx)
1244{
1245 struct statfs stbuf;
1246 LocalData *data = g_malloc(sizeof(*data));
1247
1248 data->mountfd = open(ctx->fs_root, O_DIRECTORY | O_RDONLY);
1249 if (data->mountfd == -1) {
1250 goto err;
1251 }
1252
1253#ifdef FS_IOC_GETVERSION
1254
1255
1256
1257 if (fstatfs(data->mountfd, &stbuf) < 0) {
1258 close_preserve_errno(data->mountfd);
1259 goto err;
1260 }
1261 switch (stbuf.f_type) {
1262 case EXT2_SUPER_MAGIC:
1263 case BTRFS_SUPER_MAGIC:
1264 case REISERFS_SUPER_MAGIC:
1265 case XFS_SUPER_MAGIC:
1266 ctx->exops.get_st_gen = local_ioc_getversion;
1267 break;
1268 }
1269#endif
1270
1271 if (ctx->export_flags & V9FS_SM_PASSTHROUGH) {
1272 ctx->xops = passthrough_xattr_ops;
1273 } else if (ctx->export_flags & V9FS_SM_MAPPED) {
1274 ctx->xops = mapped_xattr_ops;
1275 } else if (ctx->export_flags & V9FS_SM_NONE) {
1276 ctx->xops = none_xattr_ops;
1277 } else if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
1278
1279
1280
1281
1282 ctx->xops = passthrough_xattr_ops;
1283 }
1284 ctx->export_flags |= V9FS_PATHNAME_FSCONTEXT;
1285
1286 ctx->private = data;
1287 return 0;
1288
1289err:
1290 g_free(data);
1291 return -1;
1292}
1293
1294static void local_cleanup(FsContext *ctx)
1295{
1296 LocalData *data = ctx->private;
1297
1298 close(data->mountfd);
1299 g_free(data);
1300}
1301
1302static int local_parse_opts(QemuOpts *opts, struct FsDriverEntry *fse)
1303{
1304 const char *sec_model = qemu_opt_get(opts, "security_model");
1305 const char *path = qemu_opt_get(opts, "path");
1306
1307 if (!sec_model) {
1308 error_report("Security model not specified, local fs needs security model");
1309 error_printf("valid options are:"
1310 "\tsecurity_model=[passthrough|mapped-xattr|mapped-file|none]\n");
1311 return -1;
1312 }
1313
1314 if (!strcmp(sec_model, "passthrough")) {
1315 fse->export_flags |= V9FS_SM_PASSTHROUGH;
1316 } else if (!strcmp(sec_model, "mapped") ||
1317 !strcmp(sec_model, "mapped-xattr")) {
1318 fse->export_flags |= V9FS_SM_MAPPED;
1319 } else if (!strcmp(sec_model, "none")) {
1320 fse->export_flags |= V9FS_SM_NONE;
1321 } else if (!strcmp(sec_model, "mapped-file")) {
1322 fse->export_flags |= V9FS_SM_MAPPED_FILE;
1323 } else {
1324 error_report("Invalid security model %s specified", sec_model);
1325 error_printf("valid options are:"
1326 "\t[passthrough|mapped-xattr|mapped-file|none]\n");
1327 return -1;
1328 }
1329
1330 if (!path) {
1331 error_report("fsdev: No path specified");
1332 return -1;
1333 }
1334 fse->path = g_strdup(path);
1335
1336 return 0;
1337}
1338
1339FileOperations local_ops = {
1340 .parse_opts = local_parse_opts,
1341 .init = local_init,
1342 .cleanup = local_cleanup,
1343 .lstat = local_lstat,
1344 .readlink = local_readlink,
1345 .close = local_close,
1346 .closedir = local_closedir,
1347 .open = local_open,
1348 .opendir = local_opendir,
1349 .rewinddir = local_rewinddir,
1350 .telldir = local_telldir,
1351 .readdir = local_readdir,
1352 .seekdir = local_seekdir,
1353 .preadv = local_preadv,
1354 .pwritev = local_pwritev,
1355 .chmod = local_chmod,
1356 .mknod = local_mknod,
1357 .mkdir = local_mkdir,
1358 .fstat = local_fstat,
1359 .open2 = local_open2,
1360 .symlink = local_symlink,
1361 .link = local_link,
1362 .truncate = local_truncate,
1363 .rename = local_rename,
1364 .chown = local_chown,
1365 .utimensat = local_utimensat,
1366 .remove = local_remove,
1367 .fsync = local_fsync,
1368 .statfs = local_statfs,
1369 .lgetxattr = local_lgetxattr,
1370 .llistxattr = local_llistxattr,
1371 .lsetxattr = local_lsetxattr,
1372 .lremovexattr = local_lremovexattr,
1373 .name_to_path = local_name_to_path,
1374 .renameat = local_renameat,
1375 .unlinkat = local_unlinkat,
1376};
1377