sys/compat/svr4/svr4_fcntl.c

   1 /*-
   2  * Copyright (c) 1998 Mark Newton
   3  * Copyright (c) 1994, 1997 Christos Zoulas.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the following acknowledgement:
  16  *      This product includes software developed by Christos Zoulas.
  17  * 4. The name of the author may not be used to endorse or promote products
  18  *    derived from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/capability.h>
  37 #include <sys/systm.h>
  38 #include <sys/file.h>
  39 #include <sys/filedesc.h>
  40 /*#include <sys/ioctl.h>*/
  41 #include <sys/lock.h>
  42 #include <sys/malloc.h>
  43 #include <sys/mount.h>
  44 #include <sys/mutex.h>
  45 #include <sys/namei.h>
  46 #include <sys/priv.h>
  47 #include <sys/proc.h>
  48 #include <sys/stat.h>
  49 #include <sys/syscallsubr.h>
  50 #include <sys/unistd.h>
  51 #include <sys/vnode.h>
  52
  53 #include <sys/sysproto.h>
  54
  55 #include <compat/svr4/svr4.h>
  56 #include <compat/svr4/svr4_types.h>
  57 #include <compat/svr4/svr4_signal.h>
  58 #include <compat/svr4/svr4_proto.h>
  59 #include <compat/svr4/svr4_util.h>
  60 #include <compat/svr4/svr4_fcntl.h>
  61
  62 #include <security/mac/mac_framework.h>
  63
  64 static int svr4_to_bsd_flags(int);
  65 static u_long svr4_to_bsd_cmd(u_long);
  66 static int fd_revoke(struct thread *, int);
  67 static int fd_truncate(struct thread *, int, struct flock *);
  68 static int bsd_to_svr4_flags(int);
  69 static void bsd_to_svr4_flock(struct flock *, struct svr4_flock *);
  70 static void svr4_to_bsd_flock(struct svr4_flock *, struct flock *);
  71 static void bsd_to_svr4_flock64(struct flock *, struct svr4_flock64 *);
  72 static void svr4_to_bsd_flock64(struct svr4_flock64 *, struct flock *);
  73
  74 static u_long
  75 svr4_to_bsd_cmd(cmd)
  76         u_long  cmd;
  77 {
  78         switch (cmd) {
  79         case SVR4_F_DUPFD:
  80                 return F_DUPFD;
  81         case SVR4_F_DUP2FD:
  82                 return F_DUP2FD;
  83         case SVR4_F_GETFD:
  84                 return F_GETFD;
  85         case SVR4_F_SETFD:
  86                 return F_SETFD;
  87         case SVR4_F_GETFL:
  88                 return F_GETFL;
  89         case SVR4_F_SETFL:
  90                 return F_SETFL;
  91         case SVR4_F_GETLK:
  92                 return F_GETLK;
  93         case SVR4_F_SETLK:
  94                 return F_SETLK;
  95         case SVR4_F_SETLKW:
  96                 return F_SETLKW;
  97         default:
  98                 return -1;
  99         }
 100 }
 101
 102 static int
 103 svr4_to_bsd_flags(l)
 104         int     l;
 105 {
 106         int     r = 0;
 107         r |= (l & SVR4_O_RDONLY) ? O_RDONLY : 0;
 108         r |= (l & SVR4_O_WRONLY) ? O_WRONLY : 0;
 109         r |= (l & SVR4_O_RDWR) ? O_RDWR : 0;
 110         r |= (l & SVR4_O_NDELAY) ? O_NONBLOCK : 0;
 111         r |= (l & SVR4_O_APPEND) ? O_APPEND : 0;
 112         r |= (l & SVR4_O_SYNC) ? O_FSYNC : 0;
 113         r |= (l & SVR4_O_NONBLOCK) ? O_NONBLOCK : 0;
 114         r |= (l & SVR4_O_PRIV) ? O_EXLOCK : 0;
 115         r |= (l & SVR4_O_CREAT) ? O_CREAT : 0;
 116         r |= (l & SVR4_O_TRUNC) ? O_TRUNC : 0;
 117         r |= (l & SVR4_O_EXCL) ? O_EXCL : 0;
 118         r |= (l & SVR4_O_NOCTTY) ? O_NOCTTY : 0;
 119         return r;
 120 }
 121
 122 static int
 123 bsd_to_svr4_flags(l)
 124         int     l;
 125 {
 126         int     r = 0;
 127         r |= (l & O_RDONLY) ? SVR4_O_RDONLY : 0;
 128         r |= (l & O_WRONLY) ? SVR4_O_WRONLY : 0;
 129         r |= (l & O_RDWR) ? SVR4_O_RDWR : 0;
 130         r |= (l & O_NDELAY) ? SVR4_O_NONBLOCK : 0;
 131         r |= (l & O_APPEND) ? SVR4_O_APPEND : 0;
 132         r |= (l & O_FSYNC) ? SVR4_O_SYNC : 0;
 133         r |= (l & O_NONBLOCK) ? SVR4_O_NONBLOCK : 0;
 134         r |= (l & O_EXLOCK) ? SVR4_O_PRIV : 0;
 135         r |= (l & O_CREAT) ? SVR4_O_CREAT : 0;
 136         r |= (l & O_TRUNC) ? SVR4_O_TRUNC : 0;
 137         r |= (l & O_EXCL) ? SVR4_O_EXCL : 0;
 138         r |= (l & O_NOCTTY) ? SVR4_O_NOCTTY : 0;
 139         return r;
 140 }
 141
 142
 143 static void
 144 bsd_to_svr4_flock(iflp, oflp)
 145         struct flock            *iflp;
 146         struct svr4_flock       *oflp;
 147 {
 148         switch (iflp->l_type) {
 149         case F_RDLCK:
 150                 oflp->l_type = SVR4_F_RDLCK;
 151                 break;
 152         case F_WRLCK:
 153                 oflp->l_type = SVR4_F_WRLCK;
 154                 break;
 155         case F_UNLCK:
 156                 oflp->l_type = SVR4_F_UNLCK;
 157                 break;
 158         default:
 159                 oflp->l_type = -1;
 160                 break;
 161         }
 162
 163         oflp->l_whence = (short) iflp->l_whence;
 164         oflp->l_start = (svr4_off_t) iflp->l_start;
 165         oflp->l_len = (svr4_off_t) iflp->l_len;
 166         oflp->l_sysid = 0;
 167         oflp->l_pid = (svr4_pid_t) iflp->l_pid;
 168 }
 169
 170
 171 static void
 172 svr4_to_bsd_flock(iflp, oflp)
 173         struct svr4_flock       *iflp;
 174         struct flock            *oflp;
 175 {
 176         switch (iflp->l_type) {
 177         case SVR4_F_RDLCK:
 178                 oflp->l_type = F_RDLCK;
 179                 break;
 180         case SVR4_F_WRLCK:
 181                 oflp->l_type = F_WRLCK;
 182                 break;
 183         case SVR4_F_UNLCK:
 184                 oflp->l_type = F_UNLCK;
 185                 break;
 186         default:
 187                 oflp->l_type = -1;
 188                 break;
 189         }
 190
 191         oflp->l_whence = iflp->l_whence;
 192         oflp->l_start = (off_t) iflp->l_start;
 193         oflp->l_len = (off_t) iflp->l_len;
 194         oflp->l_pid = (pid_t) iflp->l_pid;
 195         oflp->l_sysid = iflp->l_sysid;
 196 }
 197
 198 static void
 199 bsd_to_svr4_flock64(iflp, oflp)
 200         struct flock            *iflp;
 201         struct svr4_flock64     *oflp;
 202 {
 203         switch (iflp->l_type) {
 204         case F_RDLCK:
 205                 oflp->l_type = SVR4_F_RDLCK;
 206                 break;
 207         case F_WRLCK:
 208                 oflp->l_type = SVR4_F_WRLCK;
 209                 break;
 210         case F_UNLCK:
 211                 oflp->l_type = SVR4_F_UNLCK;
 212                 break;
 213         default:
 214                 oflp->l_type = -1;
 215                 break;
 216         }
 217
 218         oflp->l_whence = (short) iflp->l_whence;
 219         oflp->l_start = (svr4_off64_t) iflp->l_start;
 220         oflp->l_len = (svr4_off64_t) iflp->l_len;
 221         oflp->l_sysid = iflp->l_sysid;
 222         oflp->l_pid = (svr4_pid_t) iflp->l_pid;
 223 }
 224
 225
 226 static void
 227 svr4_to_bsd_flock64(iflp, oflp)
 228         struct svr4_flock64     *iflp;
 229         struct flock            *oflp;
 230 {
 231         switch (iflp->l_type) {
 232         case SVR4_F_RDLCK:
 233                 oflp->l_type = F_RDLCK;
 234                 break;
 235         case SVR4_F_WRLCK:
 236                 oflp->l_type = F_WRLCK;
 237                 break;
 238         case SVR4_F_UNLCK:
 239                 oflp->l_type = F_UNLCK;
 240                 break;
 241         default:
 242                 oflp->l_type = -1;
 243                 break;
 244         }
 245
 246         oflp->l_whence = iflp->l_whence;
 247         oflp->l_start = (off_t) iflp->l_start;
 248         oflp->l_len = (off_t) iflp->l_len;
 249         oflp->l_pid = (pid_t) iflp->l_pid;
 250
 251 }
 252
 253
 254 static int
 255 fd_revoke(td, fd)
 256         struct thread *td;
 257         int fd;
 258 {
 259         struct vnode *vp;
 260         struct mount *mp;
 261         struct vattr vattr;
 262         cap_rights_t rights;
 263         int error, *retval;
 264
 265         retval = td->td_retval;
 266         /*
 267          * If we ever want to support Capsicum on SVR4 processes (unlikely)
 268          * or FreeBSD grows a native frevoke() (more likely), we will need a
 269          * CAP_FREVOKE here.
 270          *
 271          * In the meantime, use CAP_ALL(): if a SVR4 process wants to
 272          * do an frevoke(), it needs to do it on either a regular file
 273          * descriptor or a fully-privileged capability (which is effectively
 274          * the same as a non-capability-restricted file descriptor).
 275          */
 276         CAP_ALL(&rights);
 277         if ((error = fgetvp(td, fd, &rights, &vp)) != 0)
 278                 return (error);
 279
 280         if (vp->v_type != VCHR && vp->v_type != VBLK) {
 281                 error = EINVAL;
 282                 goto out;
 283         }
 284
 285 #ifdef MAC
 286         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 287         error = mac_vnode_check_revoke(td->td_ucred, vp);
 288         VOP_UNLOCK(vp, 0);
 289         if (error)
 290                 goto out;
 291 #endif
 292
 293         if ((error = VOP_GETATTR(vp, &vattr, td->td_ucred)) != 0)
 294                 goto out;
 295
 296         if (td->td_ucred->cr_uid != vattr.va_uid &&
 297             (error = priv_check(td, PRIV_VFS_ADMIN)) != 0)
 298                 goto out;
 299
 300         if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
 301                 goto out;
 302         if (vcount(vp) > 1)
 303                 VOP_REVOKE(vp, REVOKEALL);
 304         vn_finished_write(mp);
 305 out:
 306         vrele(vp);
 307         return error;
 308 }
 309
 310
 311 static int
 312 fd_truncate(td, fd, flp)
 313         struct thread *td;
 314         int fd;
 315         struct flock *flp;
 316 {
 317         off_t start, length;
 318         struct file *fp;
 319         struct vnode *vp;
 320         struct vattr vattr;
 321         int error, *retval;
 322         struct ftruncate_args ft;
 323         cap_rights_t rights;
 324
 325         retval = td->td_retval;
 326
 327         /*
 328          * We only support truncating the file.
 329          */
 330         error = fget(td, fd, cap_rights_init(&rights, CAP_FTRUNCATE), &fp);
 331         if (error != 0)
 332                 return (error);
 333
 334         vp = fp->f_vnode;
 335
 336         if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) {
 337                 fdrop(fp, td);
 338                 return ESPIPE;
 339         }
 340
 341         if ((error = VOP_GETATTR(vp, &vattr, td->td_ucred)) != 0) {
 342                 fdrop(fp, td);
 343                 return error;
 344         }
 345
 346         length = vattr.va_size;
 347
 348         switch (flp->l_whence) {
 349         case SEEK_CUR:
 350                 start = fp->f_offset + flp->l_start;
 351                 break;
 352
 353         case SEEK_END:
 354                 start = flp->l_start + length;
 355                 break;
 356
 357         case SEEK_SET:
 358                 start = flp->l_start;
 359                 break;
 360
 361         default:
 362                 fdrop(fp, td);
 363                 return EINVAL;
 364         }
 365
 366         if (start + flp->l_len < length) {
 367                 /* We don't support free'ing in the middle of the file */
 368                 fdrop(fp, td);
 369                 return EINVAL;
 370         }
 371
 372         ft.fd = fd;
 373         ft.length = start;
 374
 375         error = sys_ftruncate(td, &ft);
 376
 377         fdrop(fp, td);
 378         return (error);
 379 }
 380
 381 int
 382 svr4_sys_open(td, uap)
 383         struct thread *td;
 384         struct svr4_sys_open_args *uap;
 385 {
 386         struct proc *p = td->td_proc;
 387         char *newpath;
 388         int bsd_flags, error, retval;
 389
 390         CHECKALTEXIST(td, uap->path, &newpath);
 391
 392         bsd_flags = svr4_to_bsd_flags(uap->flags);
 393         error = kern_open(td, newpath, UIO_SYSSPACE, bsd_flags, uap->mode);
 394         free(newpath, M_TEMP);
 395
 396         if (error) {
 397           /*            uprintf("svr4_open(%s, 0x%0x, 0%o): %d\n", uap->path,
 398                         uap->flags, uap->mode, error);*/
 399                 return error;
 400         }
 401
 402         retval = td->td_retval[0];
 403
 404         PROC_LOCK(p);
 405         if (!(bsd_flags & O_NOCTTY) && SESS_LEADER(p) &&
 406             !(p->p_flag & P_CONTROLT)) {
 407 #if defined(NOTYET)
 408                 cap_rights_t rights;
 409                 struct file *fp;
 410
 411                 error = fget(td, retval,
 412                     cap_rights_init(&rights, CAP_IOCTL), &fp);
 413                 PROC_UNLOCK(p);
 414                 /*
 415                  * we may have lost a race the above open() and
 416                  * another thread issuing a close()
 417                  */
 418                 if (error)
 419                         return (EBADF); /* XXX: correct errno? */
 420                 /* ignore any error, just give it a try */
 421                 if (fp->f_type == DTYPE_VNODE)
 422                         fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0, td->td_ucred,
 423                             td);
 424                 fdrop(fp, td);
 425         } else {
 426                 PROC_UNLOCK(p);
 427         }
 428 #else
 429         }
 430         PROC_UNLOCK(p);
 431 #endif
 432         return error;
 433 }
 434
 435 int
 436 svr4_sys_open64(td, uap)
 437         struct thread *td;
 438         struct svr4_sys_open64_args *uap;
 439 {
 440         return svr4_sys_open(td, (struct svr4_sys_open_args *)uap);
 441 }
 442
 443 int
 444 svr4_sys_creat(td, uap)
 445         struct thread *td;
 446         struct svr4_sys_creat_args *uap;
 447 {
 448         char *newpath;
 449         int error;
 450
 451         CHECKALTEXIST(td, uap->path, &newpath);
 452
 453         error = kern_open(td, newpath, UIO_SYSSPACE, O_WRONLY | O_CREAT |
 454             O_TRUNC, uap->mode);
 455         free(newpath, M_TEMP);
 456         return (error);
 457 }
 458
 459 int
 460 svr4_sys_creat64(td, uap)
 461         struct thread *td;
 462         struct svr4_sys_creat64_args *uap;
 463 {
 464         return svr4_sys_creat(td, (struct svr4_sys_creat_args *)uap);
 465 }
 466
 467 int
 468 svr4_sys_llseek(td, uap)
 469         struct thread *td;
 470         struct svr4_sys_llseek_args *uap;
 471 {
 472         struct lseek_args ap;
 473
 474         ap.fd = uap->fd;
 475
 476 #if BYTE_ORDER == BIG_ENDIAN
 477         ap.offset = (((u_int64_t) uap->offset1) << 32) |
 478                 uap->offset2;
 479 #else
 480         ap.offset = (((u_int64_t) uap->offset2) << 32) |
 481                 uap->offset1;
 482 #endif
 483         ap.whence = uap->whence;
 484
 485         return sys_lseek(td, &ap);
 486 }
 487
 488 int
 489 svr4_sys_access(td, uap)
 490         struct thread *td;
 491         struct svr4_sys_access_args *uap;
 492 {
 493         char *newpath;
 494         int error;
 495
 496         CHECKALTEXIST(td, uap->path, &newpath);
 497         error = kern_access(td, newpath, UIO_SYSSPACE, uap->amode);
 498         free(newpath, M_TEMP);
 499         return (error);
 500 }
 501
 502 #if defined(NOTYET)
 503 int
 504 svr4_sys_pread(td, uap)
 505         struct thread *td;
 506         struct svr4_sys_pread_args *uap;
 507 {
 508         struct pread_args pra;
 509
 510         /*
 511          * Just translate the args structure and call the NetBSD
 512          * pread(2) system call (offset type is 64-bit in NetBSD).
 513          */
 514         pra.fd = uap->fd;
 515         pra.buf = uap->buf;
 516         pra.nbyte = uap->nbyte;
 517         pra.offset = uap->off;
 518
 519         return pread(td, &pra);
 520 }
 521 #endif
 522
 523 #if defined(NOTYET)
 524 int
 525 svr4_sys_pread64(td, v, retval)
 526         struct thread *td;
 527         void *v;
 528         register_t *retval;
 529 {
 530
 531         struct svr4_sys_pread64_args *uap = v;
 532         struct sys_pread_args pra;
 533
 534         /*
 535          * Just translate the args structure and call the NetBSD
 536          * pread(2) system call (offset type is 64-bit in NetBSD).
 537          */
 538         pra.fd = uap->fd;
 539         pra.buf = uap->buf;
 540         pra.nbyte = uap->nbyte;
 541         pra.offset = uap->off;
 542
 543         return (sys_pread(td, &pra, retval));
 544 }
 545 #endif /* NOTYET */
 546
 547 #if defined(NOTYET)
 548 int
 549 svr4_sys_pwrite(td, uap)
 550         struct thread *td;
 551         struct svr4_sys_pwrite_args *uap;
 552 {
 553         struct pwrite_args pwa;
 554
 555         /*
 556          * Just translate the args structure and call the NetBSD
 557          * pwrite(2) system call (offset type is 64-bit in NetBSD).
 558          */
 559         pwa.fd = uap->fd;
 560         pwa.buf = uap->buf;
 561         pwa.nbyte = uap->nbyte;
 562         pwa.offset = uap->off;
 563
 564         return pwrite(td, &pwa);
 565 }
 566 #endif
 567
 568 #if defined(NOTYET)
 569 int
 570 svr4_sys_pwrite64(td, v, retval)
 571         struct thread *td;
 572         void *v;
 573         register_t *retval;
 574 {
 575         struct svr4_sys_pwrite64_args *uap = v;
 576         struct sys_pwrite_args pwa;
 577
 578         /*
 579          * Just translate the args structure and call the NetBSD
 580          * pwrite(2) system call (offset type is 64-bit in NetBSD).
 581          */
 582         pwa.fd = uap->fd;
 583         pwa.buf = uap->buf;
 584         pwa.nbyte = uap->nbyte;
 585         pwa.offset = uap->off;
 586
 587         return (sys_pwrite(td, &pwa, retval));
 588 }
 589 #endif /* NOTYET */
 590
 591 int
 592 svr4_sys_fcntl(td, uap)
 593         struct thread *td;
 594         struct svr4_sys_fcntl_args *uap;
 595 {
 596         int cmd, error, *retval;
 597
 598         retval = td->td_retval;
 599
 600         cmd = svr4_to_bsd_cmd(uap->cmd);
 601
 602         switch (cmd) {
 603         case F_DUPFD:
 604         case F_DUP2FD:
 605         case F_GETFD:
 606         case F_SETFD:
 607                 return (kern_fcntl(td, uap->fd, cmd, (intptr_t)uap->arg));
 608
 609         case F_GETFL:
 610                 error = kern_fcntl(td, uap->fd, cmd, (intptr_t)uap->arg);
 611                 if (error)
 612                         return (error);
 613                 *retval = bsd_to_svr4_flags(*retval);
 614                 return (error);
 615
 616         case F_SETFL:
 617                 {
 618                         /*
 619                          * we must save the O_ASYNC flag, as that is
 620                          * handled by ioctl(_, I_SETSIG, _) emulation.
 621                          */
 622                         int flags;
 623
 624                         DPRINTF(("Setting flags %p\n", uap->arg));
 625
 626                         error = kern_fcntl(td, uap->fd, F_GETFL, 0);
 627                         if (error)
 628                                 return (error);
 629                         flags = *retval;
 630                         flags &= O_ASYNC;
 631                         flags |= svr4_to_bsd_flags((u_long) uap->arg);
 632                         return (kern_fcntl(td, uap->fd, F_SETFL, flags));
 633                 }
 634
 635         case F_GETLK:
 636         case F_SETLK:
 637         case F_SETLKW:
 638                 {
 639                         struct svr4_flock       ifl;
 640                         struct flock            fl;
 641
 642                         error = copyin(uap->arg, &ifl, sizeof (ifl));
 643                         if (error)
 644                                 return (error);
 645
 646                         svr4_to_bsd_flock(&ifl, &fl);
 647
 648                         error = kern_fcntl(td, uap->fd, cmd, (intptr_t)&fl);
 649                         if (error || cmd != F_GETLK)
 650                                 return (error);
 651
 652                         bsd_to_svr4_flock(&fl, &ifl);
 653
 654                         return (copyout(&ifl, uap->arg, sizeof (ifl)));
 655                 }
 656         case -1:
 657                 switch (uap->cmd) {
 658                 case SVR4_F_FREESP:
 659                         {
 660                                 struct svr4_flock        ifl;
 661                                 struct flock             fl;
 662
 663                                 error = copyin(uap->arg, &ifl,
 664                                     sizeof ifl);
 665                                 if (error)
 666                                         return error;
 667                                 svr4_to_bsd_flock(&ifl, &fl);
 668                                 return fd_truncate(td, uap->fd, &fl);
 669                         }
 670
 671                 case SVR4_F_GETLK64:
 672                 case SVR4_F_SETLK64:
 673                 case SVR4_F_SETLKW64:
 674                         {
 675                                 struct svr4_flock64     ifl;
 676                                 struct flock            fl;
 677
 678                                 switch (uap->cmd) {
 679                                 case SVR4_F_GETLK64:
 680                                         cmd = F_GETLK;
 681                                         break;
 682                                 case SVR4_F_SETLK64:
 683                                         cmd = F_SETLK;
 684                                         break;
 685                                 case SVR4_F_SETLKW64:
 686                                         cmd = F_SETLKW;
 687                                         break;
 688                                 }
 689                                 error = copyin(uap->arg, &ifl,
 690                                     sizeof (ifl));
 691                                 if (error)
 692                                         return (error);
 693
 694                                 svr4_to_bsd_flock64(&ifl, &fl);
 695
 696                                 error = kern_fcntl(td, uap->fd, cmd,
 697                                     (intptr_t)&fl);
 698                                 if (error || cmd != F_GETLK)
 699                                         return (error);
 700
 701                                 bsd_to_svr4_flock64(&fl, &ifl);
 702
 703                                 return (copyout(&ifl, uap->arg,
 704                                     sizeof (ifl)));
 705                         }
 706
 707                 case SVR4_F_FREESP64:
 708                         {
 709                                 struct svr4_flock64      ifl;
 710                                 struct flock             fl;
 711
 712                                 error = copyin(uap->arg, &ifl,
 713                                     sizeof ifl);
 714                                 if (error)
 715                                         return error;
 716                                 svr4_to_bsd_flock64(&ifl, &fl);
 717                                 return fd_truncate(td, uap->fd, &fl);
 718                         }
 719
 720                 case SVR4_F_REVOKE:
 721                         return fd_revoke(td, uap->fd);
 722
 723                 default:
 724                         return ENOSYS;
 725                 }
 726
 727         default:
 728                 return ENOSYS;
 729         }
 730 }