sys/compat/svr4_32/svr4_32_fcntl.c

   1 /*      $NetBSD: svr4_32_fcntl.c,v 1.33 2008/03/21 21:54:59 ad Exp $     */
   2
   3 /*-
   4  * Copyright (c) 1994, 1997, 2008 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Christos Zoulas.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __KERNEL_RCSID(0, "$NetBSD: svr4_32_fcntl.c,v 1.33 2008/03/21 21:54:59 ad Exp $");
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/namei.h>
  38 #include <sys/proc.h>
  39 #include <sys/file.h>
  40 #include <sys/stat.h>
  41 #include <sys/filedesc.h>
  42 #include <sys/ioctl.h>
  43 #include <sys/kernel.h>
  44 #include <sys/mount.h>
  45 #include <sys/malloc.h>
  46 #include <sys/vnode.h>
  47 #include <sys/kauth.h>
  48
  49 #include <sys/syscallargs.h>
  50
  51 #include <compat/svr4_32/svr4_32_types.h>
  52 #include <compat/svr4_32/svr4_32_signal.h>
  53 #include <compat/svr4_32/svr4_32_ucontext.h>
  54 #include <compat/svr4_32/svr4_32_lwp.h>
  55 #include <compat/svr4_32/svr4_32_syscallargs.h>
  56 #include <compat/svr4_32/svr4_32_util.h>
  57 #include <compat/svr4_32/svr4_32_fcntl.h>
  58
  59 static int svr4_32_to_bsd_flags(int);
  60 static int bsd_to_svr4_32_flags(int);
  61 static void bsd_to_svr4_32_flock(struct flock *, struct svr4_32_flock *);
  62 static void svr4_32_to_bsd_flock(struct svr4_32_flock *, struct flock *);
  63 static void bsd_to_svr4_32_flock64(struct flock *, struct svr4_32_flock64 *);
  64 static void svr4_32_to_bsd_flock64(struct svr4_32_flock64 *, struct flock *);
  65 static int fd_revoke(struct lwp *, int, register_t *);
  66 static int fd_truncate(struct lwp *, int, struct flock *, register_t *);
  67
  68
  69 static int
  70 svr4_32_to_bsd_flags(int l)
  71 {
  72         int     r = 0;
  73         r |= (l & SVR4_O_RDONLY) ? O_RDONLY : 0;
  74         r |= (l & SVR4_O_WRONLY) ? O_WRONLY : 0;
  75         r |= (l & SVR4_O_RDWR) ? O_RDWR : 0;
  76         r |= (l & SVR4_O_NDELAY) ? O_NDELAY : 0;
  77         r |= (l & SVR4_O_APPEND) ? O_APPEND : 0;
  78         r |= (l & SVR4_O_SYNC) ? O_FSYNC : 0;
  79         r |= (l & SVR4_O_RSYNC) ? O_RSYNC : 0;
  80         r |= (l & SVR4_O_DSYNC) ? O_DSYNC : 0;
  81         r |= (l & SVR4_O_NONBLOCK) ? O_NONBLOCK : 0;
  82         r |= (l & SVR4_O_PRIV) ? O_EXLOCK : 0;
  83         r |= (l & SVR4_O_CREAT) ? O_CREAT : 0;
  84         r |= (l & SVR4_O_TRUNC) ? O_TRUNC : 0;
  85         r |= (l & SVR4_O_EXCL) ? O_EXCL : 0;
  86         r |= (l & SVR4_O_NOCTTY) ? O_NOCTTY : 0;
  87         return r;
  88 }
  89
  90
  91 static int
  92 bsd_to_svr4_32_flags(int l)
  93 {
  94         int     r = 0;
  95         r |= (l & O_RDONLY) ? SVR4_O_RDONLY : 0;
  96         r |= (l & O_WRONLY) ? SVR4_O_WRONLY : 0;
  97         r |= (l & O_RDWR) ? SVR4_O_RDWR : 0;
  98         r |= (l & O_NDELAY) ? SVR4_O_NDELAY : 0;
  99         r |= (l & O_APPEND) ? SVR4_O_APPEND : 0;
 100         r |= (l & O_FSYNC) ? SVR4_O_SYNC : 0;
 101         r |= (l & O_RSYNC) ? SVR4_O_RSYNC : 0;
 102         r |= (l & O_DSYNC) ? SVR4_O_DSYNC : 0;
 103         r |= (l & O_NONBLOCK) ? SVR4_O_NONBLOCK : 0;
 104         r |= (l & O_EXLOCK) ? SVR4_O_PRIV : 0;
 105         r |= (l & O_CREAT) ? SVR4_O_CREAT : 0;
 106         r |= (l & O_TRUNC) ? SVR4_O_TRUNC : 0;
 107         r |= (l & O_EXCL) ? SVR4_O_EXCL : 0;
 108         r |= (l & O_NOCTTY) ? SVR4_O_NOCTTY : 0;
 109         return r;
 110 }
 111
 112
 113 static void
 114 bsd_to_svr4_32_flock(struct flock *iflp, struct svr4_32_flock *oflp)
 115 {
 116         switch (iflp->l_type) {
 117         case F_RDLCK:
 118                 oflp->l_type = SVR4_F_RDLCK;
 119                 break;
 120         case F_WRLCK:
 121                 oflp->l_type = SVR4_F_WRLCK;
 122                 break;
 123         case F_UNLCK:
 124                 oflp->l_type = SVR4_F_UNLCK;
 125                 break;
 126         default:
 127                 oflp->l_type = -1;
 128                 break;
 129         }
 130
 131         oflp->l_whence = (short) iflp->l_whence;
 132         oflp->l_start = (svr4_32_off_t) iflp->l_start;
 133         oflp->l_len = (svr4_32_off_t) iflp->l_len;
 134         oflp->l_sysid = 0;
 135         oflp->l_pid = (svr4_32_pid_t) iflp->l_pid;
 136 }
 137
 138
 139 static void
 140 svr4_32_to_bsd_flock(struct svr4_32_flock *iflp, struct flock *oflp)
 141 {
 142         switch (iflp->l_type) {
 143         case SVR4_F_RDLCK:
 144                 oflp->l_type = F_RDLCK;
 145                 break;
 146         case SVR4_F_WRLCK:
 147                 oflp->l_type = F_WRLCK;
 148                 break;
 149         case SVR4_F_UNLCK:
 150                 oflp->l_type = F_UNLCK;
 151                 break;
 152         default:
 153                 oflp->l_type = -1;
 154                 break;
 155         }
 156
 157         oflp->l_whence = iflp->l_whence;
 158         oflp->l_start = (off_t) iflp->l_start;
 159         oflp->l_len = (off_t) iflp->l_len;
 160         oflp->l_pid = (pid_t) iflp->l_pid;
 161
 162 }
 163
 164 static void
 165 bsd_to_svr4_32_flock64(struct flock *iflp, struct svr4_32_flock64 *oflp)
 166 {
 167         switch (iflp->l_type) {
 168         case F_RDLCK:
 169                 oflp->l_type = SVR4_F_RDLCK;
 170                 break;
 171         case F_WRLCK:
 172                 oflp->l_type = SVR4_F_WRLCK;
 173                 break;
 174         case F_UNLCK:
 175                 oflp->l_type = SVR4_F_UNLCK;
 176                 break;
 177         default:
 178                 oflp->l_type = -1;
 179                 break;
 180         }
 181
 182         oflp->l_whence = (short) iflp->l_whence;
 183         oflp->l_start = (svr4_32_off64_t) iflp->l_start;
 184         oflp->l_len = (svr4_32_off64_t) iflp->l_len;
 185         oflp->l_sysid = 0;
 186         oflp->l_pid = (svr4_32_pid_t) iflp->l_pid;
 187 }
 188
 189
 190 static void
 191 svr4_32_to_bsd_flock64(struct svr4_32_flock64 *iflp, struct flock *oflp)
 192 {
 193         switch (iflp->l_type) {
 194         case SVR4_F_RDLCK:
 195                 oflp->l_type = F_RDLCK;
 196                 break;
 197         case SVR4_F_WRLCK:
 198                 oflp->l_type = F_WRLCK;
 199                 break;
 200         case SVR4_F_UNLCK:
 201                 oflp->l_type = F_UNLCK;
 202                 break;
 203         default:
 204                 oflp->l_type = -1;
 205                 break;
 206         }
 207
 208         oflp->l_whence = iflp->l_whence;
 209         oflp->l_start = (off_t) iflp->l_start;
 210         oflp->l_len = (off_t) iflp->l_len;
 211         oflp->l_pid = (pid_t) iflp->l_pid;
 212
 213 }
 214
 215
 216 static int
 217 fd_revoke(struct lwp *l, int fd, register_t *retval)
 218 {
 219         file_t *fp;
 220         struct vnode *vp;
 221         int error;
 222
 223         if ((fp = fd_getfile(fd)) == NULL)
 224                 return EBADF;
 225
 226         if (fp->f_type != DTYPE_VNODE) {
 227                 fd_putfile(fd);
 228                 return EINVAL;
 229         }
 230
 231         vp = fp->f_data;
 232         if (vp->v_type != VCHR && vp->v_type != VBLK) {
 233                 error = EINVAL;
 234                 goto out;
 235         }
 236         error = dorevoke(vp, l->l_cred);
 237 out:
 238         vrele(vp);
 239         fd_putfile(fd);
 240         return error;
 241 }
 242
 243
 244 static int
 245 fd_truncate(struct lwp *l, int fd, struct flock *flp, register_t *retval)
 246 {
 247         file_t *fp;
 248         off_t start, length;
 249         struct vnode *vp;
 250         struct vattr vattr;
 251         int error;
 252         struct sys_ftruncate_args ft;
 253
 254         /*
 255          * We only support truncating the file.
 256          */
 257         if ((fp = fd_getfile(fd)) == NULL)
 258                 return EBADF;
 259         vp = fp->f_data;
 260         if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) {
 261                 fd_putfile(fd);
 262                 return ESPIPE;
 263         }
 264         if ((error = VOP_GETATTR(vp, &vattr, l->l_cred)) != 0) {
 265                 fd_putfile(fd);
 266                 return error;
 267         }
 268
 269         length = vattr.va_size;
 270
 271         switch (flp->l_whence) {
 272         case SEEK_CUR:
 273                 start = fp->f_offset + flp->l_start;
 274                 break;
 275
 276         case SEEK_END:
 277                 start = flp->l_start + length;
 278                 break;
 279
 280         case SEEK_SET:
 281                 start = flp->l_start;
 282                 break;
 283
 284         default:
 285                 fd_putfile(fd);
 286                 return EINVAL;
 287         }
 288
 289         if (start + flp->l_len < length) {
 290                 /* We don't support free'ing in the middle of the file */
 291                 fd_putfile(fd);
 292                 return EINVAL;
 293         }
 294
 295         SCARG(&ft, fd) = fd;
 296         SCARG(&ft, length) = start;
 297
 298         error = sys_ftruncate(l, &ft, retval);
 299         fd_putfile(fd);
 300         return error;
 301 }
 302
 303
 304 int
 305 svr4_32_sys_open(struct lwp *l, const struct svr4_32_sys_open_args *uap, register_t *retval)
 306 {
 307         int                     error;
 308         struct sys_open_args    cup;
 309
 310         SCARG(&cup, flags) = svr4_32_to_bsd_flags(SCARG(uap, flags));
 311
 312         SCARG(&cup, path) = SCARG_P32(uap, path);
 313         SCARG(&cup, mode) = SCARG(uap, mode);
 314         error = sys_open(l, &cup, retval);
 315
 316         if (error)
 317                 return error;
 318
 319         /* XXXAD locking */
 320
 321         if (!(SCARG(&cup, flags) & O_NOCTTY) && SESS_LEADER(l->l_proc) &&
 322             !(l->l_proc->p_lflag & PL_CONTROLT)) {
 323                 file_t *fp;
 324                 int fd;
 325
 326                 fd = *retval;
 327                 fp = fd_getfile(fd);
 328
 329                 /* ignore any error, just give it a try */
 330                 if (fp != NULL) {
 331                         if (fp->f_type == DTYPE_VNODE)
 332                                 (fp->f_ops->fo_ioctl)(fp, TIOCSCTTY, NULL);
 333                         fd_putfile(fd);
 334                 }
 335         }
 336         return 0;
 337 }
 338
 339
 340 int
 341 svr4_32_sys_creat(struct lwp *l, const struct svr4_32_sys_creat_args *uap, register_t *retval)
 342 {
 343         struct sys_open_args cup;
 344
 345         SCARG(&cup, path) = SCARG_P32(uap, path);
 346         SCARG(&cup, mode) = SCARG(uap, mode);
 347         SCARG(&cup, flags) = O_WRONLY | O_CREAT | O_TRUNC;
 348
 349         return sys_open(l, &cup, retval);
 350 }
 351
 352
 353 int
 354 svr4_32_sys_llseek(struct lwp *l, const struct svr4_32_sys_llseek_args *uap, register_t *retval)
 355 {
 356         struct sys_lseek_args ap;
 357
 358         SCARG(&ap, fd) = SCARG(uap, fd);
 359
 360 #if BYTE_ORDER == BIG_ENDIAN
 361         SCARG(&ap, offset) = (((long long) SCARG(uap, offset1)) << 32) |
 362                 SCARG(uap, offset2);
 363 #else
 364         SCARG(&ap, offset) = (((long long) SCARG(uap, offset2)) << 32) |
 365                 SCARG(uap, offset1);
 366 #endif
 367         SCARG(&ap, whence) = SCARG(uap, whence);
 368
 369         return sys_lseek(l, &ap, retval);
 370 }
 371
 372 int
 373 svr4_32_sys_access(struct lwp *l, const struct svr4_32_sys_access_args *uap, register_t *retval)
 374 {
 375         struct sys_access_args cup;
 376
 377         SCARG(&cup, path) = SCARG_P32(uap, path);
 378         SCARG(&cup, flags) = SCARG(uap, flags);
 379
 380         return sys_access(l, &cup, retval);
 381 }
 382
 383
 384 int
 385 svr4_32_sys_pread(struct lwp *l, const struct svr4_32_sys_pread_args *uap, register_t *retval)
 386 {
 387         struct sys_pread_args pra;
 388
 389         /*
 390          * Just translate the args structure and call the NetBSD
 391          * pread(2) system call (offset type is 64-bit in NetBSD).
 392          */
 393         SCARG(&pra, fd) = SCARG(uap, fd);
 394         SCARG(&pra, buf) = SCARG_P32(uap, buf);
 395         SCARG(&pra, nbyte) = SCARG(uap, nbyte);
 396         SCARG(&pra, offset) = SCARG(uap, off);
 397
 398         return (sys_pread(l, &pra, retval));
 399 }
 400
 401
 402 int
 403 svr4_32_sys_pread64(struct lwp *l, const struct svr4_32_sys_pread64_args *uap, register_t *retval)
 404 {
 405         struct sys_pread_args pra;
 406
 407         /*
 408          * Just translate the args structure and call the NetBSD
 409          * pread(2) system call (offset type is 64-bit in NetBSD).
 410          */
 411         SCARG(&pra, fd) = SCARG(uap, fd);
 412         SCARG(&pra, buf) = SCARG_P32(uap, buf);
 413         SCARG(&pra, nbyte) = SCARG(uap, nbyte);
 414         SCARG(&pra, offset) = SCARG(uap, off);
 415
 416         return (sys_pread(l, &pra, retval));
 417 }
 418
 419
 420 int
 421 svr4_32_sys_pwrite(struct lwp *l, const struct svr4_32_sys_pwrite_args *uap, register_t *retval)
 422 {
 423         struct sys_pwrite_args pwa;
 424
 425         /*
 426          * Just translate the args structure and call the NetBSD
 427          * pwrite(2) system call (offset type is 64-bit in NetBSD).
 428          */
 429         SCARG(&pwa, fd) = SCARG(uap, fd);
 430         SCARG(&pwa, buf) = SCARG_P32(uap, buf);
 431         SCARG(&pwa, nbyte) = SCARG(uap, nbyte);
 432         SCARG(&pwa, offset) = SCARG(uap, off);
 433
 434         return (sys_pwrite(l, &pwa, retval));
 435 }
 436
 437
 438 int
 439 svr4_32_sys_pwrite64(struct lwp *l, const struct svr4_32_sys_pwrite64_args *uap, register_t *retval)
 440 {
 441         struct sys_pwrite_args pwa;
 442
 443         /*
 444          * Just translate the args structure and call the NetBSD
 445          * pwrite(2) system call (offset type is 64-bit in NetBSD).
 446          */
 447         SCARG(&pwa, fd) = SCARG(uap, fd);
 448         SCARG(&pwa, buf) = SCARG_P32(uap, buf);
 449         SCARG(&pwa, nbyte) = SCARG(uap, nbyte);
 450         SCARG(&pwa, offset) = SCARG(uap, off);
 451
 452         return (sys_pwrite(l, &pwa, retval));
 453 }
 454
 455
 456 int
 457 svr4_32_sys_fcntl(struct lwp *l, const struct svr4_32_sys_fcntl_args *uap, register_t *retval)
 458 {
 459         struct sys_fcntl_args   fa;
 460         register_t              flags;
 461         struct svr4_32_flock64  ifl64;
 462         struct svr4_32_flock    ifl;
 463         struct flock            fl;
 464         int error;
 465         int cmd;
 466
 467         SCARG(&fa, fd) = SCARG(uap, fd);
 468         SCARG(&fa, arg) = SCARG_P32(uap, arg);
 469
 470         switch (SCARG(uap, cmd)) {
 471         case SVR4_F_DUPFD:
 472                 cmd = F_DUPFD;
 473                 break;
 474         case SVR4_F_GETFD:
 475                 cmd = F_GETFD;
 476                 break;
 477         case SVR4_F_SETFD:
 478                 cmd = F_SETFD;
 479                 break;
 480
 481         case SVR4_F_GETFL:
 482                 cmd = F_GETFL;
 483                 break;
 484
 485         case SVR4_F_SETFL:
 486                 /*
 487                  * we must save the O_ASYNC flag, as that is
 488                  * handled by ioctl(_, I_SETSIG, _) emulation.
 489                  */
 490                 SCARG(&fa, cmd) = F_GETFL;
 491                 if ((error = sys_fcntl(l, &fa, &flags)) != 0)
 492                         return error;
 493                 flags &= O_ASYNC;
 494                 flags |= svr4_32_to_bsd_flags((u_long) SCARG_P32(uap, arg));
 495                 cmd = F_SETFL;
 496                 SCARG(&fa, arg) = (void *) flags;
 497                 break;
 498
 499         case SVR4_F_GETLK:
 500                 cmd = F_GETLK;
 501                 goto lock32;
 502         case SVR4_F_SETLK:
 503                 cmd = F_SETLK;
 504                 goto lock32;
 505         case SVR4_F_SETLKW:
 506                 cmd = F_SETLKW;
 507             lock32:
 508                 error = copyin(SCARG_P32(uap, arg), &ifl, sizeof ifl);
 509                 if (error)
 510                         return error;
 511                 svr4_32_to_bsd_flock(&ifl, &fl);
 512
 513                 error = do_fcntl_lock(SCARG(uap, fd), cmd, &fl);
 514                 if (cmd != F_GETLK || error != 0)
 515                         return error;
 516
 517                 bsd_to_svr4_32_flock(&fl, &ifl);
 518                 return copyout(&ifl, SCARG_P32(uap, arg), sizeof ifl);
 519
 520         case SVR4_F_DUP2FD:
 521                 {
 522                         struct sys_dup2_args du;
 523
 524                         SCARG(&du, from) = SCARG(uap, fd);
 525                         SCARG(&du, to) = (int)(u_long)SCARG_P32(uap, arg);
 526                         error = sys_dup2(l, &du, retval);
 527                         if (error)
 528                                 return error;
 529                         *retval = SCARG(&du, to);
 530                         return 0;
 531                 }
 532
 533         case SVR4_F_FREESP:
 534                 error = copyin(SCARG_P32(uap, arg), &ifl, sizeof ifl);
 535                 if (error)
 536                         return error;
 537                 svr4_32_to_bsd_flock(&ifl, &fl);
 538                 return fd_truncate(l, SCARG(uap, fd), &fl, retval);
 539
 540         case SVR4_F_GETLK64:
 541                 cmd = F_GETLK;
 542                 goto lock64;
 543         case SVR4_F_SETLK64:
 544                 cmd = F_SETLK;
 545                 goto lock64;
 546         case SVR4_F_SETLKW64:
 547                 cmd = F_SETLKW;
 548             lock64:
 549                 error = copyin(SCARG_P32(uap, arg), &ifl64, sizeof ifl64);
 550                 if (error)
 551                         return error;
 552                 svr4_32_to_bsd_flock64(&ifl64, &fl);
 553
 554                 error = do_fcntl_lock(SCARG(uap, fd), cmd, &fl);
 555                 if (cmd != F_GETLK || error != 0)
 556                         return error;
 557
 558                 bsd_to_svr4_32_flock64(&fl, &ifl64);
 559                 return copyout(&ifl64, SCARG_P32(uap, arg), sizeof ifl64);
 560
 561         case SVR4_F_FREESP64:
 562                 error = copyin(SCARG_P32(uap, arg), &ifl64, sizeof ifl64);
 563                 if (error)
 564                         return error;
 565                 svr4_32_to_bsd_flock64(&ifl64, &fl);
 566                 return fd_truncate(l, SCARG(uap, fd), &fl, retval);
 567
 568         case SVR4_F_REVOKE:
 569                 return fd_revoke(l, SCARG(uap, fd), retval);
 570
 571         default:
 572                 return ENOSYS;
 573         }
 574
 575         SCARG(&fa, cmd) = cmd;
 576
 577         error = sys_fcntl(l, &fa, retval);
 578         if (error != 0)
 579                 return error;
 580
 581         switch (SCARG(uap, cmd)) {
 582
 583         case SVR4_F_GETFL:
 584                 *retval = bsd_to_svr4_32_flags(*retval);
 585                 break;
 586         }
 587
 588         return 0;
 589 }