convert VOP_UNLOCK and vrele into vput's; add proc parameter to union_dircache

[unix-history] / usr / src / sys / kern / kern_subr.c

/*
* Copyright (c) 1982, 1986, 1991, 1993
*      The Regents of the University of California.  All rights reserved.
* (c) UNIX System Laboratories, Inc.
* All or some portions of this file are derived from material licensed
* to the University of California by American Telephone and Telegraph
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
* the permission of UNIX System Laboratories, Inc.
*
* %sccs.include.redist.c%
*
*      @(#)kern_subr.c 8.4 (Berkeley) %G%
*/

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/malloc.h>
#include <sys/queue.h>

int
uiomove(cp, n, uio)
       register caddr_t cp;
       register int n;
       register struct uio *uio;
{
       register struct iovec *iov;
       u_int cnt;
       int error = 0;

#ifdef DIAGNOSTIC
       if (uio->uio_rw != UIO_READ && uio->uio_rw != UIO_WRITE)
               panic("uiomove: mode");
       if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc)
               panic("uiomove proc");
#endif
       while (n > 0 && uio->uio_resid) {
               iov = uio->uio_iov;
               cnt = iov->iov_len;
               if (cnt == 0) {
                       uio->uio_iov++;
                       uio->uio_iovcnt--;
                       continue;
               }
               if (cnt > n)
                       cnt = n;
               switch (uio->uio_segflg) {

               case UIO_USERSPACE:
               case UIO_USERISPACE:
                       if (uio->uio_rw == UIO_READ)
                               error = copyout(cp, iov->iov_base, cnt);
                       else
                               error = copyin(iov->iov_base, cp, cnt);
                       if (error)
                               return (error);
                       break;

               case UIO_SYSSPACE:
                       if (uio->uio_rw == UIO_READ)
                               bcopy((caddr_t)cp, iov->iov_base, cnt);
                       else
                               bcopy(iov->iov_base, (caddr_t)cp, cnt);
                       break;
               }
               iov->iov_base += cnt;
               iov->iov_len -= cnt;
               uio->uio_resid -= cnt;
               uio->uio_offset += cnt;
               cp += cnt;
               n -= cnt;
       }
       return (error);
}

/*
* Give next character to user as result of read.
*/
int
ureadc(c, uio)
       register int c;
       register struct uio *uio;
{
       register struct iovec *iov;

       if (uio->uio_resid <= 0)
               panic("ureadc: non-positive resid");
again:
       if (uio->uio_iovcnt <= 0)
               panic("ureadc: non-positive iovcnt");
       iov = uio->uio_iov;
       if (iov->iov_len <= 0) {
               uio->uio_iovcnt--;
               uio->uio_iov++;
               goto again;
       }
       switch (uio->uio_segflg) {

       case UIO_USERSPACE:
               if (subyte(iov->iov_base, c) < 0)
                       return (EFAULT);
               break;

       case UIO_SYSSPACE:
               *iov->iov_base = c;
               break;

       case UIO_USERISPACE:
               if (suibyte(iov->iov_base, c) < 0)
                       return (EFAULT);
               break;
       }
       iov->iov_base++;
       iov->iov_len--;
       uio->uio_resid--;
       uio->uio_offset++;
       return (0);
}

#ifdef vax      /* unused except by ct.c, other oddities XXX */
/*
* Get next character written in by user from uio.
*/
int
uwritec(uio)
       struct uio *uio;
{
       register struct iovec *iov;
       register int c;

       if (uio->uio_resid <= 0)
               return (-1);
again:
       if (uio->uio_iovcnt <= 0)
               panic("uwritec: non-positive iovcnt");
       iov = uio->uio_iov;
       if (iov->iov_len == 0) {
               uio->uio_iov++;
               if (--uio->uio_iovcnt == 0)
                       return (-1);
               goto again;
       }
       switch (uio->uio_segflg) {

       case UIO_USERSPACE:
               c = fubyte(iov->iov_base);
               break;

       case UIO_SYSSPACE:
               c = *(u_char *) iov->iov_base;
               break;

       case UIO_USERISPACE:
               c = fuibyte(iov->iov_base);
               break;
       }
       if (c < 0)
               return (-1);
       iov->iov_base++;
       iov->iov_len--;
       uio->uio_resid--;
       uio->uio_offset++;
       return (c);
}
#endif /* vax */

/*
* General routine to allocate a hash table.
*/
void *
hashinit(elements, type, hashmask)
       int elements, type;
       u_long *hashmask;
{
       long hashsize;
       LIST_HEAD(generic, generic) *hashtbl;
       int i;

       if (elements <= 0)
               panic("hashinit: bad cnt");
       for (hashsize = 1; hashsize <= elements; hashsize <<= 1)
               continue;
       hashsize >>= 1;
       hashtbl = malloc((u_long)hashsize * sizeof(*hashtbl), type, M_WAITOK);
       for (i = 0; i < hashsize; i++)
               LIST_INIT(&hashtbl[i]);
       *hashmask = hashsize - 1;
       return (hashtbl);
}