bsd-user/freebsd/os-stat.h

   1 /*
   2  *  stat 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_USER_FREEBSD_OS_STAT_H
  21 #define BSD_USER_FREEBSD_OS_STAT_H
  22
  23 int freebsd11_stat(const char *path, struct freebsd11_stat *stat);
  24 __sym_compat(stat, freebsd11_stat, FBSD_1.0);
  25 int freebsd11_lstat(const char *path, struct freebsd11_stat *stat);
  26 __sym_compat(lstat, freebsd11_lstat, FBSD_1.0);
  27 int freebsd11_fstat(int fd, struct freebsd11_stat *stat);
  28 __sym_compat(fstat, freebsd11_fstat, FBSD_1.0);
  29 int freebsd11_fstatat(int fd, const char *path, struct freebsd11_stat *stat,
  30         int flag);
  31 __sym_compat(fstatat, freebsd11_fstatat, FBSD_1.1);
  32
  33 int freebsd11_fhstat(const fhandle_t *fhandle, struct freebsd11_stat *stat);
  34 __sym_compat(fhstat, freebsd11_fhstat, FBSD_1.0);
  35 int freebsd11_getfsstat(struct freebsd11_statfs *buf, long bufsize, int mode);
  36 __sym_compat(getfsstat, freebsd11_getfsstat, FBSD_1.0);
  37 int freebsd11_fhstatfs(const fhandle_t *fhandle, struct freebsd11_statfs * buf);
  38 __sym_compat(fhstatfs, freebsd11_fhstatfs, FBSD_1.0);
  39 int freebsd11_statfs(const char *path, struct freebsd11_statfs *buf);
  40 __sym_compat(statfs, freebsd11_statfs, FBSD_1.0);
  41 int freebsd11_fstatfs(int fd, struct freebsd11_statfs *buf);
  42 __sym_compat(fstatfs, freebsd11_fstatfs, FBSD_1.0);
  43
  44 ssize_t freebsd11_getdirentries(int fd, char *buf, size_t nbytes, off_t *basep);
  45 __sym_compat(getdirentries, freebsd11_getdirentries, FBSD_1.0);
  46 ssize_t freebsd11_getdents(int fd, char *buf, size_t nbytes);
  47 __sym_compat(getdents, freebsd11_getdents, FBSD_1.0);
  48
  49 /* undocumented nstat system calls */
  50 int freebsd11_nstat(const char *path, struct freebsd11_stat *sb);
  51 __sym_compat(nstat, freebsd11_nstat, FBSD_1.0);
  52 int freebsd11_nlstat(const char *path, struct freebsd11_stat *sb);
  53 __sym_compat(nlstat, freebsd11_nlstat, FBSD_1.0);
  54 int freebsd11_nfstat(int fd, struct freebsd11_stat *sb);
  55 __sym_compat(nfstat, freebsd11_nfstat, FBSD_1.0);
  56
  57 /* stat(2) */
  58 static inline abi_long do_freebsd11_stat(abi_long arg1, abi_long arg2)
  59 {
  60     abi_long ret;
  61     void *p;
  62     struct freebsd11_stat st;
  63
  64     LOCK_PATH(p, arg1);
  65     ret = get_errno(freebsd11_stat(path(p), &st));
  66     UNLOCK_PATH(p, arg1);
  67     if (!is_error(ret)) {
  68         ret = h2t_freebsd11_stat(arg2, &st);
  69     }
  70     return ret;
  71 }
  72
  73 /* lstat(2) */
  74 static inline abi_long do_freebsd11_lstat(abi_long arg1, abi_long arg2)
  75 {
  76     abi_long ret;
  77     void *p;
  78     struct freebsd11_stat st;
  79
  80     LOCK_PATH(p, arg1);
  81     ret = get_errno(freebsd11_lstat(path(p), &st));
  82     UNLOCK_PATH(p, arg1);
  83     if (!is_error(ret)) {
  84         ret = h2t_freebsd11_stat(arg2, &st);
  85     }
  86     return ret;
  87 }
  88
  89 /* fstat(2) */
  90 static inline abi_long do_freebsd11_fstat(abi_long arg1, abi_long arg2)
  91 {
  92     abi_long ret;
  93     struct freebsd11_stat st;
  94
  95     ret = get_errno(freebsd11_fstat(arg1, &st));
  96     if (!is_error(ret))  {
  97         ret = h2t_freebsd11_stat(arg2, &st);
  98     }
  99     return ret;
 100 }
 101
 102 /* fstat(2) */
 103 static inline abi_long do_freebsd_fstat(abi_long arg1, abi_long arg2)
 104 {
 105     abi_long ret;
 106     struct stat st;
 107
 108     ret = get_errno(fstat(arg1, &st));
 109     if (!is_error(ret))  {
 110         ret = h2t_freebsd_stat(arg2, &st);
 111     }
 112     return ret;
 113 }
 114
 115 /* fstatat(2) */
 116 static inline abi_long do_freebsd11_fstatat(abi_long arg1, abi_long arg2,
 117         abi_long arg3, abi_long arg4)
 118 {
 119     abi_long ret;
 120     void *p;
 121     struct freebsd11_stat st;
 122
 123     LOCK_PATH(p, arg2);
 124     ret = get_errno(freebsd11_fstatat(arg1, p, &st, arg4));
 125     UNLOCK_PATH(p, arg2);
 126     if (!is_error(ret) && arg3) {
 127         ret = h2t_freebsd11_stat(arg3, &st);
 128     }
 129     return ret;
 130 }
 131
 132 /* fstatat(2) */
 133 static inline abi_long do_freebsd_fstatat(abi_long arg1, abi_long arg2,
 134         abi_long arg3, abi_long arg4)
 135 {
 136     abi_long ret;
 137     void *p;
 138     struct stat st;
 139
 140     LOCK_PATH(p, arg2);
 141     ret = get_errno(fstatat(arg1, p, &st, arg4));
 142     UNLOCK_PATH(p, arg2);
 143     if (!is_error(ret) && arg3) {
 144         ret = h2t_freebsd_stat(arg3, &st);
 145     }
 146     return ret;
 147 }
 148
 149 /* undocumented nstat(char *path, struct nstat *ub) syscall */
 150 static abi_long do_freebsd11_nstat(abi_long arg1, abi_long arg2)
 151 {
 152     abi_long ret;
 153     void *p;
 154     struct freebsd11_stat st;
 155
 156     LOCK_PATH(p, arg1);
 157     ret = get_errno(freebsd11_nstat(path(p), &st));
 158     UNLOCK_PATH(p, arg1);
 159     if (!is_error(ret)) {
 160         ret = h2t_freebsd11_nstat(arg2, &st);
 161     }
 162     return ret;
 163 }
 164
 165 /* undocumented nfstat(int fd, struct nstat *sb) syscall */
 166 static abi_long do_freebsd11_nfstat(abi_long arg1, abi_long arg2)
 167 {
 168     abi_long ret;
 169     struct freebsd11_stat st;
 170
 171     ret = get_errno(freebsd11_nfstat(arg1, &st));
 172     if (!is_error(ret))  {
 173         ret = h2t_freebsd11_nstat(arg2, &st);
 174     }
 175     return ret;
 176 }
 177
 178 /* undocumented nlstat(char *path, struct nstat *ub) syscall */
 179 static abi_long do_freebsd11_nlstat(abi_long arg1, abi_long arg2)
 180 {
 181     abi_long ret;
 182     void *p;
 183     struct freebsd11_stat st;
 184
 185     LOCK_PATH(p, arg1);
 186     ret = get_errno(freebsd11_nlstat(path(p), &st));
 187     UNLOCK_PATH(p, arg1);
 188     if (!is_error(ret)) {
 189         ret = h2t_freebsd11_nstat(arg2, &st);
 190     }
 191     return ret;
 192 }
 193
 194 /* getfh(2) */
 195 static abi_long do_freebsd_getfh(abi_long arg1, abi_long arg2)
 196 {
 197     abi_long ret;
 198     void *p;
 199     fhandle_t host_fh;
 200
 201     LOCK_PATH(p, arg1);
 202     ret = get_errno(getfh(path(p), &host_fh));
 203     UNLOCK_PATH(p, arg1);
 204     if (is_error(ret)) {
 205         return ret;
 206     }
 207     return h2t_freebsd_fhandle(arg2, &host_fh);
 208 }
 209
 210 /* lgetfh(2) */
 211 static inline abi_long do_freebsd_lgetfh(abi_long arg1, abi_long arg2)
 212 {
 213     abi_long ret;
 214     void *p;
 215     fhandle_t host_fh;
 216
 217     LOCK_PATH(p, arg1);
 218     ret = get_errno(lgetfh(path(p), &host_fh));
 219     UNLOCK_PATH(p, arg1);
 220     if (is_error(ret)) {
 221         return ret;
 222     }
 223     return h2t_freebsd_fhandle(arg2, &host_fh);
 224 }
 225
 226 /* fhopen(2) */
 227 static inline abi_long do_freebsd_fhopen(abi_long arg1, abi_long arg2)
 228 {
 229     abi_long ret;
 230     fhandle_t host_fh;
 231
 232     ret = t2h_freebsd_fhandle(&host_fh, arg1);
 233     if (is_error(ret)) {
 234         return ret;
 235     }
 236
 237     return get_errno(fhopen(&host_fh, arg2));
 238 }
 239
 240 /* fhstat(2) */
 241 static inline abi_long do_freebsd11_fhstat(abi_long arg1, abi_long arg2)
 242 {
 243     abi_long ret;
 244     fhandle_t host_fh;
 245     struct freebsd11_stat host_sb;
 246
 247     ret = t2h_freebsd_fhandle(&host_fh, arg1);
 248     if (is_error(ret)) {
 249         return ret;
 250     }
 251     ret = get_errno(freebsd11_fhstat(&host_fh, &host_sb));
 252     if (is_error(ret)) {
 253         return ret;
 254     }
 255     return h2t_freebsd11_stat(arg2, &host_sb);
 256 }
 257
 258 /* fhstat(2) */
 259 static inline abi_long do_freebsd_fhstat(abi_long arg1, abi_long arg2)
 260 {
 261     abi_long ret;
 262     fhandle_t host_fh;
 263     struct stat host_sb;
 264
 265     ret = t2h_freebsd_fhandle(&host_fh, arg1);
 266     if (is_error(ret)) {
 267         return ret;
 268     }
 269     ret = get_errno(fhstat(&host_fh, &host_sb));
 270     if (is_error(ret)) {
 271         return ret;
 272     }
 273     return h2t_freebsd_stat(arg2, &host_sb);
 274 }
 275
 276 /* fhstatfs(2) */
 277 static inline abi_long do_freebsd11_fhstatfs(abi_ulong target_fhp_addr,
 278         abi_ulong target_stfs_addr)
 279 {
 280     abi_long ret;
 281     fhandle_t host_fh;
 282     struct freebsd11_statfs host_stfs;
 283
 284     ret = t2h_freebsd_fhandle(&host_fh, target_fhp_addr);
 285     if (is_error(ret)) {
 286         return ret;
 287     }
 288     ret = get_errno(freebsd11_fhstatfs(&host_fh, &host_stfs));
 289     if (is_error(ret)) {
 290         return ret;
 291     }
 292     return h2t_freebsd11_statfs(target_stfs_addr, &host_stfs);
 293 }
 294
 295 /* fhstatfs(2) */
 296 static inline abi_long do_freebsd_fhstatfs(abi_ulong target_fhp_addr,
 297         abi_ulong target_stfs_addr)
 298 {
 299     abi_long ret;
 300     fhandle_t host_fh;
 301     struct statfs host_stfs;
 302
 303     ret = t2h_freebsd_fhandle(&host_fh, target_fhp_addr);
 304     if (is_error(ret)) {
 305         return ret;
 306     }
 307     ret = get_errno(fhstatfs(&host_fh, &host_stfs));
 308     if (is_error(ret)) {
 309         return ret;
 310     }
 311     return h2t_freebsd_statfs(target_stfs_addr, &host_stfs);
 312 }
 313
 314 /* statfs(2) */
 315 static inline abi_long do_freebsd11_statfs(abi_long arg1, abi_long arg2)
 316 {
 317     abi_long ret;
 318     void *p;
 319     struct freebsd11_statfs host_stfs;
 320
 321     LOCK_PATH(p, arg1);
 322     ret = get_errno(freebsd11_statfs(path(p), &host_stfs));
 323     UNLOCK_PATH(p, arg1);
 324     if (is_error(ret)) {
 325         return ret;
 326     }
 327
 328     return h2t_freebsd11_statfs(arg2, &host_stfs);
 329 }
 330
 331 /* statfs(2) */
 332 static inline abi_long do_freebsd_statfs(abi_long arg1, abi_long arg2)
 333 {
 334     abi_long ret;
 335     void *p;
 336     struct statfs host_stfs;
 337
 338     LOCK_PATH(p, arg1);
 339     ret = get_errno(statfs(path(p), &host_stfs));
 340     UNLOCK_PATH(p, arg1);
 341     if (is_error(ret)) {
 342         return ret;
 343     }
 344
 345     return h2t_freebsd_statfs(arg2, &host_stfs);
 346 }
 347
 348 /* fstatfs(2) */
 349 static inline abi_long do_freebsd11_fstatfs(abi_long fd, abi_ulong target_addr)
 350 {
 351     abi_long ret;
 352     struct freebsd11_statfs host_stfs;
 353
 354     ret = get_errno(freebsd11_fstatfs(fd, &host_stfs));
 355     if (is_error(ret)) {
 356         return ret;
 357     }
 358
 359     return h2t_freebsd11_statfs(target_addr, &host_stfs);
 360 }
 361
 362 /* fstatfs(2) */
 363 static inline abi_long do_freebsd_fstatfs(abi_long fd, abi_ulong target_addr)
 364 {
 365     abi_long ret;
 366     struct statfs host_stfs;
 367
 368     ret = get_errno(fstatfs(fd, &host_stfs));
 369     if (is_error(ret)) {
 370         return ret;
 371     }
 372
 373     return h2t_freebsd_statfs(target_addr, &host_stfs);
 374 }
 375
 376 /* getfsstat(2) */
 377 static inline abi_long do_freebsd11_getfsstat(abi_ulong target_addr,
 378         abi_long bufsize, abi_long flags)
 379 {
 380     abi_long ret;
 381     struct freebsd11_statfs *host_stfs;
 382     int count;
 383     long host_bufsize;
 384
 385     count = bufsize / sizeof(struct target_freebsd11_statfs);
 386
 387     /* if user buffer is NULL then return number of mounted FS's */
 388     if (target_addr == 0 || count == 0) {
 389         return get_errno(freebsd11_getfsstat(NULL, 0, flags));
 390     }
 391
 392     /* XXX check count to be reasonable */
 393     host_bufsize = sizeof(struct freebsd11_statfs) * count;
 394     host_stfs = alloca(host_bufsize);
 395     if (!host_stfs) {
 396         return -TARGET_EINVAL;
 397     }
 398
 399     ret = count = get_errno(freebsd11_getfsstat(host_stfs, host_bufsize, flags));
 400     if (is_error(ret)) {
 401         return ret;
 402     }
 403
 404     while (count--) {
 405         if (h2t_freebsd11_statfs((target_addr +
 406                         (count * sizeof(struct target_freebsd11_statfs))),
 407                     &host_stfs[count])) {
 408             return -TARGET_EFAULT;
 409         }
 410     }
 411     return ret;
 412 }
 413
 414 /* getfsstat(2) */
 415 static inline abi_long do_freebsd_getfsstat(abi_ulong target_addr,
 416         abi_long bufsize, abi_long flags)
 417 {
 418     abi_long ret;
 419     struct statfs *host_stfs;
 420     int count;
 421     long host_bufsize;
 422
 423     count = bufsize / sizeof(struct target_statfs);
 424
 425     /* if user buffer is NULL then return number of mounted FS's */
 426     if (target_addr == 0 || count == 0) {
 427         return get_errno(freebsd11_getfsstat(NULL, 0, flags));
 428     }
 429
 430     /* XXX check count to be reasonable */
 431     host_bufsize = sizeof(struct statfs) * count;
 432     host_stfs = alloca(host_bufsize);
 433     if (!host_stfs) {
 434         return -TARGET_EINVAL;
 435     }
 436
 437     ret = count = get_errno(getfsstat(host_stfs, host_bufsize, flags));
 438     if (is_error(ret)) {
 439         return ret;
 440     }
 441
 442     while (count--) {
 443         if (h2t_freebsd_statfs((target_addr +
 444                         (count * sizeof(struct target_statfs))),
 445                     &host_stfs[count])) {
 446             return -TARGET_EFAULT;
 447         }
 448     }
 449     return ret;
 450 }
 451
 452 /* getdents(2) */
 453 static inline abi_long do_freebsd11_getdents(abi_long arg1,
 454         abi_ulong arg2, abi_long nbytes)
 455 {
 456     abi_long ret;
 457     struct freebsd11_dirent *dirp;
 458
 459     dirp = lock_user(VERIFY_WRITE, arg2, nbytes, 0);
 460     if (dirp == NULL) {
 461         return -TARGET_EFAULT;
 462     }
 463     ret = get_errno(freebsd11_getdents(arg1, (char *)dirp, nbytes));
 464     if (!is_error(ret)) {
 465         struct freebsd11_dirent *de;
 466         int len = ret;
 467         int reclen;
 468
 469         de = dirp;
 470         while (len > 0) {
 471             reclen = de->d_reclen;
 472             if (reclen > len) {
 473                 return -TARGET_EFAULT;
 474             }
 475             de->d_reclen = tswap16(reclen);
 476             de->d_fileno = tswap32(de->d_fileno);
 477             len -= reclen;
 478         }
 479     }
 480     return ret;
 481 }
 482
 483 /* getdirecentries(2) */
 484 static inline abi_long do_freebsd11_getdirentries(abi_long arg1,
 485         abi_ulong arg2, abi_long nbytes, abi_ulong arg4)
 486 {
 487     abi_long ret;
 488     struct freebsd11_dirent *dirp;
 489     long basep;
 490
 491     dirp = lock_user(VERIFY_WRITE, arg2, nbytes, 0);
 492     if (dirp == NULL) {
 493         return -TARGET_EFAULT;
 494     }
 495     ret = get_errno(freebsd11_getdirentries(arg1, (char *)dirp, nbytes, &basep));
 496     if (!is_error(ret)) {
 497         struct freebsd11_dirent *de;
 498         int len = ret;
 499         int reclen;
 500
 501         de = dirp;
 502         while (len > 0) {
 503             reclen = de->d_reclen;
 504             if (reclen > len) {
 505                 return -TARGET_EFAULT;
 506             }
 507             de->d_reclen = tswap16(reclen);
 508             de->d_fileno = tswap32(de->d_fileno);
 509             len -= reclen;
 510             de = (struct freebsd11_dirent *)((void *)de + reclen);
 511         }
 512     }
 513     unlock_user(dirp, arg2, ret);
 514     if (arg4) {
 515         if (put_user(basep, arg4, abi_ulong)) {
 516             return -TARGET_EFAULT;
 517         }
 518     }
 519     return ret;
 520 }
 521
 522 /* getdirecentries(2) */
 523 static inline abi_long do_freebsd_getdirentries(abi_long arg1,
 524         abi_ulong arg2, abi_long nbytes, abi_ulong arg4)
 525 {
 526     abi_long ret;
 527     struct dirent *dirp;
 528     long basep;
 529
 530     dirp = lock_user(VERIFY_WRITE, arg2, nbytes, 0);
 531     if (dirp == NULL) {
 532         return -TARGET_EFAULT;
 533     }
 534     ret = get_errno(getdirentries(arg1, (char *)dirp, nbytes, &basep));
 535     if (!is_error(ret)) {
 536         struct dirent *de;
 537         int len = ret;
 538         int reclen;
 539
 540         de = dirp;
 541         while (len > 0) {
 542             reclen = de->d_reclen;
 543             if (reclen > len) {
 544                 return -TARGET_EFAULT;
 545             }
 546             de->d_fileno = tswap64(de->d_fileno);
 547             de->d_off = tswap64(de->d_off);
 548             de->d_reclen = tswap16(de->d_reclen);
 549             de->d_namlen = tswap16(de->d_namlen);
 550             len -= reclen;
 551             de = (struct dirent *)((void *)de + reclen);
 552         }
 553     }
 554     unlock_user(dirp, arg2, ret);
 555     if (arg4) {
 556         if (put_user(basep, arg4, abi_ulong)) {
 557             return -TARGET_EFAULT;
 558         }
 559     }
 560     return ret;
 561 }
 562
 563 /* fcntl(2) */
 564 static inline abi_long do_freebsd_fcntl(abi_long arg1, abi_long arg2,
 565         abi_ulong arg3)
 566 {
 567     abi_long ret;
 568     int host_cmd;
 569     struct flock fl;
 570     struct target_freebsd_flock *target_fl;
 571
 572     host_cmd = target_to_host_fcntl_cmd(arg2);
 573     if (host_cmd < 0) {
 574         return host_cmd;
 575     }
 576     switch (arg2) {
 577     case TARGET_F_GETLK:
 578         if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1)) {
 579             return -TARGET_EFAULT;
 580         }
 581         __get_user(fl.l_type, &target_fl->l_type);
 582         __get_user(fl.l_whence, &target_fl->l_whence);
 583         __get_user(fl.l_start, &target_fl->l_start);
 584         __get_user(fl.l_len, &target_fl->l_len);
 585         __get_user(fl.l_pid, &target_fl->l_pid);
 586         __get_user(fl.l_sysid, &target_fl->l_sysid);
 587         unlock_user_struct(target_fl, arg3, 0);
 588         ret = get_errno(safe_fcntl(arg1, host_cmd, &fl));
 589         if (!is_error(ret)) {
 590             if (!lock_user_struct(VERIFY_WRITE, target_fl, arg3, 0)) {
 591                 return -TARGET_EFAULT;
 592             }
 593             __put_user(fl.l_type, &target_fl->l_type);
 594             __put_user(fl.l_whence, &target_fl->l_whence);
 595             __put_user(fl.l_start, &target_fl->l_start);
 596             __put_user(fl.l_len, &target_fl->l_len);
 597             __put_user(fl.l_pid, &target_fl->l_pid);
 598             __put_user(fl.l_sysid, &target_fl->l_sysid);
 599             unlock_user_struct(target_fl, arg3, 1);
 600         }
 601         break;
 602
 603     case TARGET_F_SETLK:
 604     case TARGET_F_SETLKW:
 605         if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1)) {
 606             return -TARGET_EFAULT;
 607         }
 608         __get_user(fl.l_type, &target_fl->l_type);
 609         __get_user(fl.l_whence, &target_fl->l_whence);
 610         __get_user(fl.l_start, &target_fl->l_start);
 611         __get_user(fl.l_len, &target_fl->l_len);
 612         __get_user(fl.l_pid, &target_fl->l_pid);
 613         __get_user(fl.l_sysid, &target_fl->l_sysid);
 614         unlock_user_struct(target_fl, arg3, 0);
 615         ret = get_errno(safe_fcntl(arg1, host_cmd, &fl));
 616         break;
 617
 618     case TARGET_F_DUPFD:
 619     case TARGET_F_DUP2FD:
 620     case TARGET_F_GETOWN:
 621     case TARGET_F_SETOWN:
 622     case TARGET_F_GETFD:
 623     case TARGET_F_SETFD:
 624     case TARGET_F_GETFL:
 625     case TARGET_F_SETFL:
 626     case TARGET_F_READAHEAD:
 627     case TARGET_F_RDAHEAD:
 628     case TARGET_F_ADD_SEALS:
 629     case TARGET_F_GET_SEALS:
 630     default:
 631         ret = get_errno(safe_fcntl(arg1, host_cmd, arg3));
 632         break;
 633     }
 634     return ret;
 635 }
 636
 637 #if defined(__FreeBSD_version) && __FreeBSD_version >= 1300080
 638 extern int __realpathat(int fd, const char *path, char *buf, size_t size,
 639         int flags);
 640 /* https://svnweb.freebsd.org/base?view=revision&revision=358172 */
 641 /* no man page */
 642 static inline abi_long do_freebsd_realpathat(abi_long arg1, abi_long arg2,
 643         abi_long arg3, abi_long arg4, abi_long arg5)
 644 {
 645     abi_long ret;
 646     void *p, *b;
 647
 648     LOCK_PATH(p, arg2);
 649     b = lock_user(VERIFY_WRITE, arg3, arg4, 0);
 650     if (b == NULL) {
 651         UNLOCK_PATH(p, arg2);
 652         return -TARGET_EFAULT;
 653     }
 654
 655     ret = get_errno(__realpathat(arg1, p, b, arg4, arg5));
 656     UNLOCK_PATH(p, arg2);
 657     unlock_user(b, arg3, ret);
 658
 659     return ret;
 660 }
 661 #endif
 662
 663 #endif /* BSD_USER_FREEBSD_OS_STAT_H */