bsd/kern/kern_subr.c

   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 NeXT Computer, Inc. All Rights Reserved */
  23 /*
  24  * Copyright (c) 1982, 1986, 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_subr.c 8.3 (Berkeley) 1/21/94
  61  */
  62
  63 #include <sys/param.h>
  64 #include <sys/systm.h>
  65 #include <sys/proc.h>
  66 #include <sys/malloc.h>
  67 #include <sys/queue.h>
  68
  69 #include <kdebug.h>
  70
  71 #include <sys/kdebug.h>
  72 #define DBG_UIO_COPYOUT 16
  73 #define DBG_UIO_COPYIN  17
  74
  75
  76 int
  77 uiomove(cp, n, uio)
  78         register caddr_t cp;
  79         register int n;
  80         register struct uio *uio;
  81 {
  82         register struct iovec *iov;
  83         u_int cnt;
  84         int error = 0;
  85
  86 #if DIAGNOSTIC
  87         if (uio->uio_rw != UIO_READ && uio->uio_rw != UIO_WRITE)
  88                 panic("uiomove: mode");
  89         if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != current_proc())
  90                 panic("uiomove proc");
  91 #endif
  92
  93         while (n > 0 && uio->uio_resid) {
  94                 iov = uio->uio_iov;
  95                 cnt = iov->iov_len;
  96                 if (cnt == 0) {
  97                         uio->uio_iov++;
  98                         uio->uio_iovcnt--;
  99                         continue;
 100                 }
 101                 if (cnt > n)
 102                         cnt = n;
 103                 switch (uio->uio_segflg) {
 104
 105                 case UIO_USERSPACE:
 106                 case UIO_USERISPACE:
 107                         if (uio->uio_rw == UIO_READ)
 108                           {
 109                                 KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, DBG_UIO_COPYOUT)) | DBG_FUNC_START,
 110                                          cp, iov->iov_base, cnt, 0,0);
 111
 112                                 error = copyout(cp, iov->iov_base, cnt);
 113
 114                                 KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, DBG_UIO_COPYOUT)) | DBG_FUNC_END,
 115                                          cp, iov->iov_base, cnt, 0,0);
 116                           }
 117                         else
 118                           {
 119                                 KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, DBG_UIO_COPYIN)) | DBG_FUNC_START,
 120                                          iov->iov_base, cp, cnt, 0,0);
 121
 122                                 error = copyin(iov->iov_base, cp, cnt);
 123
 124                                 KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, DBG_UIO_COPYIN)) | DBG_FUNC_END,
 125                                          iov->iov_base, cp, cnt, 0,0);
 126                           }
 127                         if (error)
 128                                 return (error);
 129                         break;
 130
 131                 case UIO_SYSSPACE:
 132                         if (uio->uio_rw == UIO_READ)
 133                                 error = copywithin((caddr_t)cp, iov->iov_base,
 134                                                    cnt);
 135                         else
 136                                 error = copywithin(iov->iov_base, (caddr_t)cp,
 137                                                    cnt);
 138                         break;
 139 #ifdef ppc
 140                 case UIO_PHYS_USERSPACE:
 141                         if (uio->uio_rw == UIO_READ)
 142                           {
 143                                 KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, DBG_UIO_COPYOUT)) | DBG_FUNC_START,
 144                                          cp, iov->iov_base, cnt, 1,0);
 145
 146                                 error = copyp2v(cp, iov->iov_base, cnt);
 147
 148
 149                                 KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, DBG_UIO_COPYOUT)) | DBG_FUNC_END,
 150                                          cp, iov->iov_base, cnt, 1,0);
 151                           }
 152                         else
 153                           {
 154                                 KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, DBG_UIO_COPYIN)) | DBG_FUNC_START,
 155                                          iov->iov_base, cp, cnt, 1,0);
 156
 157                                 panic("copyv2p not implemented yet\n");
 158
 159                                 KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, DBG_UIO_COPYIN)) | DBG_FUNC_END,
 160                                          iov->iov_base, cp, cnt, 1,0);
 161                           }
 162                         if (error)
 163                                 return (error);
 164                         break;
 165 #endif
 166                 }
 167                 iov->iov_base += cnt;
 168                 iov->iov_len -= cnt;
 169                 uio->uio_resid -= cnt;
 170                 uio->uio_offset += cnt;
 171                 cp += cnt;
 172                 n -= cnt;
 173         }
 174         return (error);
 175 }
 176
 177 /*
 178  * Give next character to user as result of read.
 179  */
 180 int
 181 ureadc(c, uio)
 182         register int c;
 183         register struct uio *uio;
 184 {
 185         register struct iovec *iov;
 186
 187         if (uio->uio_resid <= 0)
 188                 panic("ureadc: non-positive resid");
 189 again:
 190         if (uio->uio_iovcnt == 0)
 191                 panic("ureadc: non-positive iovcnt");
 192         iov = uio->uio_iov;
 193         if (iov->iov_len <= 0) {
 194                 uio->uio_iovcnt--;
 195                 uio->uio_iov++;
 196                 goto again;
 197         }
 198         switch (uio->uio_segflg) {
 199
 200         case UIO_USERSPACE:
 201                 if (subyte(iov->iov_base, c) < 0)
 202                         return (EFAULT);
 203                 break;
 204
 205         case UIO_SYSSPACE:
 206                 *iov->iov_base = c;
 207                 break;
 208
 209         case UIO_USERISPACE:
 210                 if (suibyte(iov->iov_base, c) < 0)
 211                         return (EFAULT);
 212                 break;
 213         }
 214         iov->iov_base++;
 215         iov->iov_len--;
 216         uio->uio_resid--;
 217         uio->uio_offset++;
 218         return (0);
 219 }
 220
 221 #if defined(vax) || defined(ppc)
 222 /* unused except by ct.c, other oddities XXX */
 223 /*
 224  * Get next character written in by user from uio.
 225  */
 226 uwritec(uio)
 227         struct uio *uio;
 228 {
 229         register struct iovec *iov;
 230         register int c;
 231
 232         if (uio->uio_resid <= 0)
 233                 return (-1);
 234 again:
 235         if (uio->uio_iovcnt <= 0)
 236                 panic("uwritec: non-positive iovcnt");
 237         iov = uio->uio_iov;
 238         if (iov->iov_len == 0) {
 239                 uio->uio_iov++;
 240                 if (--uio->uio_iovcnt == 0)
 241                         return (-1);
 242                 goto again;
 243         }
 244         switch (uio->uio_segflg) {
 245
 246         case UIO_USERSPACE:
 247                 c = fubyte(iov->iov_base);
 248                 break;
 249
 250         case UIO_SYSSPACE:
 251                 c = *iov->iov_base & 0377;
 252                 break;
 253
 254         case UIO_USERISPACE:
 255                 c = fuibyte(iov->iov_base);
 256                 break;
 257
 258         default:
 259                 c = 0;  /* avoid uninitialized variable warning */
 260                 panic("uwritec: bogus uio_segflg");
 261                 break;
 262         }
 263         if (c < 0)
 264                 return (-1);
 265         iov->iov_base++;
 266         iov->iov_len--;
 267         uio->uio_resid--;
 268         uio->uio_offset++;
 269         return (c);
 270 }
 271 #endif /* vax || ppc */
 272
 273 /*
 274  * General routine to allocate a hash table.
 275  */
 276 void *
 277 hashinit(elements, type, hashmask)
 278         int elements, type;
 279         u_long *hashmask;
 280 {
 281         long hashsize;
 282         LIST_HEAD(generic, generic) *hashtbl;
 283         int i;
 284
 285         if (elements <= 0)
 286                 panic("hashinit: bad cnt");
 287         for (hashsize = 1; hashsize <= elements; hashsize <<= 1)
 288                 continue;
 289         hashsize >>= 1;
 290         MALLOC(hashtbl, struct generic *,
 291                         (u_long)hashsize * sizeof(*hashtbl), type, M_WAITOK);
 292         bzero(hashtbl, (u_long)hashsize * sizeof(*hashtbl));
 293         for (i = 0; i < hashsize; i++)
 294                 LIST_INIT(&hashtbl[i]);
 295         *hashmask = hashsize - 1;
 296         return (hashtbl);
 297 }