bsd-user/bsd-file.h

   1 /*
   2  *  file related system call shims and definitions
   3  *
   4  *  Copyright (c) 2013 Stacey D. Son
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #ifndef BSD_FILE_H
  21 #define BSD_FILE_H
  22
  23 #include "qemu/path.h"
  24
  25 #define LOCK_PATH(p, arg)                   \
  26 do {                                        \
  27     (p) = lock_user_string(arg);            \
  28     if ((p) == NULL) {                      \
  29         return -TARGET_EFAULT;              \
  30     }                                       \
  31 } while (0)
  32
  33 #define UNLOCK_PATH(p, arg)     unlock_user(p, arg, 0)
  34
  35 #define LOCK_PATH2(p1, arg1, p2, arg2)      \
  36 do {                                        \
  37     (p1) = lock_user_string(arg1);          \
  38     if ((p1) == NULL) {                     \
  39         return -TARGET_EFAULT;              \
  40     }                                       \
  41     (p2) = lock_user_string(arg2);          \
  42     if ((p2) == NULL) {                     \
  43         unlock_user(p1, arg1, 0);           \
  44         return -TARGET_EFAULT;              \
  45     }                                       \
  46 } while (0)
  47
  48 #define UNLOCK_PATH2(p1, arg1, p2, arg2)    \
  49 do {                                        \
  50     unlock_user(p2, arg2, 0);               \
  51     unlock_user(p1, arg1, 0);               \
  52 } while (0)
  53
  54 extern struct iovec *lock_iovec(int type, abi_ulong target_addr, int count,
  55         int copy);
  56 extern void unlock_iovec(struct iovec *vec, abi_ulong target_addr, int count,
  57         int copy);
  58
  59 int safe_open(const char *path, int flags, mode_t mode);
  60 int safe_openat(int fd, const char *path, int flags, mode_t mode);
  61
  62 ssize_t safe_read(int fd, void *buf, size_t nbytes);
  63 ssize_t safe_pread(int fd, void *buf, size_t nbytes, off_t offset);
  64 ssize_t safe_readv(int fd, const struct iovec *iov, int iovcnt);
  65 ssize_t safe_preadv(int fd, const struct iovec *iov, int iovcnt, off_t offset);
  66
  67 ssize_t safe_write(int fd, void *buf, size_t nbytes);
  68 ssize_t safe_pwrite(int fd, void *buf, size_t nbytes, off_t offset);
  69 ssize_t safe_writev(int fd, const struct iovec *iov, int iovcnt);
  70 ssize_t safe_pwritev(int fd, const struct iovec *iov, int iovcnt, off_t offset);
  71
  72 /* read(2) */
  73 static abi_long do_bsd_read(abi_long arg1, abi_long arg2, abi_long arg3)
  74 {
  75     abi_long ret;
  76     void *p;
  77
  78     p = lock_user(VERIFY_WRITE, arg2, arg3, 0);
  79     if (p == NULL) {
  80         return -TARGET_EFAULT;
  81     }
  82     ret = get_errno(safe_read(arg1, p, arg3));
  83     unlock_user(p, arg2, ret);
  84
  85     return ret;
  86 }
  87
  88 /* pread(2) */
  89 static abi_long do_bsd_pread(void *cpu_env, abi_long arg1,
  90     abi_long arg2, abi_long arg3, abi_long arg4, abi_long arg5, abi_long arg6)
  91 {
  92     abi_long ret;
  93     void *p;
  94
  95     p = lock_user(VERIFY_WRITE, arg2, arg3, 0);
  96     if (p == NULL) {
  97         return -TARGET_EFAULT;
  98     }
  99     if (regpairs_aligned(cpu_env) != 0) {
 100         arg4 = arg5;
 101         arg5 = arg6;
 102     }
 103     ret = get_errno(safe_pread(arg1, p, arg3, target_arg64(arg4, arg5)));
 104     unlock_user(p, arg2, ret);
 105
 106     return ret;
 107 }
 108
 109 /* readv(2) */
 110 static abi_long do_bsd_readv(abi_long arg1, abi_long arg2, abi_long arg3)
 111 {
 112     abi_long ret;
 113     struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0);
 114
 115     if (vec != NULL) {
 116         ret = get_errno(safe_readv(arg1, vec, arg3));
 117         unlock_iovec(vec, arg2, arg3, 1);
 118     } else {
 119         ret = -host_to_target_errno(errno);
 120     }
 121
 122     return ret;
 123 }
 124
 125 /* preadv(2) */
 126 static abi_long do_bsd_preadv(void *cpu_env, abi_long arg1,
 127     abi_long arg2, abi_long arg3, abi_long arg4, abi_long arg5, abi_long arg6)
 128 {
 129     abi_long ret;
 130     struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 1);
 131
 132     if (vec != NULL) {
 133         if (regpairs_aligned(cpu_env) != 0) {
 134             arg4 = arg5;
 135             arg5 = arg6;
 136         }
 137         ret = get_errno(safe_preadv(arg1, vec, arg3, target_arg64(arg4, arg5)));
 138         unlock_iovec(vec, arg2, arg3, 0);
 139     } else {
 140         ret = -host_to_target_errno(errno);
 141     }
 142
 143     return ret;
 144 }
 145
 146 /* write(2) */
 147 static abi_long do_bsd_write(abi_long arg1, abi_long arg2, abi_long arg3)
 148 {
 149     abi_long nbytes, ret;
 150     void *p;
 151
 152     /* nbytes < 0 implies that it was larger than SIZE_MAX. */
 153     nbytes = arg3;
 154     if (nbytes < 0) {
 155         return -TARGET_EINVAL;
 156     }
 157     p = lock_user(VERIFY_READ, arg2, nbytes, 1);
 158     if (p == NULL) {
 159         return -TARGET_EFAULT;
 160     }
 161     ret = get_errno(safe_write(arg1, p, arg3));
 162     unlock_user(p, arg2, 0);
 163
 164     return ret;
 165 }
 166
 167 /* pwrite(2) */
 168 static abi_long do_bsd_pwrite(void *cpu_env, abi_long arg1,
 169     abi_long arg2, abi_long arg3, abi_long arg4, abi_long arg5, abi_long arg6)
 170 {
 171     abi_long ret;
 172     void *p;
 173
 174     p = lock_user(VERIFY_READ, arg2, arg3, 1);
 175     if (p == NULL) {
 176         return -TARGET_EFAULT;
 177     }
 178     if (regpairs_aligned(cpu_env) != 0) {
 179         arg4 = arg5;
 180         arg5 = arg6;
 181     }
 182     ret = get_errno(safe_pwrite(arg1, p, arg3, target_arg64(arg4, arg5)));
 183     unlock_user(p, arg2, 0);
 184
 185     return ret;
 186 }
 187
 188 /* writev(2) */
 189 static abi_long do_bsd_writev(abi_long arg1, abi_long arg2, abi_long arg3)
 190 {
 191     abi_long ret;
 192     struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
 193
 194     if (vec != NULL) {
 195         ret = get_errno(safe_writev(arg1, vec, arg3));
 196         unlock_iovec(vec, arg2, arg3, 0);
 197     } else {
 198         ret = -host_to_target_errno(errno);
 199     }
 200
 201     return ret;
 202 }
 203
 204 /* pwritev(2) */
 205 static abi_long do_bsd_pwritev(void *cpu_env, abi_long arg1,
 206     abi_long arg2, abi_long arg3, abi_long arg4, abi_long arg5, abi_long arg6)
 207 {
 208     abi_long ret;
 209     struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
 210
 211     if (vec != NULL) {
 212         if (regpairs_aligned(cpu_env) != 0) {
 213             arg4 = arg5;
 214             arg5 = arg6;
 215         }
 216         ret = get_errno(safe_pwritev(arg1, vec, arg3, target_arg64(arg4, arg5)));
 217         unlock_iovec(vec, arg2, arg3, 0);
 218     } else {
 219         ret = -host_to_target_errno(errno);
 220     }
 221
 222     return ret;
 223 }
 224
 225 /* open(2) */
 226 static abi_long do_bsd_open(abi_long arg1, abi_long arg2, abi_long arg3)
 227 {
 228     abi_long ret;
 229     void *p;
 230
 231     LOCK_PATH(p, arg1);
 232     ret = get_errno(safe_open(path(p), target_to_host_bitmask(arg2,
 233                 fcntl_flags_tbl), arg3));
 234     UNLOCK_PATH(p, arg1);
 235
 236     return ret;
 237 }
 238
 239 /* openat(2) */
 240 static abi_long do_bsd_openat(abi_long arg1, abi_long arg2,
 241         abi_long arg3, abi_long arg4)
 242 {
 243     abi_long ret;
 244     void *p;
 245
 246     LOCK_PATH(p, arg2);
 247     ret = get_errno(safe_openat(arg1, path(p),
 248                 target_to_host_bitmask(arg3, fcntl_flags_tbl), arg4));
 249     UNLOCK_PATH(p, arg2);
 250
 251     return ret;
 252 }
 253
 254 /* close(2) */
 255 static inline abi_long do_bsd_close(abi_long arg1)
 256 {
 257     return get_errno(close(arg1));
 258 }
 259
 260 /* fdatasync(2) */
 261 static abi_long do_bsd_fdatasync(abi_long arg1)
 262 {
 263     return get_errno(fdatasync(arg1));
 264 }
 265
 266 /* fsync(2) */
 267 static abi_long do_bsd_fsync(abi_long arg1)
 268 {
 269     return get_errno(fsync(arg1));
 270 }
 271
 272 /* closefrom(2) */
 273 static abi_long do_bsd_closefrom(abi_long arg1)
 274 {
 275     closefrom(arg1);  /* returns void */
 276     return get_errno(0);
 277 }
 278
 279 /* revoke(2) */
 280 static abi_long do_bsd_revoke(abi_long arg1)
 281 {
 282     abi_long ret;
 283     void *p;
 284
 285     LOCK_PATH(p, arg1);
 286     ret = get_errno(revoke(p)); /* XXX path(p)? */
 287     UNLOCK_PATH(p, arg1);
 288
 289     return ret;
 290 }
 291
 292 /* access(2) */
 293 static abi_long do_bsd_access(abi_long arg1, abi_long arg2)
 294 {
 295     abi_long ret;
 296     void *p;
 297
 298     LOCK_PATH(p, arg1);
 299     ret = get_errno(access(path(p), arg2));
 300     UNLOCK_PATH(p, arg1);
 301
 302     return ret;
 303 }
 304
 305 /* eaccess(2) */
 306 static abi_long do_bsd_eaccess(abi_long arg1, abi_long arg2)
 307 {
 308     abi_long ret;
 309     void *p;
 310
 311     LOCK_PATH(p, arg1);
 312     ret = get_errno(eaccess(path(p), arg2));
 313     UNLOCK_PATH(p, arg1);
 314
 315     return ret;
 316 }
 317
 318 /* faccessat(2) */
 319 static abi_long do_bsd_faccessat(abi_long arg1, abi_long arg2,
 320         abi_long arg3, abi_long arg4)
 321 {
 322     abi_long ret;
 323     void *p;
 324
 325     LOCK_PATH(p, arg2);
 326     ret = get_errno(faccessat(arg1, p, arg3, arg4)); /* XXX path(p)? */
 327     UNLOCK_PATH(p, arg2);
 328
 329     return ret;
 330 }
 331
 332 /* chdir(2) */
 333 static abi_long do_bsd_chdir(abi_long arg1)
 334 {
 335     abi_long ret;
 336     void *p;
 337
 338     LOCK_PATH(p, arg1);
 339     ret = get_errno(chdir(p)); /* XXX  path(p)? */
 340     UNLOCK_PATH(p, arg1);
 341
 342     return ret;
 343 }
 344
 345 /* fchdir(2) */
 346 static abi_long do_bsd_fchdir(abi_long arg1)
 347 {
 348     return get_errno(fchdir(arg1));
 349 }
 350
 351 /* rename(2) */
 352 static abi_long do_bsd_rename(abi_long arg1, abi_long arg2)
 353 {
 354     abi_long ret;
 355     void *p1, *p2;
 356
 357     LOCK_PATH2(p1, arg1, p2, arg2);
 358     ret = get_errno(rename(p1, p2)); /* XXX path(p1), path(p2) */
 359     UNLOCK_PATH2(p1, arg1, p2, arg2);
 360
 361     return ret;
 362 }
 363
 364 /* renameat(2) */
 365 static abi_long do_bsd_renameat(abi_long arg1, abi_long arg2,
 366         abi_long arg3, abi_long arg4)
 367 {
 368     abi_long ret;
 369     void *p1, *p2;
 370
 371     LOCK_PATH2(p1, arg2, p2, arg4);
 372     ret = get_errno(renameat(arg1, p1, arg3, p2));
 373     UNLOCK_PATH2(p1, arg2, p2, arg4);
 374
 375     return ret;
 376 }
 377
 378 /* link(2) */
 379 static abi_long do_bsd_link(abi_long arg1, abi_long arg2)
 380 {
 381     abi_long ret;
 382     void *p1, *p2;
 383
 384     LOCK_PATH2(p1, arg1, p2, arg2);
 385     ret = get_errno(link(p1, p2)); /* XXX path(p1), path(p2) */
 386     UNLOCK_PATH2(p1, arg1, p2, arg2);
 387
 388     return ret;
 389 }
 390
 391 /* linkat(2) */
 392 static abi_long do_bsd_linkat(abi_long arg1, abi_long arg2,
 393         abi_long arg3, abi_long arg4, abi_long arg5)
 394 {
 395     abi_long ret;
 396     void *p1, *p2;
 397
 398     LOCK_PATH2(p1, arg2, p2, arg4);
 399     ret = get_errno(linkat(arg1, p1, arg3, p2, arg5));
 400     UNLOCK_PATH2(p1, arg2, p2, arg4);
 401
 402     return ret;
 403 }
 404
 405 /* unlink(2) */
 406 static abi_long do_bsd_unlink(abi_long arg1)
 407 {
 408     abi_long ret;
 409     void *p;
 410
 411     LOCK_PATH(p, arg1);
 412     ret = get_errno(unlink(p)); /* XXX path(p) */
 413     UNLOCK_PATH(p, arg1);
 414
 415     return ret;
 416 }
 417
 418 /* unlinkat(2) */
 419 static abi_long do_bsd_unlinkat(abi_long arg1, abi_long arg2,
 420         abi_long arg3)
 421 {
 422     abi_long ret;
 423     void *p;
 424
 425     LOCK_PATH(p, arg2);
 426     ret = get_errno(unlinkat(arg1, p, arg3)); /* XXX path(p) */
 427     UNLOCK_PATH(p, arg2);
 428
 429     return ret;
 430 }
 431
 432 /* mkdir(2) */
 433 static abi_long do_bsd_mkdir(abi_long arg1, abi_long arg2)
 434 {
 435     abi_long ret;
 436     void *p;
 437
 438     LOCK_PATH(p, arg1);
 439     ret = get_errno(mkdir(p, arg2)); /* XXX path(p) */
 440     UNLOCK_PATH(p, arg1);
 441
 442     return ret;
 443 }
 444
 445 /* mkdirat(2) */
 446 static abi_long do_bsd_mkdirat(abi_long arg1, abi_long arg2,
 447         abi_long arg3)
 448 {
 449     abi_long ret;
 450     void *p;
 451
 452     LOCK_PATH(p, arg2);
 453     ret = get_errno(mkdirat(arg1, p, arg3));
 454     UNLOCK_PATH(p, arg2);
 455
 456     return ret;
 457 }
 458
 459 /* rmdir(2) */
 460 static abi_long do_bsd_rmdir(abi_long arg1)
 461 {
 462     abi_long ret;
 463     void *p;
 464
 465     LOCK_PATH(p, arg1);
 466     ret = get_errno(rmdir(p)); /* XXX path(p)? */
 467     UNLOCK_PATH(p, arg1);
 468
 469     return ret;
 470 }
 471
 472 /* undocumented __getcwd(char *buf, size_t len)  system call */
 473 static abi_long do_bsd___getcwd(abi_long arg1, abi_long arg2)
 474 {
 475     abi_long ret;
 476     void *p;
 477
 478     p = lock_user(VERIFY_WRITE, arg1, arg2, 0);
 479     if (p == NULL) {
 480         return -TARGET_EFAULT;
 481     }
 482     ret = safe_syscall(SYS___getcwd, p, arg2);
 483     unlock_user(p, arg1, ret == 0 ? strlen(p) + 1 : 0);
 484
 485     return get_errno(ret);
 486 }
 487
 488 /* dup(2) */
 489 static abi_long do_bsd_dup(abi_long arg1)
 490 {
 491     return get_errno(dup(arg1));
 492 }
 493
 494 /* dup2(2) */
 495 static abi_long do_bsd_dup2(abi_long arg1, abi_long arg2)
 496 {
 497     return get_errno(dup2(arg1, arg2));
 498 }
 499
 500 /* truncate(2) */
 501 static abi_long do_bsd_truncate(void *cpu_env, abi_long arg1,
 502         abi_long arg2, abi_long arg3, abi_long arg4)
 503 {
 504     abi_long ret;
 505     void *p;
 506
 507     LOCK_PATH(p, arg1);
 508     if (regpairs_aligned(cpu_env) != 0) {
 509         arg2 = arg3;
 510         arg3 = arg4;
 511     }
 512     ret = get_errno(truncate(p, target_arg64(arg2, arg3)));
 513     UNLOCK_PATH(p, arg1);
 514
 515     return ret;
 516 }
 517
 518 /* ftruncate(2) */
 519 static abi_long do_bsd_ftruncate(void *cpu_env, abi_long arg1,
 520         abi_long arg2, abi_long arg3, abi_long arg4)
 521 {
 522     if (regpairs_aligned(cpu_env) != 0) {
 523         arg2 = arg3;
 524         arg3 = arg4;
 525     }
 526     return get_errno(ftruncate(arg1, target_arg64(arg2, arg3)));
 527 }
 528
 529 /* acct(2) */
 530 static abi_long do_bsd_acct(abi_long arg1)
 531 {
 532     abi_long ret;
 533     void *p;
 534
 535     if (arg1 == 0) {
 536         ret = get_errno(acct(NULL));
 537     } else {
 538         LOCK_PATH(p, arg1);
 539         ret = get_errno(acct(path(p)));
 540         UNLOCK_PATH(p, arg1);
 541     }
 542     return ret;
 543 }
 544
 545 /* sync(2) */
 546 static abi_long do_bsd_sync(void)
 547 {
 548     sync();
 549     return 0;
 550 }
 551
 552 #endif /* BSD_FILE_H */