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

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

diff --git a/usr/src/sys/kern/kern_subr.c b/usr/src/sys/kern/kern_subr.c
index 777084a..531d00c 100644 (file)
--- a/usr/src/sys/kern/kern_subr.c
+++ b/usr/src/sys/kern/kern_subr.c
@@ -1,27 +1,39 @@
 /*
 /*

- * Copyright (c) 1982, 1986 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+ * 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.

  *
  *

- *     @(#)kern_subr.c 7.1 (Berkeley) %G%
+ * %sccs.include.redist.c%
+ *
+ *     @(#)kern_subr.c 8.4 (Berkeley) %G%

  */
 
  */
 

-#include "param.h"
-#include "systm.h"
-#include "dir.h"
-#include "user.h"
-#include "uio.h"
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/proc.h>
+#include <sys/malloc.h>
+#include <sys/queue.h>

 
 

-uiomove(cp, n, rw, uio)
+int
+uiomove(cp, n, uio)

        register caddr_t cp;
        register int n;
        register caddr_t cp;
        register int n;

-       enum uio_rw rw;

        register struct uio *uio;
 {
        register struct iovec *iov;
        u_int cnt;
        int error = 0;
 
        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;
        while (n > 0 && uio->uio_resid) {
                iov = uio->uio_iov;
                cnt = iov->iov_len;


@@ -36,7 +48,7 @@ uiomove(cp, n, rw, uio)
 
                case UIO_USERSPACE:
                case UIO_USERISPACE:
 
                case UIO_USERSPACE:
                case UIO_USERISPACE:

-                       if (rw == UIO_READ)
+                       if (uio->uio_rw == UIO_READ)

                                error = copyout(cp, iov->iov_base, cnt);
                        else
                                error = copyin(iov->iov_base, cp, cnt);
                                error = copyout(cp, iov->iov_base, cnt);
                        else
                                error = copyin(iov->iov_base, cp, cnt);


@@ -45,7 +57,7 @@ uiomove(cp, n, rw, uio)
                        break;
 
                case UIO_SYSSPACE:
                        break;
 
                case UIO_SYSSPACE:

-                       if (rw == UIO_READ)
+                       if (uio->uio_rw == UIO_READ)

                                bcopy((caddr_t)cp, iov->iov_base, cnt);
                        else
                                bcopy(iov->iov_base, (caddr_t)cp, cnt);
                                bcopy((caddr_t)cp, iov->iov_base, cnt);
                        else
                                bcopy(iov->iov_base, (caddr_t)cp, cnt);


@@ -64,17 +76,20 @@ uiomove(cp, n, rw, uio)
 /*
  * Give next character to user as result of read.
  */
 /*
  * Give next character to user as result of read.
  */

+int

 ureadc(c, uio)
        register int c;
        register struct uio *uio;
 {
        register struct iovec *iov;
 
 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:
 again:

-       if (uio->uio_iovcnt == 0)
-               panic("ureadc");
+       if (uio->uio_iovcnt <= 0)
+               panic("ureadc: non-positive iovcnt");

        iov = uio->uio_iov;
        iov = uio->uio_iov;

-       if (iov->iov_len <= 0 || uio->uio_resid <= 0) {
+       if (iov->iov_len <= 0) {

                uio->uio_iovcnt--;
                uio->uio_iov++;
                goto again;
                uio->uio_iovcnt--;
                uio->uio_iov++;
                goto again;


@@ -102,9 +117,11 @@ again:
        return (0);
 }
 
        return (0);
 }
 

+#ifdef vax     /* unused except by ct.c, other oddities XXX */

 /*
  * Get next character written in by user from uio.
  */
 /*
  * Get next character written in by user from uio.
  */

+int

 uwritec(uio)
        struct uio *uio;
 {
 uwritec(uio)
        struct uio *uio;
 {


@@ -115,7 +132,7 @@ uwritec(uio)
                return (-1);
 again:
        if (uio->uio_iovcnt <= 0)
                return (-1);
 again:
        if (uio->uio_iovcnt <= 0)

-               panic("uwritec");
+               panic("uwritec: non-positive iovcnt");

        iov = uio->uio_iov;
        if (iov->iov_len == 0) {
                uio->uio_iov++;
        iov = uio->uio_iov;
        if (iov->iov_len == 0) {
                uio->uio_iov++;


@@ -130,7 +147,7 @@ again:
                break;
 
        case UIO_SYSSPACE:
                break;
 
        case UIO_SYSSPACE:

-               c = *iov->iov_base & 0377;
+               c = *(u_char *) iov->iov_base;

                break;
 
        case UIO_USERISPACE:
                break;
 
        case UIO_USERISPACE:


@@ -143,5 +160,30 @@ again:
        iov->iov_len--;
        uio->uio_resid--;
        uio->uio_offset++;
        iov->iov_len--;
        uio->uio_resid--;
        uio->uio_offset++;

-       return (c & 0377);
+       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);

 }
 }