![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_descrip.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / kern|
Return to kern_descrip.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* Copyright (c) 1995, 1997 Apple Computer, Inc. All Rights Reserved */ ! 23: /* ! 24: * Copyright (c) 1982, 1986, 1989, 1991, 1993 ! 25: * The Regents of the University of California. All rights reserved. ! 26: * (c) UNIX System Laboratories, Inc. ! 27: * All or some portions of this file are derived from material licensed ! 28: * to the University of California by American Telephone and Telegraph ! 29: * Co. or Unix System Laboratories, Inc. and are reproduced herein with ! 30: * the permission of UNIX System Laboratories, Inc. ! 31: * ! 32: * Redistribution and use in source and binary forms, with or without ! 33: * modification, are permitted provided that the following conditions ! 34: * are met: ! 35: * 1. Redistributions of source code must retain the above copyright ! 36: * notice, this list of conditions and the following disclaimer. ! 37: * 2. Redistributions in binary form must reproduce the above copyright ! 38: * notice, this list of conditions and the following disclaimer in the ! 39: * documentation and/or other materials provided with the distribution. ! 40: * 3. All advertising materials mentioning features or use of this software ! 41: * must display the following acknowledgement: ! 42: * This product includes software developed by the University of ! 43: * California, Berkeley and its contributors. ! 44: * 4. Neither the name of the University nor the names of its contributors ! 45: * may be used to endorse or promote products derived from this software ! 46: * without specific prior written permission. ! 47: * ! 48: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 49: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 50: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 51: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 52: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 53: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 54: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 55: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 56: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 57: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 58: * SUCH DAMAGE. ! 59: * ! 60: * @(#)kern_descrip.c 8.8 (Berkeley) 2/14/95 ! 61: * ! 62: * History: ! 63: * CHW 8/5/98 Added F_SETSIZE command to truncate without ! 64: * zero filling space ! 65: * CHW 7/6/98 Updated Preallocate command to take a structure ! 66: * and return output. ! 67: * CHW 6/25/98 Fixed a bug in the lock call in fcntl ! 68: * Preallocate command ! 69: */ ! 70: ! 71: #include <sys/param.h> ! 72: #include <sys/systm.h> ! 73: #include <sys/filedesc.h> ! 74: #include <sys/kernel.h> ! 75: #include <sys/vnode.h> ! 76: #include <sys/proc.h> ! 77: #include <sys/file.h> ! 78: #include <sys/socket.h> ! 79: #include <sys/socketvar.h> ! 80: #include <sys/stat.h> ! 81: #include <sys/ioctl.h> ! 82: #include <sys/fcntl.h> ! 83: #include <sys/malloc.h> ! 84: #include <sys/syslog.h> ! 85: #include <sys/unistd.h> ! 86: #include <sys/resourcevar.h> ! 87: ! 88: #include <sys/mount.h> ! 89: ! 90: /* ! 91: * Descriptor management. ! 92: */ ! 93: struct filelist filehead; /* head of list of open files */ ! 94: int nfiles; /* actual number of open files */ ! 95: ! 96: /* ! 97: * System calls on descriptors. ! 98: */ ! 99: /* ARGSUSED */ ! 100: int ! 101: getdtablesize(p, uap, retval) ! 102: struct proc *p; ! 103: void *uap; ! 104: register_t *retval; ! 105: { ! 106: ! 107: *retval = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles); ! 108: return (0); ! 109: } ! 110: ! 111: /* ARGSUSED */ ! 112: int ! 113: ogetdtablesize(p, uap, retval) ! 114: struct proc *p; ! 115: void *uap; ! 116: register_t *retval; ! 117: { ! 118: ! 119: *retval = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, NOFILE); ! 120: return (0); ! 121: } ! 122: ! 123: static __inline__ ! 124: void _fdrelse(fdp, fd) ! 125: register struct filedesc *fdp; ! 126: register int fd; ! 127: { ! 128: if (fd < fdp->fd_freefile) ! 129: fdp->fd_freefile = fd; ! 130: #if DIAGNOSTIC ! 131: if (fd > fdp->fd_lastfile) ! 132: panic("fdrelse: fd_lastfile inconsistent"); ! 133: #endif ! 134: fdp->fd_ofiles[fd] = NULL; ! 135: fdp->fd_ofileflags[fd] = 0; ! 136: while ((fd = fdp->fd_lastfile) > 0 && ! 137: fdp->fd_ofiles[fd] == NULL && ! 138: !(fdp->fd_ofileflags[fd] & UF_RESERVED)) ! 139: fdp->fd_lastfile--; ! 140: } ! 141: ! 142: /* ! 143: * Duplicate a file descriptor. ! 144: */ ! 145: struct dup_args { ! 146: u_int fd; ! 147: }; ! 148: /* ARGSUSED */ ! 149: int ! 150: dup(p, uap, retval) ! 151: struct proc *p; ! 152: struct dup_args *uap; ! 153: register_t *retval; ! 154: { ! 155: register struct filedesc *fdp = p->p_fd; ! 156: register int old = uap->fd; ! 157: int new, error; ! 158: ! 159: if ((u_int)old >= fdp->fd_nfiles || ! 160: fdp->fd_ofiles[old] == NULL || ! 161: (fdp->fd_ofileflags[old] & UF_RESERVED)) ! 162: return (EBADF); ! 163: if (error = fdalloc(p, 0, &new)) ! 164: return (error); ! 165: return (finishdup(fdp, old, new, retval)); ! 166: } ! 167: ! 168: /* ! 169: * Duplicate a file descriptor to a particular value. ! 170: */ ! 171: struct dup2_args { ! 172: u_int from; ! 173: u_int to; ! 174: }; ! 175: /* ARGSUSED */ ! 176: int ! 177: dup2(p, uap, retval) ! 178: struct proc *p; ! 179: struct dup2_args *uap; ! 180: register_t *retval; ! 181: { ! 182: register struct filedesc *fdp = p->p_fd; ! 183: register int old = uap->from, new = uap->to; ! 184: int i, error; ! 185: ! 186: if ((u_int)old >= fdp->fd_nfiles || ! 187: fdp->fd_ofiles[old] == NULL || ! 188: (fdp->fd_ofileflags[old] & UF_RESERVED) || ! 189: (u_int)new >= p->p_rlimit[RLIMIT_NOFILE].rlim_cur || ! 190: (u_int)new >= maxfiles) ! 191: return (EBADF); ! 192: if (old == new) { ! 193: *retval = new; ! 194: return (0); ! 195: } ! 196: if ((u_int)new >= fdp->fd_nfiles) { ! 197: if (error = fdalloc(p, new, &i)) ! 198: return (error); ! 199: if (new != i) { ! 200: _fdrelse(fdp, i); ! 201: goto closeit; ! 202: } ! 203: } ! 204: else { ! 205: struct file **fpp; ! 206: char flags; ! 207: closeit: ! 208: if ((flags = fdp->fd_ofileflags[new]) & UF_RESERVED) ! 209: return (EBADF); ! 210: fdp->fd_ofileflags[new] = (flags & ~UF_MAPPED) | UF_RESERVED; ! 211: /* ! 212: * dup2() must succeed even if the close has an error. ! 213: */ ! 214: if (*(fpp = &fdp->fd_ofiles[new])) { ! 215: struct file *fp = *fpp; ! 216: ! 217: *fpp = NULL; (void) closef(fp, p); ! 218: } ! 219: } ! 220: return (finishdup(fdp, old, new, retval)); ! 221: } ! 222: ! 223: /* ! 224: * The file control system call. ! 225: */ ! 226: struct fcntl_args { ! 227: int fd; ! 228: int cmd; ! 229: int arg; ! 230: }; ! 231: /* ARGSUSED */ ! 232: int ! 233: fcntl(p, uap, retval) ! 234: struct proc *p; ! 235: register struct fcntl_args *uap; ! 236: register_t *retval; ! 237: { ! 238: int fd = uap->fd; ! 239: register struct filedesc *fdp = p->p_fd; ! 240: register struct file *fp; ! 241: register char *pop; ! 242: struct vnode *vp; ! 243: int i, tmp, error, error2, flg = F_POSIX; ! 244: struct flock fl; ! 245: fstore_t alloc_struct; /* structure for allocate command */ ! 246: u_int32_t alloc_flags = 0; ! 247: off_t offset; /* used for F_SETSIZE */ ! 248: int newmin; ! 249: struct radvisory ra_struct; ! 250: fbootstraptransfer_t fbt_struct; /* for F_READBOOTSTRAP and F_WRITEBOOTSTRAP */ ! 251: ! 252: if ((u_int)fd >= fdp->fd_nfiles || ! 253: (fp = fdp->fd_ofiles[fd]) == NULL || ! 254: (fdp->fd_ofileflags[fd] & UF_RESERVED)) ! 255: return (EBADF); ! 256: pop = &fdp->fd_ofileflags[fd]; ! 257: switch (uap->cmd) { ! 258: ! 259: case F_DUPFD: ! 260: newmin = (long)uap->arg; ! 261: if ((u_int)newmin >= p->p_rlimit[RLIMIT_NOFILE].rlim_cur || ! 262: (u_int)newmin >= maxfiles) ! 263: return (EINVAL); ! 264: if (error = fdalloc(p, newmin, &i)) ! 265: return (error); ! 266: return (finishdup(fdp, fd, i, retval)); ! 267: ! 268: case F_GETFD: ! 269: *retval = (*pop & UF_EXCLOSE)? 1 : 0; ! 270: return (0); ! 271: ! 272: case F_SETFD: ! 273: *pop = (*pop &~ UF_EXCLOSE) | ! 274: ((long)(uap->arg) & 1)? UF_EXCLOSE : 0; ! 275: return (0); ! 276: ! 277: case F_GETFL: ! 278: *retval = OFLAGS(fp->f_flag); ! 279: return (0); ! 280: ! 281: case F_SETFL: ! 282: fp->f_flag &= ~FCNTLFLAGS; ! 283: fp->f_flag |= FFLAGS((long)uap->arg) & FCNTLFLAGS; ! 284: tmp = fp->f_flag & FNONBLOCK; ! 285: error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO, (caddr_t)&tmp, p); ! 286: if (error) ! 287: return (error); ! 288: tmp = fp->f_flag & FASYNC; ! 289: error = (*fp->f_ops->fo_ioctl)(fp, FIOASYNC, (caddr_t)&tmp, p); ! 290: if (!error) ! 291: return (0); ! 292: fp->f_flag &= ~FNONBLOCK; ! 293: tmp = 0; ! 294: (void) (*fp->f_ops->fo_ioctl)(fp, FIONBIO, (caddr_t)&tmp, p); ! 295: return (error); ! 296: ! 297: case F_GETOWN: ! 298: if (fp->f_type == DTYPE_SOCKET) { ! 299: *retval = ((struct socket *)fp->f_data)->so_pgid; ! 300: return (0); ! 301: } ! 302: error = (*fp->f_ops->fo_ioctl) ! 303: (fp, (int)TIOCGPGRP, (caddr_t)retval, p); ! 304: *retval = -*retval; ! 305: return (error); ! 306: ! 307: case F_SETOWN: ! 308: if (fp->f_type == DTYPE_SOCKET) { ! 309: ((struct socket *)fp->f_data)->so_pgid = ! 310: (long)uap->arg; ! 311: return (0); ! 312: } ! 313: if ((long)uap->arg <= 0) { ! 314: uap->arg = (void *)(-(long)(uap->arg)); ! 315: } else { ! 316: struct proc *p1 = pfind((long)uap->arg); ! 317: if (p1 == 0) ! 318: return (ESRCH); ! 319: uap->arg = (void *)(long)p1->p_pgrp->pg_id; ! 320: } ! 321: return ((*fp->f_ops->fo_ioctl) ! 322: (fp, (int)TIOCSPGRP, (caddr_t)&uap->arg, p)); ! 323: ! 324: case F_SETLKW: ! 325: flg |= F_WAIT; ! 326: /* Fall into F_SETLK */ ! 327: ! 328: case F_SETLK: ! 329: if (fp->f_type != DTYPE_VNODE) ! 330: return (EBADF); ! 331: vp = (struct vnode *)fp->f_data; ! 332: /* Copy in the lock structure */ ! 333: error = copyin((caddr_t)uap->arg, (caddr_t)&fl, ! 334: sizeof (fl)); ! 335: if (error) ! 336: return (error); ! 337: if (fl.l_whence == SEEK_CUR) ! 338: fl.l_start += fp->f_offset; ! 339: switch (fl.l_type) { ! 340: ! 341: case F_RDLCK: ! 342: if ((fp->f_flag & FREAD) == 0) ! 343: return (EBADF); ! 344: p->p_flag |= P_ADVLOCK; ! 345: return (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg)); ! 346: ! 347: case F_WRLCK: ! 348: if ((fp->f_flag & FWRITE) == 0) ! 349: return (EBADF); ! 350: p->p_flag |= P_ADVLOCK; ! 351: return (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg)); ! 352: ! 353: case F_UNLCK: ! 354: return (VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &fl, ! 355: F_POSIX)); ! 356: ! 357: default: ! 358: return (EINVAL); ! 359: } ! 360: ! 361: case F_GETLK: ! 362: if (fp->f_type != DTYPE_VNODE) ! 363: return (EBADF); ! 364: vp = (struct vnode *)fp->f_data; ! 365: /* Copy in the lock structure */ ! 366: error = copyin((caddr_t)uap->arg, (caddr_t)&fl, ! 367: sizeof (fl)); ! 368: if (error) ! 369: return (error); ! 370: if (fl.l_whence == SEEK_CUR) ! 371: fl.l_start += fp->f_offset; ! 372: if (error = VOP_ADVLOCK(vp, (caddr_t)p, F_GETLK, &fl, F_POSIX)) ! 373: return (error); ! 374: return (copyout((caddr_t)&fl, (caddr_t)uap->arg, ! 375: sizeof (fl))); ! 376: ! 377: case F_PREALLOCATE: ! 378: ! 379: /* Copy in the structure */ ! 380: ! 381: error = copyin((caddr_t)uap->arg, (caddr_t)&alloc_struct, ! 382: sizeof (alloc_struct)); ! 383: ! 384: if (error) ! 385: return (error); ! 386: ! 387: /* now set the space allocated to 0 and pass it out in ! 388: case we get a parameter checking error */ ! 389: ! 390: alloc_struct.fst_bytesalloc = 0; ! 391: ! 392: error = copyout((caddr_t)&alloc_struct, (caddr_t)uap->arg, ! 393: sizeof (alloc_struct)); ! 394: ! 395: if (error) ! 396: return(error); ! 397: ! 398: /* First make sure that we have write permission */ ! 399: ! 400: if ((fp->f_flag & FWRITE) == 0) ! 401: return (EBADF); ! 402: ! 403: ! 404: /* Do some simple parameter checking */ ! 405: ! 406: ! 407: /* set up the flags */ ! 408: ! 409: alloc_flags |= PREALLOCATE; ! 410: ! 411: if (alloc_struct.fst_flags & F_ALLOCATECONTIG) { ! 412: alloc_flags |= ALLOCATECONTIG; ! 413: } ! 414: ! 415: if (alloc_struct.fst_flags & F_ALLOCATEALL) { ! 416: alloc_flags |= ALLOCATEALL; ! 417: } ! 418: ! 419: /* Do any position mode specific stuff. The only */ ! 420: /* position mode supported now is PEOFPOSMODE */ ! 421: ! 422: switch (alloc_struct.fst_posmode) { ! 423: ! 424: case F_PEOFPOSMODE: ! 425: ! 426: if ((alloc_struct.fst_offset != 0) || ! 427: (alloc_struct.fst_length < 0)) ! 428: return (EINVAL); ! 429: ! 430: alloc_flags |= ALLOCATEFROMPEOF; ! 431: break; ! 432: ! 433: default: ! 434: ! 435: return(EINVAL); ! 436: ! 437: } ! 438: ! 439: ! 440: /* Now lock the vnode and call allocate to get the space */ ! 441: ! 442: vp = (struct vnode *)fp->f_data; ! 443: ! 444: VOP_LOCK(vp,LK_EXCLUSIVE,p); ! 445: error = VOP_ALLOCATE(vp,alloc_struct.fst_length,alloc_flags, ! 446: &alloc_struct.fst_bytesalloc,fp->f_cred,p); ! 447: VOP_UNLOCK(vp,0,p); ! 448: ! 449: if (error2 = (copyout((caddr_t)&alloc_struct, (caddr_t)uap->arg, ! 450: sizeof (alloc_struct)))) { ! 451: if (error) { ! 452: return(error); ! 453: } else { ! 454: return(error2); ! 455: } ! 456: } ! 457: ! 458: return(error); ! 459: ! 460: case F_SETSIZE: ! 461: ! 462: /* Copy in the structure */ ! 463: ! 464: error = copyin((caddr_t)uap->arg, (caddr_t)&offset, ! 465: sizeof (off_t)); ! 466: ! 467: if (error) ! 468: return (error); ! 469: ! 470: ! 471: /* First make sure that we are root. Growing a file */ ! 472: /* without zero filling the data is a security hole */ ! 473: /* root would have access anyway so we'll allow it */ ! 474: ! 475: if (!is_suser()) { ! 476: return (EACCES); ! 477: } ! 478: ! 479: /* Now lock the vnode and call allocate to get the space */ ! 480: ! 481: vp = (struct vnode *)fp->f_data; ! 482: ! 483: VOP_LOCK(vp,LK_EXCLUSIVE,p); ! 484: error = VOP_TRUNCATE(vp,offset,IO_NOZEROFILL,fp->f_cred,p); ! 485: VOP_UNLOCK(vp,0,p); ! 486: ! 487: return(error); ! 488: ! 489: case F_RDAHEAD: ! 490: vp = (struct vnode *)fp->f_data; ! 491: ! 492: simple_lock(&vp->v_interlock); ! 493: if (uap->arg) ! 494: vp->v_flag &= ~VRAOFF; ! 495: else ! 496: vp->v_flag |= VRAOFF; ! 497: simple_unlock(&vp->v_interlock); ! 498: ! 499: return (0); ! 500: ! 501: case F_RDADVISE: ! 502: vp = (struct vnode *)fp->f_data; ! 503: ! 504: if (error = copyin((caddr_t)uap->arg, (caddr_t)&ra_struct, sizeof (ra_struct))) ! 505: return(error); ! 506: return (VOP_IOCTL(vp, 1, &ra_struct, 0, fp->f_cred, p)); ! 507: ! 508: case F_READBOOTSTRAP: ! 509: case F_WRITEBOOTSTRAP: ! 510: ! 511: /* Copy in the structure */ ! 512: ! 513: error = copyin((caddr_t)uap->arg, (caddr_t)&fbt_struct, ! 514: sizeof (fbt_struct)); ! 515: ! 516: if (error) ! 517: return (error); ! 518: ! 519: ! 520: if (uap->cmd == F_WRITEBOOTSTRAP) { ! 521: /* First make sure that we are root. Updating the */ ! 522: /* bootstrap on a disk could be a security hole */ ! 523: ! 524: if (!is_suser()) { ! 525: return (EACCES); ! 526: } ! 527: }; ! 528: ! 529: /* Now lock the vnode and call VOP_IOCTL to handle the I/O: */ ! 530: ! 531: vp = (struct vnode *)fp->f_data; ! 532: if (vp->v_tag != VT_HFS) { ! 533: error = EINVAL; ! 534: } else { ! 535: VOP_LOCK(vp,LK_EXCLUSIVE,p); ! 536: error = VOP_IOCTL(vp, (uap->cmd == F_WRITEBOOTSTRAP) ? 3 : 2, &fbt_struct, 0, fp->f_cred, p); ! 537: VOP_UNLOCK(vp,0,p); ! 538: }; ! 539: ! 540: return(error); ! 541: ! 542: ! 543: default: ! 544: return (EINVAL); ! 545: } ! 546: /* NOTREACHED */ ! 547: } ! 548: ! 549: /* ! 550: * Common code for dup, dup2, and fcntl(F_DUPFD). ! 551: */ ! 552: int ! 553: finishdup(fdp, old, new, retval) ! 554: register struct filedesc *fdp; ! 555: register int old, new; ! 556: register_t *retval; ! 557: { ! 558: register struct file *fp; ! 559: ! 560: if ((fp = fdp->fd_ofiles[old]) == NULL || ! 561: (fdp->fd_ofileflags[old] & UF_RESERVED)) { ! 562: _fdrelse(fdp, new); ! 563: return (EBADF); ! 564: } ! 565: fdp->fd_ofiles[new] = fp; ! 566: fdp->fd_ofileflags[new] = fdp->fd_ofileflags[old] &~ UF_EXCLOSE; ! 567: if (++fp->f_count <= 0) ! 568: panic("finishdup f_count"); ! 569: if (new > fdp->fd_lastfile) ! 570: fdp->fd_lastfile = new; ! 571: *retval = new; ! 572: return (0); ! 573: } ! 574: ! 575: /* ! 576: * Close a file descriptor. ! 577: */ ! 578: struct close_args { ! 579: int fd; ! 580: }; ! 581: /* ARGSUSED */ ! 582: int ! 583: close(p, uap, retval) ! 584: struct proc *p; ! 585: struct close_args *uap; ! 586: register_t *retval; ! 587: { ! 588: int fd = uap->fd; ! 589: register struct filedesc *fdp = p->p_fd; ! 590: register struct file *fp; ! 591: ! 592: if ((u_int)fd >= fdp->fd_nfiles || ! 593: (fp = fdp->fd_ofiles[fd]) == NULL || ! 594: (fdp->fd_ofileflags[fd] & UF_RESERVED)) ! 595: return (EBADF); ! 596: _fdrelse(fdp, fd); ! 597: return (closef(fp, p)); ! 598: } ! 599: ! 600: /* ! 601: * Return status information about a file descriptor. ! 602: */ ! 603: struct fstat_args { ! 604: int fd; ! 605: struct stat *sb; ! 606: }; ! 607: /* ARGSUSED */ ! 608: int ! 609: fstat(p, uap, retval) ! 610: struct proc *p; ! 611: register struct fstat_args *uap; ! 612: register_t *retval; ! 613: { ! 614: int fd = uap->fd; ! 615: register struct filedesc *fdp = p->p_fd; ! 616: register struct file *fp; ! 617: struct stat ub; ! 618: int error; ! 619: ! 620: if ((u_int)fd >= fdp->fd_nfiles || ! 621: (fp = fdp->fd_ofiles[fd]) == NULL || ! 622: (fdp->fd_ofileflags[fd] & UF_RESERVED)) ! 623: return (EBADF); ! 624: switch (fp->f_type) { ! 625: ! 626: case DTYPE_VNODE: ! 627: error = vn_stat((struct vnode *)fp->f_data, &ub, p); ! 628: break; ! 629: ! 630: case DTYPE_SOCKET: ! 631: error = soo_stat((struct socket *)fp->f_data, &ub); ! 632: break; ! 633: ! 634: case DTYPE_PSXSHM: ! 635: error = pshm_stat((void *)fp->f_data, &ub); ! 636: break; ! 637: default: ! 638: panic("fstat"); ! 639: /*NOTREACHED*/ ! 640: } ! 641: if (error == 0) ! 642: error = copyout((caddr_t)&ub, (caddr_t)uap->sb, ! 643: sizeof (ub)); ! 644: return (error); ! 645: } ! 646: ! 647: #if COMPAT_43 ! 648: /* ! 649: * Return status information about a file descriptor. ! 650: */ ! 651: struct ofstat_args { ! 652: int fd; ! 653: struct ostat *sb; ! 654: }; ! 655: /* ARGSUSED */ ! 656: ofstat(p, uap, retval) ! 657: struct proc *p; ! 658: register struct ofstat_args *uap; ! 659: register_t *retval; ! 660: { ! 661: int fd = uap->fd; ! 662: register struct filedesc *fdp = p->p_fd; ! 663: register struct file *fp; ! 664: struct stat ub; ! 665: struct ostat oub; ! 666: int error; ! 667: ! 668: if ((u_int)fd >= fdp->fd_nfiles || ! 669: (fp = fdp->fd_ofiles[fd]) == NULL || ! 670: (fdp->fd_ofileflags[fd] & UF_RESERVED)) ! 671: return (EBADF); ! 672: switch (fp->f_type) { ! 673: ! 674: case DTYPE_VNODE: ! 675: error = vn_stat((struct vnode *)fp->f_data, &ub, p); ! 676: break; ! 677: ! 678: case DTYPE_SOCKET: ! 679: error = soo_stat((struct socket *)fp->f_data, &ub); ! 680: break; ! 681: ! 682: default: ! 683: panic("ofstat"); ! 684: /*NOTREACHED*/ ! 685: } ! 686: cvtstat(&ub, &oub); ! 687: if (error == 0) ! 688: error = copyout((caddr_t)&oub, (caddr_t)uap->sb, ! 689: sizeof (oub)); ! 690: return (error); ! 691: } ! 692: #endif /* COMPAT_43 */ ! 693: ! 694: /* ! 695: * Return pathconf information about a file descriptor. ! 696: */ ! 697: struct fpathconf_args { ! 698: int fd; ! 699: int name; ! 700: }; ! 701: /* ARGSUSED */ ! 702: fpathconf(p, uap, retval) ! 703: struct proc *p; ! 704: register struct fpathconf_args *uap; ! 705: register_t *retval; ! 706: { ! 707: int fd = uap->fd; ! 708: struct filedesc *fdp = p->p_fd; ! 709: struct file *fp; ! 710: struct vnode *vp; ! 711: ! 712: if ((u_int)fd >= fdp->fd_nfiles || ! 713: (fp = fdp->fd_ofiles[fd]) == NULL || ! 714: (fdp->fd_ofileflags[fd] & UF_RESERVED)) ! 715: return (EBADF); ! 716: switch (fp->f_type) { ! 717: ! 718: case DTYPE_SOCKET: ! 719: if (uap->name != _PC_PIPE_BUF) ! 720: return (EINVAL); ! 721: *retval = PIPE_BUF; ! 722: return (0); ! 723: ! 724: case DTYPE_VNODE: ! 725: vp = (struct vnode *)fp->f_data; ! 726: return (VOP_PATHCONF(vp, uap->name, retval)); ! 727: ! 728: default: ! 729: panic("fpathconf"); ! 730: } ! 731: /*NOTREACHED*/ ! 732: } ! 733: ! 734: /* ! 735: * Allocate a file descriptor for the process. ! 736: */ ! 737: int fdexpand; ! 738: ! 739: int ! 740: fdalloc(p, want, result) ! 741: struct proc *p; ! 742: int want; ! 743: int *result; ! 744: { ! 745: register struct filedesc *fdp = p->p_fd; ! 746: register int i; ! 747: int lim, last, nfiles, oldnfiles; ! 748: struct file **newofiles, **ofiles; ! 749: char *newofileflags, *ofileflags; ! 750: ! 751: /* ! 752: * Search for a free descriptor starting at the higher ! 753: * of want or fd_freefile. If that fails, consider ! 754: * expanding the ofile array. ! 755: */ ! 756: lim = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles); ! 757: for (;;) { ! 758: last = min(fdp->fd_nfiles, lim); ! 759: if ((i = want) < fdp->fd_freefile) ! 760: i = fdp->fd_freefile; ! 761: ofiles = &fdp->fd_ofiles[i]; ! 762: ofileflags = &fdp->fd_ofileflags[i]; ! 763: for (; i < last; i++) { ! 764: if (*ofiles == NULL && !(*ofileflags & UF_RESERVED)) { ! 765: *ofileflags = UF_RESERVED; ! 766: if (i > fdp->fd_lastfile) ! 767: fdp->fd_lastfile = i; ! 768: if (want <= fdp->fd_freefile) ! 769: fdp->fd_freefile = i; ! 770: *result = i; ! 771: return (0); ! 772: } ! 773: ofiles++; ofileflags++; ! 774: } ! 775: ! 776: /* ! 777: * No space in current array. Expand? ! 778: */ ! 779: if (fdp->fd_nfiles >= lim) ! 780: return (EMFILE); ! 781: if (fdp->fd_nfiles < NDEXTENT) ! 782: nfiles = NDEXTENT; ! 783: else ! 784: nfiles = 2 * fdp->fd_nfiles; ! 785: /* Enforce lim */ ! 786: if (nfiles > lim) ! 787: nfiles = lim; ! 788: MALLOC_ZONE(newofiles, struct file **, ! 789: nfiles * OFILESIZE, M_OFILETABL, M_WAITOK); ! 790: if (fdp->fd_nfiles >= nfiles) { ! 791: FREE_ZONE(newofiles, nfiles * OFILESIZE, M_OFILETABL); ! 792: continue; ! 793: } ! 794: newofileflags = (char *) &newofiles[nfiles]; ! 795: /* ! 796: * Copy the existing ofile and ofileflags arrays ! 797: * and zero the new portion of each array. ! 798: */ ! 799: oldnfiles = fdp->fd_nfiles; ! 800: (void) memcpy(newofiles, fdp->fd_ofiles, ! 801: oldnfiles * sizeof *fdp->fd_ofiles); ! 802: (void) memset(&newofiles[oldnfiles], 0, ! 803: (nfiles - oldnfiles) * sizeof *fdp->fd_ofiles); ! 804: ! 805: (void) memcpy(newofileflags, fdp->fd_ofileflags, ! 806: oldnfiles * sizeof *fdp->fd_ofileflags); ! 807: (void) memset(&newofileflags[oldnfiles], 0, ! 808: (nfiles - oldnfiles) * ! 809: sizeof *fdp->fd_ofileflags); ! 810: ofiles = fdp->fd_ofiles; ! 811: fdp->fd_ofiles = newofiles; ! 812: fdp->fd_ofileflags = newofileflags; ! 813: fdp->fd_nfiles = nfiles; ! 814: FREE_ZONE(ofiles, oldnfiles * OFILESIZE, M_OFILETABL); ! 815: fdexpand++; ! 816: } ! 817: } ! 818: ! 819: /* ! 820: * Check to see whether n user file descriptors ! 821: * are available to the process p. ! 822: */ ! 823: int ! 824: fdavail(p, n) ! 825: struct proc *p; ! 826: register int n; ! 827: { ! 828: register struct filedesc *fdp = p->p_fd; ! 829: register struct file **fpp; ! 830: register char *flags; ! 831: register int i, lim; ! 832: ! 833: lim = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles); ! 834: if ((i = lim - fdp->fd_nfiles) > 0 && (n -= i) <= 0) ! 835: return (1); ! 836: fpp = &fdp->fd_ofiles[fdp->fd_freefile]; ! 837: flags = &fdp->fd_ofileflags[fdp->fd_freefile]; ! 838: for (i = fdp->fd_nfiles - fdp->fd_freefile; --i >= 0; fpp++, flags++) ! 839: if (*fpp == NULL && !(*flags & UF_RESERVED) && --n <= 0) ! 840: return (1); ! 841: return (0); ! 842: } ! 843: ! 844: void ! 845: fdrelse(p, fd) ! 846: struct proc *p; ! 847: int fd; ! 848: { ! 849: _fdrelse(p->p_fd, fd); ! 850: } ! 851: ! 852: int ! 853: fdgetf(p, fd, resultfp) ! 854: register struct proc *p; ! 855: register int fd; ! 856: struct file **resultfp; ! 857: { ! 858: register struct filedesc *fdp = p->p_fd; ! 859: struct file *fp; ! 860: ! 861: if ((u_int)fd >= fdp->fd_nfiles || ! 862: (fp = fdp->fd_ofiles[fd]) == NULL || ! 863: (fdp->fd_ofileflags[fd] & UF_RESERVED)) ! 864: return (EBADF); ! 865: ! 866: if (resultfp) ! 867: *resultfp = fp; ! 868: return (0); ! 869: } ! 870: ! 871: /* ! 872: * Create a new open file structure and allocate ! 873: * a file decriptor for the process that refers to it. ! 874: */ ! 875: int ! 876: falloc(p, resultfp, resultfd) ! 877: register struct proc *p; ! 878: struct file **resultfp; ! 879: int *resultfd; ! 880: { ! 881: register struct file *fp, *fq; ! 882: int error, i; ! 883: ! 884: if (error = fdalloc(p, 0, &i)) ! 885: return (error); ! 886: if (nfiles >= maxfiles) { ! 887: tablefull("file"); ! 888: return (ENFILE); ! 889: } ! 890: /* ! 891: * Allocate a new file descriptor. ! 892: * If the process has file descriptor zero open, add to the list ! 893: * of open files at that point, otherwise put it at the front of ! 894: * the list of open files. ! 895: */ ! 896: nfiles++; ! 897: MALLOC_ZONE(fp, struct file *, sizeof(struct file), M_FILE, M_WAITOK); ! 898: bzero(fp, sizeof(struct file)); ! 899: if (fq = p->p_fd->fd_ofiles[0]) { ! 900: LIST_INSERT_AFTER(fq, fp, f_list); ! 901: } else { ! 902: LIST_INSERT_HEAD(&filehead, fp, f_list); ! 903: } ! 904: p->p_fd->fd_ofiles[i] = fp; ! 905: fp->f_count = 1; ! 906: fp->f_cred = p->p_ucred; ! 907: crhold(fp->f_cred); ! 908: if (resultfp) ! 909: *resultfp = fp; ! 910: if (resultfd) ! 911: *resultfd = i; ! 912: return (0); ! 913: } ! 914: ! 915: /* ! 916: * Free a file structure. ! 917: */ ! 918: void ! 919: ffree(fp) ! 920: register struct file *fp; ! 921: { ! 922: register struct file *fq; ! 923: struct ucred *cred; ! 924: ! 925: LIST_REMOVE(fp, f_list); ! 926: cred = fp->f_cred; ! 927: if (cred != NOCRED) { ! 928: fp->f_cred = NOCRED; ! 929: crfree(cred); ! 930: } ! 931: #if DIAGNOSTIC ! 932: fp->f_count = 0; ! 933: #endif ! 934: nfiles--; ! 935: FREE_ZONE(fp, sizeof *fp, M_FILE); ! 936: } ! 937: ! 938: void ! 939: fdexec(p) ! 940: struct proc *p; ! 941: { ! 942: register struct filedesc *fdp = p->p_fd; ! 943: register int i = fdp->fd_lastfile; ! 944: register struct file **fpp = &fdp->fd_ofiles[i]; ! 945: register char *flags = &fdp->fd_ofileflags[i]; ! 946: ! 947: while (i >= 0) { ! 948: if ((*flags & (UF_RESERVED|UF_EXCLOSE)) == UF_EXCLOSE) { ! 949: register struct file *fp = *fpp; ! 950: ! 951: *fpp = NULL; *flags = 0; ! 952: if (i == fdp->fd_lastfile && i > 0) ! 953: fdp->fd_lastfile--; ! 954: closef(fp, p); ! 955: } ! 956: else ! 957: *flags &= ~UF_MAPPED; ! 958: ! 959: i--; fpp--; flags--; ! 960: } ! 961: } ! 962: ! 963: /* ! 964: * Copy a filedesc structure. ! 965: */ ! 966: struct filedesc * ! 967: fdcopy(p) ! 968: struct proc *p; ! 969: { ! 970: register struct filedesc *newfdp, *fdp = p->p_fd; ! 971: register int i; ! 972: ! 973: MALLOC_ZONE(newfdp, struct filedesc *, ! 974: sizeof *newfdp, M_FILEDESC, M_WAITOK); ! 975: (void) memcpy(newfdp, fdp, sizeof *newfdp); ! 976: VREF(newfdp->fd_cdir); ! 977: if (newfdp->fd_rdir) ! 978: VREF(newfdp->fd_rdir); ! 979: newfdp->fd_refcnt = 1; ! 980: ! 981: /* ! 982: * If the number of open files fits in the internal arrays ! 983: * of the open file structure, use them, otherwise allocate ! 984: * additional memory for the number of descriptors currently ! 985: * in use. ! 986: */ ! 987: if (newfdp->fd_lastfile < NDFILE) ! 988: i = NDFILE; ! 989: else { ! 990: /* ! 991: * Compute the smallest multiple of NDEXTENT needed ! 992: * for the file descriptors currently in use, ! 993: * allowing the table to shrink. ! 994: */ ! 995: i = newfdp->fd_nfiles; ! 996: while (i > 2 * NDEXTENT && i > newfdp->fd_lastfile * 2) ! 997: i /= 2; ! 998: } ! 999: MALLOC_ZONE(newfdp->fd_ofiles, struct file **, ! 1000: i * OFILESIZE, M_OFILETABL, M_WAITOK); ! 1001: newfdp->fd_ofileflags = (char *) &newfdp->fd_ofiles[i]; ! 1002: newfdp->fd_nfiles = i; ! 1003: if (fdp->fd_nfiles > 0) { ! 1004: register struct file **fpp; ! 1005: register char *flags; ! 1006: ! 1007: (void) memcpy(newfdp->fd_ofiles, fdp->fd_ofiles, ! 1008: i * sizeof *fdp->fd_ofiles); ! 1009: (void) memcpy(newfdp->fd_ofileflags, fdp->fd_ofileflags, ! 1010: i * sizeof *fdp->fd_ofileflags); ! 1011: ! 1012: fpp = newfdp->fd_ofiles; ! 1013: flags = newfdp->fd_ofileflags; ! 1014: for (i = newfdp->fd_lastfile; i-- >= 0; fpp++, flags++) ! 1015: if (*fpp != NULL && !(*flags & UF_RESERVED)) { ! 1016: if (++(*fpp)->f_count <= 0) ! 1017: panic("fdcopy f_count"); ! 1018: } else { ! 1019: *fpp = NULL; *flags = 0; ! 1020: } ! 1021: } ! 1022: else ! 1023: (void) memset(newfdp->fd_ofiles, 0, i * OFILESIZE); ! 1024: ! 1025: return (newfdp); ! 1026: } ! 1027: ! 1028: /* ! 1029: * Release a filedesc structure. ! 1030: */ ! 1031: void ! 1032: fdfree(p) ! 1033: struct proc *p; ! 1034: { ! 1035: register struct filedesc *fdp; ! 1036: register struct file **fpp; ! 1037: register int i; ! 1038: ! 1039: if ((fdp = p->p_fd) == NULL) ! 1040: return; ! 1041: if (--fdp->fd_refcnt > 0) ! 1042: return; ! 1043: p->p_fd = NULL; ! 1044: if (fdp->fd_nfiles > 0) { ! 1045: fpp = fdp->fd_ofiles; ! 1046: for (i = fdp->fd_lastfile; i-- >= 0; fpp++) ! 1047: if (*fpp) ! 1048: (void) closef(*fpp, p); ! 1049: FREE_ZONE(fdp->fd_ofiles, ! 1050: fdp->fd_nfiles * OFILESIZE, M_OFILETABL); ! 1051: } ! 1052: vrele(fdp->fd_cdir); ! 1053: if (fdp->fd_rdir) ! 1054: vrele(fdp->fd_rdir); ! 1055: FREE_ZONE(fdp, sizeof *fdp, M_FILEDESC); ! 1056: } ! 1057: ! 1058: /* ! 1059: * Internal form of close. ! 1060: * Decrement reference count on file structure. ! 1061: * Note: p may be NULL when closing a file ! 1062: * that was being passed in a message. ! 1063: */ ! 1064: int ! 1065: closef(fp, p) ! 1066: register struct file *fp; ! 1067: register struct proc *p; ! 1068: { ! 1069: struct vnode *vp; ! 1070: struct flock lf; ! 1071: int error; ! 1072: ! 1073: if (fp == NULL) ! 1074: return (0); ! 1075: /* ! 1076: * POSIX record locking dictates that any close releases ALL ! 1077: * locks owned by this process. This is handled by setting ! 1078: * a flag in the unlock to free ONLY locks obeying POSIX ! 1079: * semantics, and not to free BSD-style file locks. ! 1080: * If the descriptor was in a message, POSIX-style locks ! 1081: * aren't passed with the descriptor. ! 1082: */ ! 1083: if (p && (p->p_flag & P_ADVLOCK) && fp->f_type == DTYPE_VNODE) { ! 1084: lf.l_whence = SEEK_SET; ! 1085: lf.l_start = 0; ! 1086: lf.l_len = 0; ! 1087: lf.l_type = F_UNLCK; ! 1088: vp = (struct vnode *)fp->f_data; ! 1089: (void) VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &lf, F_POSIX); ! 1090: } ! 1091: if (--fp->f_count > 0) ! 1092: return (0); ! 1093: if (fp->f_count < 0) ! 1094: panic("closef: count < 0"); ! 1095: if ((fp->f_flag & FHASLOCK) && fp->f_type == DTYPE_VNODE) { ! 1096: lf.l_whence = SEEK_SET; ! 1097: lf.l_start = 0; ! 1098: lf.l_len = 0; ! 1099: lf.l_type = F_UNLCK; ! 1100: vp = (struct vnode *)fp->f_data; ! 1101: (void) VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK); ! 1102: } ! 1103: if (fp->f_ops) ! 1104: error = (*fp->f_ops->fo_close)(fp, p); ! 1105: else ! 1106: error = 0; ! 1107: ffree(fp); ! 1108: return (error); ! 1109: } ! 1110: ! 1111: /* ! 1112: * Apply an advisory lock on a file descriptor. ! 1113: * ! 1114: * Just attempt to get a record lock of the requested type on ! 1115: * the entire file (l_whence = SEEK_SET, l_start = 0, l_len = 0). ! 1116: */ ! 1117: struct flock_args { ! 1118: int fd; ! 1119: int how; ! 1120: }; ! 1121: /* ARGSUSED */ ! 1122: int ! 1123: flock(p, uap, retval) ! 1124: struct proc *p; ! 1125: register struct flock_args *uap; ! 1126: register_t *retval; ! 1127: { ! 1128: int fd = uap->fd; ! 1129: int how = uap->how; ! 1130: register struct filedesc *fdp = p->p_fd; ! 1131: register struct file *fp; ! 1132: struct vnode *vp; ! 1133: struct flock lf; ! 1134: ! 1135: if ((u_int)fd >= fdp->fd_nfiles || ! 1136: (fp = fdp->fd_ofiles[fd]) == NULL || ! 1137: (fdp->fd_ofileflags[fd] & UF_RESERVED)) ! 1138: return (EBADF); ! 1139: if (fp->f_type != DTYPE_VNODE) ! 1140: return (EOPNOTSUPP); ! 1141: vp = (struct vnode *)fp->f_data; ! 1142: lf.l_whence = SEEK_SET; ! 1143: lf.l_start = 0; ! 1144: lf.l_len = 0; ! 1145: if (how & LOCK_UN) { ! 1146: lf.l_type = F_UNLCK; ! 1147: fp->f_flag &= ~FHASLOCK; ! 1148: return (VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK)); ! 1149: } ! 1150: if (how & LOCK_EX) ! 1151: lf.l_type = F_WRLCK; ! 1152: else if (how & LOCK_SH) ! 1153: lf.l_type = F_RDLCK; ! 1154: else ! 1155: return (EBADF); ! 1156: fp->f_flag |= FHASLOCK; ! 1157: if (how & LOCK_NB) ! 1158: return (VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, F_FLOCK)); ! 1159: return (VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, F_FLOCK|F_WAIT)); ! 1160: } ! 1161: ! 1162: /* ! 1163: * File Descriptor pseudo-device driver (/dev/fd/). ! 1164: * ! 1165: * Opening minor device N dup()s the file (if any) connected to file ! 1166: * descriptor N belonging to the calling process. Note that this driver ! 1167: * consists of only the ``open()'' routine, because all subsequent ! 1168: * references to this file will be direct to the other driver. ! 1169: */ ! 1170: /* ARGSUSED */ ! 1171: int ! 1172: fdopen(dev, mode, type, p) ! 1173: dev_t dev; ! 1174: int mode, type; ! 1175: struct proc *p; ! 1176: { ! 1177: ! 1178: /* ! 1179: * XXX Kludge: set curproc->p_dupfd to contain the value of the ! 1180: * the file descriptor being sought for duplication. The error ! 1181: * return ensures that the vnode for this device will be released ! 1182: * by vn_open. Open will detect this special error and take the ! 1183: * actions in dupfdopen below. Other callers of vn_open or VOP_OPEN ! 1184: * will simply report the error. ! 1185: */ ! 1186: p->p_dupfd = minor(dev); ! 1187: return (ENODEV); ! 1188: } ! 1189: ! 1190: /* ! 1191: * Duplicate the specified descriptor to a free descriptor. ! 1192: */ ! 1193: int ! 1194: dupfdopen(fdp, indx, dfd, mode, error) ! 1195: register struct filedesc *fdp; ! 1196: register int indx, dfd; ! 1197: int mode; ! 1198: int error; ! 1199: { ! 1200: register struct file *wfp; ! 1201: struct file *fp; ! 1202: ! 1203: /* ! 1204: * If the to-be-dup'd fd number is greater than the allowed number ! 1205: * of file descriptors, or the fd to be dup'd has already been ! 1206: * closed, reject. Note, check for new == old is necessary as ! 1207: * falloc could allocate an already closed to-be-dup'd descriptor ! 1208: * as the new descriptor. ! 1209: */ ! 1210: fp = fdp->fd_ofiles[indx]; ! 1211: if ((u_int)dfd >= fdp->fd_nfiles || ! 1212: (wfp = fdp->fd_ofiles[dfd]) == NULL || wfp == fp || ! 1213: (fdp->fd_ofileflags[dfd] & UF_RESERVED)) ! 1214: return (EBADF); ! 1215: ! 1216: /* ! 1217: * There are two cases of interest here. ! 1218: * ! 1219: * For ENODEV simply dup (dfd) to file descriptor ! 1220: * (indx) and return. ! 1221: * ! 1222: * For ENXIO steal away the file structure from (dfd) and ! 1223: * store it in (indx). (dfd) is effectively closed by ! 1224: * this operation. ! 1225: * ! 1226: * Any other error code is just returned. ! 1227: */ ! 1228: switch (error) { ! 1229: case ENODEV: ! 1230: /* ! 1231: * Check that the mode the file is being opened for is a ! 1232: * subset of the mode of the existing descriptor. ! 1233: */ ! 1234: if (((mode & (FREAD|FWRITE)) | wfp->f_flag) != wfp->f_flag) ! 1235: return (EACCES); ! 1236: if (++wfp->f_count <= 0) ! 1237: panic("dupfdopen f_count"); ! 1238: if (indx > fdp->fd_lastfile) ! 1239: fdp->fd_lastfile = indx;; ! 1240: fdp->fd_ofiles[indx] = wfp; ! 1241: fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd]; ! 1242: return (0); ! 1243: ! 1244: case ENXIO: ! 1245: /* ! 1246: * Steal away the file pointer from dfd, and stuff it into indx. ! 1247: */ ! 1248: if (indx > fdp->fd_lastfile) ! 1249: fdp->fd_lastfile = indx;; ! 1250: fdp->fd_ofiles[indx] = fdp->fd_ofiles[dfd]; ! 1251: fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd]; ! 1252: _fdrelse(fdp, dfd); ! 1253: return (0); ! 1254: ! 1255: default: ! 1256: return (error); ! 1257: } ! 1258: /* NOTREACHED */ ! 1259: } ! 1260:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.