@samitouri / QOSamiQemu
Code Commits Issues Pulls Sessions CI/CD
master
master
h 928 lines 20 KB
Raw
1 /*
2 * file related system call shims and definitions
3 *
4 * Copyright (c) 2013 Stacey D. Son
5 *
6 * SPDX-License-Identifier: GPL-2.0-or-later
7 */
8 #ifndef BSD_FILE_H
9 #define BSD_FILE_H
10
11 #include "qemu/path.h"
12
13 #define LOCK_PATH(p, arg) \
14 do { \
15 (p) = lock_user_string(arg); \
16 if ((p) == NULL) { \
17 return -TARGET_EFAULT; \
18 } \
19 } while (0)
20
21 #define UNLOCK_PATH(p, arg) unlock_user(p, arg, 0)
22
23 #define LOCK_PATH2(p1, arg1, p2, arg2) \
24 do { \
25 (p1) = lock_user_string(arg1); \
26 if ((p1) == NULL) { \
27 return -TARGET_EFAULT; \
28 } \
29 (p2) = lock_user_string(arg2); \
30 if ((p2) == NULL) { \
31 unlock_user(p1, arg1, 0); \
32 return -TARGET_EFAULT; \
33 } \
34 } while (0)
35
36 #define UNLOCK_PATH2(p1, arg1, p2, arg2) \
37 do { \
38 unlock_user(p2, arg2, 0); \
39 unlock_user(p1, arg1, 0); \
40 } while (0)
41
42 struct iovec *lock_iovec(int type, abi_ulong target_addr, int count, int copy);
43 void unlock_iovec(struct iovec *vec, abi_ulong target_addr, int count, int copy);
44
45 int safe_open(const char *path, int flags, mode_t mode);
46 int safe_openat(int fd, const char *path, int flags, mode_t mode);
47
48 ssize_t safe_read(int fd, void *buf, size_t nbytes);
49 ssize_t safe_pread(int fd, void *buf, size_t nbytes, off_t offset);
50 ssize_t safe_readv(int fd, const struct iovec *iov, int iovcnt);
51 ssize_t safe_preadv(int fd, const struct iovec *iov, int iovcnt, off_t offset);
52
53 ssize_t safe_write(int fd, void *buf, size_t nbytes);
54 ssize_t safe_pwrite(int fd, void *buf, size_t nbytes, off_t offset);
55 ssize_t safe_writev(int fd, const struct iovec *iov, int iovcnt);
56 ssize_t safe_pwritev(int fd, const struct iovec *iov, int iovcnt, off_t offset);
57
58 /* read(2) */
59 static abi_long do_bsd_read(abi_long arg1, abi_long arg2, abi_long arg3)
60 {
61 abi_long ret;
62 void *p;
63
64 p = lock_user(VERIFY_WRITE, arg2, arg3, 0);
65 if (p == NULL) {
66 return -TARGET_EFAULT;
67 }
68 ret = get_errno(safe_read(arg1, p, arg3));
69 unlock_user(p, arg2, ret);
70
71 return ret;
72 }
73
74 /* pread(2) */
75 static abi_long do_bsd_pread(void *cpu_env, abi_long arg1,
76 abi_long arg2, abi_long arg3, abi_long arg4, abi_long arg5, abi_long arg6)
77 {
78 abi_long ret;
79 void *p;
80
81 p = lock_user(VERIFY_WRITE, arg2, arg3, 0);
82 if (p == NULL) {
83 return -TARGET_EFAULT;
84 }
85 if (regpairs_aligned(cpu_env) != 0) {
86 arg4 = arg5;
87 arg5 = arg6;
88 }
89 ret = get_errno(safe_pread(arg1, p, arg3, target_arg64(arg4, arg5)));
90 unlock_user(p, arg2, ret);
91
92 return ret;
93 }
94
95 /* readv(2) */
96 static abi_long do_bsd_readv(abi_long arg1, abi_long arg2, abi_long arg3)
97 {
98 abi_long ret;
99 struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0);
100
101 if (vec != NULL) {
102 ret = get_errno(safe_readv(arg1, vec, arg3));
103 unlock_iovec(vec, arg2, arg3, 1);
104 } else {
105 ret = -host_to_target_errno(errno);
106 }
107
108 return ret;
109 }
110
111 /* preadv(2) */
112 static abi_long do_bsd_preadv(void *cpu_env, abi_long arg1,
113 abi_long arg2, abi_long arg3, abi_long arg4, abi_long arg5, abi_long arg6)
114 {
115 abi_long ret;
116 struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 1);
117
118 if (vec != NULL) {
119 if (regpairs_aligned(cpu_env) != 0) {
120 arg4 = arg5;
121 arg5 = arg6;
122 }
123 ret = get_errno(safe_preadv(arg1, vec, arg3, target_arg64(arg4, arg5)));
124 unlock_iovec(vec, arg2, arg3, 0);
125 } else {
126 ret = -host_to_target_errno(errno);
127 }
128
129 return ret;
130 }
131
132 /* write(2) */
133 static abi_long do_bsd_write(abi_long arg1, abi_long arg2, abi_long arg3)
134 {
135 abi_long nbytes, ret;
136 void *p;
137
138 /* nbytes < 0 implies that it was larger than SIZE_MAX. */
139 nbytes = arg3;
140 if (nbytes < 0) {
141 return -TARGET_EINVAL;
142 }
143 p = lock_user(VERIFY_READ, arg2, nbytes, 1);
144 if (p == NULL) {
145 return -TARGET_EFAULT;
146 }
147 ret = get_errno(safe_write(arg1, p, arg3));
148 unlock_user(p, arg2, 0);
149
150 return ret;
151 }
152
153 /* pwrite(2) */
154 static abi_long do_bsd_pwrite(void *cpu_env, abi_long arg1,
155 abi_long arg2, abi_long arg3, abi_long arg4, abi_long arg5, abi_long arg6)
156 {
157 abi_long ret;
158 void *p;
159
160 p = lock_user(VERIFY_READ, arg2, arg3, 1);
161 if (p == NULL) {
162 return -TARGET_EFAULT;
163 }
164 if (regpairs_aligned(cpu_env) != 0) {
165 arg4 = arg5;
166 arg5 = arg6;
167 }
168 ret = get_errno(safe_pwrite(arg1, p, arg3, target_arg64(arg4, arg5)));
169 unlock_user(p, arg2, 0);
170
171 return ret;
172 }
173
174 /* writev(2) */
175 static abi_long do_bsd_writev(abi_long arg1, abi_long arg2, abi_long arg3)
176 {
177 abi_long ret;
178 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
179
180 if (vec != NULL) {
181 ret = get_errno(safe_writev(arg1, vec, arg3));
182 unlock_iovec(vec, arg2, arg3, 0);
183 } else {
184 ret = -host_to_target_errno(errno);
185 }
186
187 return ret;
188 }
189
190 /* pwritev(2) */
191 static abi_long do_bsd_pwritev(void *cpu_env, abi_long arg1,
192 abi_long arg2, abi_long arg3, abi_long arg4, abi_long arg5, abi_long arg6)
193 {
194 abi_long ret;
195 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
196
197 if (vec != NULL) {
198 if (regpairs_aligned(cpu_env) != 0) {
199 arg4 = arg5;
200 arg5 = arg6;
201 }
202 ret = get_errno(safe_pwritev(arg1, vec, arg3, target_arg64(arg4, arg5)));
203 unlock_iovec(vec, arg2, arg3, 0);
204 } else {
205 ret = -host_to_target_errno(errno);
206 }
207
208 return ret;
209 }
210
211 /* open(2) */
212 static abi_long do_bsd_open(abi_long arg1, abi_long arg2, abi_long arg3)
213 {
214 abi_long ret;
215 void *p;
216
217 LOCK_PATH(p, arg1);
218 ret = get_errno(safe_open(path(p), target_to_host_bitmask(arg2,
219 fcntl_flags_tbl), arg3));
220 UNLOCK_PATH(p, arg1);
221
222 return ret;
223 }
224
225 /* openat(2) */
226 static abi_long do_bsd_openat(abi_long arg1, abi_long arg2,
227 abi_long arg3, abi_long arg4)
228 {
229 abi_long ret;
230 void *p;
231
232 LOCK_PATH(p, arg2);
233 ret = get_errno(safe_openat(arg1, path(p),
234 target_to_host_bitmask(arg3, fcntl_flags_tbl), arg4));
235 UNLOCK_PATH(p, arg2);
236
237 return ret;
238 }
239
240 /* close(2) */
241 static abi_long do_bsd_close(abi_long arg1)
242 {
243 return get_errno(close(arg1));
244 }
245
246 /* fdatasync(2) */
247 static abi_long do_bsd_fdatasync(abi_long arg1)
248 {
249 return get_errno(fdatasync(arg1));
250 }
251
252 /* fsync(2) */
253 static abi_long do_bsd_fsync(abi_long arg1)
254 {
255 return get_errno(fsync(arg1));
256 }
257
258 /* closefrom(2) */
259 static abi_long do_bsd_closefrom(abi_long arg1)
260 {
261 closefrom(arg1); /* returns void */
262 return get_errno(0);
263 }
264
265 /* revoke(2) */
266 static abi_long do_bsd_revoke(abi_long arg1)
267 {
268 abi_long ret;
269 void *p;
270
271 LOCK_PATH(p, arg1);
272 ret = get_errno(revoke(p)); /* XXX path(p)? */
273 UNLOCK_PATH(p, arg1);
274
275 return ret;
276 }
277
278 /* access(2) */
279 static abi_long do_bsd_access(abi_long arg1, abi_long arg2)
280 {
281 abi_long ret;
282 void *p;
283
284 LOCK_PATH(p, arg1);
285 ret = get_errno(access(path(p), arg2));
286 UNLOCK_PATH(p, arg1);
287
288 return ret;
289 }
290
291 /* eaccess(2) */
292 static abi_long do_bsd_eaccess(abi_long arg1, abi_long arg2)
293 {
294 abi_long ret;
295 void *p;
296
297 LOCK_PATH(p, arg1);
298 ret = get_errno(eaccess(path(p), arg2));
299 UNLOCK_PATH(p, arg1);
300
301 return ret;
302 }
303
304 /* faccessat(2) */
305 static abi_long do_bsd_faccessat(abi_long arg1, abi_long arg2,
306 abi_long arg3, abi_long arg4)
307 {
308 abi_long ret;
309 void *p;
310
311 LOCK_PATH(p, arg2);
312 ret = get_errno(faccessat(arg1, p, arg3, arg4)); /* XXX path(p)? */
313 UNLOCK_PATH(p, arg2);
314
315 return ret;
316 }
317
318 /* chdir(2) */
319 static abi_long do_bsd_chdir(abi_long arg1)
320 {
321 abi_long ret;
322 void *p;
323
324 LOCK_PATH(p, arg1);
325 ret = get_errno(chdir(p)); /* XXX path(p)? */
326 UNLOCK_PATH(p, arg1);
327
328 return ret;
329 }
330
331 /* fchdir(2) */
332 static abi_long do_bsd_fchdir(abi_long arg1)
333 {
334 return get_errno(fchdir(arg1));
335 }
336
337 /* rename(2) */
338 static abi_long do_bsd_rename(abi_long arg1, abi_long arg2)
339 {
340 abi_long ret;
341 void *p1, *p2;
342
343 LOCK_PATH2(p1, arg1, p2, arg2);
344 ret = get_errno(rename(p1, p2)); /* XXX path(p1), path(p2) */
345 UNLOCK_PATH2(p1, arg1, p2, arg2);
346
347 return ret;
348 }
349
350 /* renameat(2) */
351 static abi_long do_bsd_renameat(abi_long arg1, abi_long arg2,
352 abi_long arg3, abi_long arg4)
353 {
354 abi_long ret;
355 void *p1, *p2;
356
357 LOCK_PATH2(p1, arg2, p2, arg4);
358 ret = get_errno(renameat(arg1, p1, arg3, p2));
359 UNLOCK_PATH2(p1, arg2, p2, arg4);
360
361 return ret;
362 }
363
364 /* link(2) */
365 static abi_long do_bsd_link(abi_long arg1, abi_long arg2)
366 {
367 abi_long ret;
368 void *p1, *p2;
369
370 LOCK_PATH2(p1, arg1, p2, arg2);
371 ret = get_errno(link(p1, p2)); /* XXX path(p1), path(p2) */
372 UNLOCK_PATH2(p1, arg1, p2, arg2);
373
374 return ret;
375 }
376
377 /* linkat(2) */
378 static abi_long do_bsd_linkat(abi_long arg1, abi_long arg2,
379 abi_long arg3, abi_long arg4, abi_long arg5)
380 {
381 abi_long ret;
382 void *p1, *p2;
383
384 LOCK_PATH2(p1, arg2, p2, arg4);
385 ret = get_errno(linkat(arg1, p1, arg3, p2, arg5));
386 UNLOCK_PATH2(p1, arg2, p2, arg4);
387
388 return ret;
389 }
390
391 /* unlink(2) */
392 static abi_long do_bsd_unlink(abi_long arg1)
393 {
394 abi_long ret;
395 void *p;
396
397 LOCK_PATH(p, arg1);
398 ret = get_errno(unlink(p)); /* XXX path(p) */
399 UNLOCK_PATH(p, arg1);
400
401 return ret;
402 }
403
404 /* unlinkat(2) */
405 static abi_long do_bsd_unlinkat(abi_long arg1, abi_long arg2,
406 abi_long arg3)
407 {
408 abi_long ret;
409 void *p;
410
411 LOCK_PATH(p, arg2);
412 ret = get_errno(unlinkat(arg1, p, arg3)); /* XXX path(p) */
413 UNLOCK_PATH(p, arg2);
414
415 return ret;
416 }
417
418 /* mkdir(2) */
419 static abi_long do_bsd_mkdir(abi_long arg1, abi_long arg2)
420 {
421 abi_long ret;
422 void *p;
423
424 LOCK_PATH(p, arg1);
425 ret = get_errno(mkdir(p, arg2)); /* XXX path(p) */
426 UNLOCK_PATH(p, arg1);
427
428 return ret;
429 }
430
431 /* mkdirat(2) */
432 static abi_long do_bsd_mkdirat(abi_long arg1, abi_long arg2,
433 abi_long arg3)
434 {
435 abi_long ret;
436 void *p;
437
438 LOCK_PATH(p, arg2);
439 ret = get_errno(mkdirat(arg1, p, arg3));
440 UNLOCK_PATH(p, arg2);
441
442 return ret;
443 }
444
445 /* rmdir(2) */
446 static abi_long do_bsd_rmdir(abi_long arg1)
447 {
448 abi_long ret;
449 void *p;
450
451 LOCK_PATH(p, arg1);
452 ret = get_errno(rmdir(p)); /* XXX path(p)? */
453 UNLOCK_PATH(p, arg1);
454
455 return ret;
456 }
457
458 /* undocumented __getcwd(char *buf, size_t len) system call */
459 static abi_long do_bsd___getcwd(abi_long arg1, abi_long arg2)
460 {
461 abi_long ret;
462 void *p;
463
464 p = lock_user(VERIFY_WRITE, arg1, arg2, 0);
465 if (p == NULL) {
466 return -TARGET_EFAULT;
467 }
468 ret = safe_syscall(SYS___getcwd, p, arg2);
469 unlock_user(p, arg1, ret == 0 ? strlen(p) + 1 : 0);
470
471 return get_errno(ret);
472 }
473
474 /* dup(2) */
475 static abi_long do_bsd_dup(abi_long arg1)
476 {
477 return get_errno(dup(arg1));
478 }
479
480 /* dup2(2) */
481 static abi_long do_bsd_dup2(abi_long arg1, abi_long arg2)
482 {
483 return get_errno(dup2(arg1, arg2));
484 }
485
486 /* truncate(2) */
487 static abi_long do_bsd_truncate(void *cpu_env, abi_long arg1,
488 abi_long arg2, abi_long arg3, abi_long arg4)
489 {
490 abi_long ret;
491 void *p;
492
493 LOCK_PATH(p, arg1);
494 if (regpairs_aligned(cpu_env) != 0) {
495 arg2 = arg3;
496 arg3 = arg4;
497 }
498 ret = get_errno(truncate(p, target_arg64(arg2, arg3)));
499 UNLOCK_PATH(p, arg1);
500
501 return ret;
502 }
503
504 /* ftruncate(2) */
505 static abi_long do_bsd_ftruncate(void *cpu_env, abi_long arg1,
506 abi_long arg2, abi_long arg3, abi_long arg4)
507 {
508 if (regpairs_aligned(cpu_env) != 0) {
509 arg2 = arg3;
510 arg3 = arg4;
511 }
512 return get_errno(ftruncate(arg1, target_arg64(arg2, arg3)));
513 }
514
515 /* acct(2) */
516 static abi_long do_bsd_acct(abi_long arg1)
517 {
518 abi_long ret;
519 void *p;
520
521 if (arg1 == 0) {
522 ret = get_errno(acct(NULL));
523 } else {
524 LOCK_PATH(p, arg1);
525 ret = get_errno(acct(path(p)));
526 UNLOCK_PATH(p, arg1);
527 }
528 return ret;
529 }
530
531 /* sync(2) */
532 static abi_long do_bsd_sync(void)
533 {
534 sync();
535 return 0;
536 }
537
538 /* mount(2) */
539 static abi_long do_bsd_mount(abi_long arg1, abi_long arg2, abi_long arg3,
540 abi_long arg4)
541 {
542 abi_long ret;
543 void *p1, *p2;
544
545 LOCK_PATH2(p1, arg1, p2, arg2);
546 /*
547 * XXX arg4 should be locked, but it isn't clear how to do that since it may
548 * be not be a NULL-terminated string.
549 */
550 if (arg4 == 0) {
551 ret = get_errno(mount(p1, p2, arg3, NULL)); /* XXX path(p2)? */
552 } else {
553 ret = get_errno(mount(p1, p2, arg3, g2h_untagged(arg4))); /* XXX path(p2)? */
554 }
555 UNLOCK_PATH2(p1, arg1, p2, arg2);
556
557 return ret;
558 }
559
560 /* unmount(2) */
561 static abi_long do_bsd_unmount(abi_long arg1, abi_long arg2)
562 {
563 abi_long ret;
564 void *p;
565
566 LOCK_PATH(p, arg1);
567 ret = get_errno(unmount(p, arg2)); /* XXX path(p)? */
568 UNLOCK_PATH(p, arg1);
569
570 return ret;
571 }
572
573 /* nmount(2) */
574 static abi_long do_bsd_nmount(abi_long arg1, abi_long count,
575 abi_long flags)
576 {
577 abi_long ret;
578 struct iovec *vec = lock_iovec(VERIFY_READ, arg1, count, 1);
579
580 if (vec != NULL) {
581 ret = get_errno(nmount(vec, count, flags));
582 unlock_iovec(vec, arg1, count, 0);
583 } else {
584 return -TARGET_EFAULT;
585 }
586
587 return ret;
588 }
589
590 /* symlink(2) */
591 static abi_long do_bsd_symlink(abi_long arg1, abi_long arg2)
592 {
593 abi_long ret;
594 void *p1, *p2;
595
596 LOCK_PATH2(p1, arg1, p2, arg2);
597 ret = get_errno(symlink(p1, p2)); /* XXX path(p1), path(p2) */
598 UNLOCK_PATH2(p1, arg1, p2, arg2);
599
600 return ret;
601 }
602
603 /* symlinkat(2) */
604 static abi_long do_bsd_symlinkat(abi_long arg1, abi_long arg2,
605 abi_long arg3)
606 {
607 abi_long ret;
608 void *p1, *p2;
609
610 LOCK_PATH2(p1, arg1, p2, arg3);
611 ret = get_errno(symlinkat(p1, arg2, p2)); /* XXX path(p1), path(p2) */
612 UNLOCK_PATH2(p1, arg1, p2, arg3);
613
614 return ret;
615 }
616
617 /* readlink(2) */
618 static abi_long do_bsd_readlink(CPUArchState *env, abi_long arg1,
619 abi_long arg2, abi_long arg3)
620 {
621 abi_long ret;
622 void *p1, *p2;
623
624 LOCK_PATH(p1, arg1);
625 p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0);
626 if (p2 == NULL) {
627 UNLOCK_PATH(p1, arg1);
628 return -TARGET_EFAULT;
629 }
630 if (strcmp(p1, "/proc/curproc/file") == 0) {
631 CPUState *cpu = env_cpu(env);
632 TaskState *ts = get_task_state(cpu);
633 strncpy(p2, ts->bprm->fullpath, arg3);
634 ret = MIN((abi_long)strlen(ts->bprm->fullpath), arg3);
635 } else {
636 ret = get_errno(readlink(path(p1), p2, arg3));
637 }
638 unlock_user(p2, arg2, ret);
639 UNLOCK_PATH(p1, arg1);
640
641 return ret;
642 }
643
644 /* readlinkat(2) */
645 static abi_long do_bsd_readlinkat(abi_long arg1, abi_long arg2,
646 abi_long arg3, abi_long arg4)
647 {
648 abi_long ret;
649 void *p1, *p2;
650
651 LOCK_PATH(p1, arg2);
652 p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0);
653 if (p2 == NULL) {
654 UNLOCK_PATH(p1, arg2);
655 return -TARGET_EFAULT;
656 }
657 ret = get_errno(readlinkat(arg1, p1, p2, arg4));
658 unlock_user(p2, arg3, ret);
659 UNLOCK_PATH(p1, arg2);
660
661 return ret;
662 }
663
664 /* chmod(2) */
665 static abi_long do_bsd_chmod(abi_long arg1, abi_long arg2)
666 {
667 abi_long ret;
668 void *p;
669
670 LOCK_PATH(p, arg1);
671 ret = get_errno(chmod(p, arg2)); /* XXX path(p)? */
672 UNLOCK_PATH(p, arg1);
673
674 return ret;
675 }
676
677 /* fchmod(2) */
678 static abi_long do_bsd_fchmod(abi_long arg1, abi_long arg2)
679 {
680 return get_errno(fchmod(arg1, arg2));
681 }
682
683 /* lchmod(2) */
684 static abi_long do_bsd_lchmod(abi_long arg1, abi_long arg2)
685 {
686 abi_long ret;
687 void *p;
688
689 LOCK_PATH(p, arg1);
690 ret = get_errno(lchmod(p, arg2)); /* XXX path(p)? */
691 UNLOCK_PATH(p, arg1);
692
693 return ret;
694 }
695
696 /* fchmodat(2) */
697 static abi_long do_bsd_fchmodat(abi_long arg1, abi_long arg2,
698 abi_long arg3, abi_long arg4)
699 {
700 abi_long ret;
701 void *p;
702
703 LOCK_PATH(p, arg2);
704 ret = get_errno(fchmodat(arg1, p, arg3, arg4));
705 UNLOCK_PATH(p, arg2);
706
707 return ret;
708 }
709
710 /* pre-ino64 mknod(2) */
711 static abi_long do_bsd_freebsd11_mknod(abi_long arg1, abi_long arg2, abi_long arg3)
712 {
713 abi_long ret;
714 void *p;
715
716 LOCK_PATH(p, arg1);
717 ret = get_errno(syscall(SYS_freebsd11_mknod, p, arg2, arg3));
718 UNLOCK_PATH(p, arg1);
719
720 return ret;
721 }
722
723 /* pre-ino64 mknodat(2) */
724 static abi_long do_bsd_freebsd11_mknodat(abi_long arg1, abi_long arg2,
725 abi_long arg3, abi_long arg4)
726 {
727 abi_long ret;
728 void *p;
729
730 LOCK_PATH(p, arg2);
731 ret = get_errno(syscall(SYS_freebsd11_mknodat, arg1, p, arg3, arg4));
732 UNLOCK_PATH(p, arg2);
733
734 return ret;
735 }
736
737 /* post-ino64 mknodat(2) */
738 static abi_long do_bsd_mknodat(void *cpu_env, abi_long arg1,
739 abi_long arg2, abi_long arg3, abi_long arg4, abi_long arg5,
740 abi_long arg6)
741 {
742 abi_long ret;
743 void *p;
744
745 LOCK_PATH(p, arg2);
746 /* 32-bit arch's use two 32 registers for 64 bit return value */
747 if (regpairs_aligned(cpu_env) != 0) {
748 ret = get_errno(mknodat(arg1, p, arg3, target_arg64(arg5, arg6)));
749 } else {
750 ret = get_errno(mknodat(arg1, p, arg3, target_arg64(arg4, arg5)));
751 }
752 UNLOCK_PATH(p, arg2);
753
754 return ret;
755 }
756
757 /* chown(2) */
758 static abi_long do_bsd_chown(abi_long arg1, abi_long arg2, abi_long arg3)
759 {
760 abi_long ret;
761 void *p;
762
763 LOCK_PATH(p, arg1);
764 ret = get_errno(chown(p, arg2, arg3)); /* XXX path(p)? */
765 UNLOCK_PATH(p, arg1);
766
767 return ret;
768 }
769
770 /* fchown(2) */
771 static abi_long do_bsd_fchown(abi_long arg1, abi_long arg2,
772 abi_long arg3)
773 {
774 return get_errno(fchown(arg1, arg2, arg3));
775 }
776
777 /* lchown(2) */
778 static abi_long do_bsd_lchown(abi_long arg1, abi_long arg2,
779 abi_long arg3)
780 {
781 abi_long ret;
782 void *p;
783
784 LOCK_PATH(p, arg1);
785 ret = get_errno(lchown(p, arg2, arg3)); /* XXX path(p)? */
786 UNLOCK_PATH(p, arg1);
787
788 return ret;
789 }
790
791 /* fchownat(2) */
792 static abi_long do_bsd_fchownat(abi_long arg1, abi_long arg2,
793 abi_long arg3, abi_long arg4, abi_long arg5)
794 {
795 abi_long ret;
796 void *p;
797
798 LOCK_PATH(p, arg2);
799 ret = get_errno(fchownat(arg1, p, arg3, arg4, arg5)); /* XXX path(p)? */
800 UNLOCK_PATH(p, arg2);
801
802 return ret;
803 }
804
805 /* chflags(2) */
806 static abi_long do_bsd_chflags(abi_long arg1, abi_long arg2)
807 {
808 abi_long ret;
809 void *p;
810
811 LOCK_PATH(p, arg1);
812 ret = get_errno(chflags(p, arg2)); /* XXX path(p)? */
813 UNLOCK_PATH(p, arg1);
814
815 return ret;
816 }
817
818 /* lchflags(2) */
819 static abi_long do_bsd_lchflags(abi_long arg1, abi_long arg2)
820 {
821 abi_long ret;
822 void *p;
823
824 LOCK_PATH(p, arg1);
825 ret = get_errno(lchflags(p, arg2)); /* XXX path(p)? */
826 UNLOCK_PATH(p, arg1);
827
828 return ret;
829 }
830
831 /* fchflags(2) */
832 static abi_long do_bsd_fchflags(abi_long arg1, abi_long arg2)
833 {
834 return get_errno(fchflags(arg1, arg2));
835 }
836
837 /* chroot(2) */
838 static abi_long do_bsd_chroot(abi_long arg1)
839 {
840 abi_long ret;
841 void *p;
842
843 LOCK_PATH(p, arg1);
844 ret = get_errno(chroot(p)); /* XXX path(p)? */
845 UNLOCK_PATH(p, arg1);
846
847 return ret;
848 }
849
850 /* flock(2) */
851 static abi_long do_bsd_flock(abi_long arg1, abi_long arg2)
852 {
853 return get_errno(flock(arg1, arg2));
854 }
855
856 /* mkfifo(2) */
857 static abi_long do_bsd_mkfifo(abi_long arg1, abi_long arg2)
858 {
859 abi_long ret;
860 void *p;
861
862 LOCK_PATH(p, arg1);
863 ret = get_errno(mkfifo(p, arg2)); /* XXX path(p)? */
864 UNLOCK_PATH(p, arg1);
865
866 return ret;
867 }
868
869 /* mkfifoat(2) */
870 static abi_long do_bsd_mkfifoat(abi_long arg1, abi_long arg2,
871 abi_long arg3)
872 {
873 abi_long ret;
874 void *p;
875
876 LOCK_PATH(p, arg2);
877 ret = get_errno(mkfifoat(arg1, p, arg3));
878 UNLOCK_PATH(p, arg2);
879
880 return ret;
881 }
882
883 /* pathconf(2) */
884 static abi_long do_bsd_pathconf(abi_long arg1, abi_long arg2)
885 {
886 abi_long ret;
887 void *p;
888
889 LOCK_PATH(p, arg1);
890 ret = get_errno(pathconf(p, arg2)); /* XXX path(p)? */
891 UNLOCK_PATH(p, arg1);
892
893 return ret;
894 }
895
896 /* lpathconf(2) */
897 static abi_long do_bsd_lpathconf(abi_long arg1, abi_long arg2)
898 {
899 abi_long ret;
900 void *p;
901
902 LOCK_PATH(p, arg1);
903 ret = get_errno(lpathconf(p, arg2)); /* XXX path(p)? */
904 UNLOCK_PATH(p, arg1);
905
906 return ret;
907 }
908
909 /* fpathconf(2) */
910 static abi_long do_bsd_fpathconf(abi_long arg1, abi_long arg2)
911 {
912 return get_errno(fpathconf(arg1, arg2));
913 }
914
915 /* undelete(2) */
916 static abi_long do_bsd_undelete(abi_long arg1)
917 {
918 abi_long ret;
919 void *p;
920
921 LOCK_PATH(p, arg1);
922 ret = get_errno(undelete(p)); /* XXX path(p)? */
923 UNLOCK_PATH(p, arg1);
924
925 return ret;
926 }
927
928 #endif /* BSD_FILE_H */