root/kern/kern_subr.c

DEFINITIONS

1. uiomove
2. ureadc
3. hashinit
4. hook_establish
5. hook_disestablish
6. dohooks
7. powerhook_establish
8. powerhook_disestablish
9. dopowerhooks

    1 /*      $OpenBSD: kern_subr.c,v 1.31 2007/05/16 17:27:30 art Exp $      */
    2 /*      $NetBSD: kern_subr.c,v 1.15 1996/04/09 17:21:56 ragge Exp $     */
    4 /*
    5  * Copyright (c) 1982, 1986, 1991, 1993
    6  *      The Regents of the University of California.  All rights reserved.
    7  * (c) UNIX System Laboratories, Inc.
    8  * All or some portions of this file are derived from material licensed
    9  * to the University of California by American Telephone and Telegraph
   10  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
   11  * the permission of UNIX System Laboratories, Inc.
   12  *
   13  * Redistribution and use in source and binary forms, with or without
   14  * modification, are permitted provided that the following conditions
   15  * are met:
   16  * 1. Redistributions of source code must retain the above copyright
   17  *    notice, this list of conditions and the following disclaimer.
   18  * 2. Redistributions in binary form must reproduce the above copyright
   19  *    notice, this list of conditions and the following disclaimer in the
   20  *    documentation and/or other materials provided with the distribution.
   21  * 3. Neither the name of the University nor the names of its contributors
   22  *    may be used to endorse or promote products derived from this software
   23  *    without specific prior written permission.
   24  *
   25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   35  * SUCH DAMAGE.
   36  *
   37  *      @(#)kern_subr.c 8.3 (Berkeley) 1/21/94
   38  */
   40 #include <sys/param.h>
   41 #include <sys/systm.h>
   42 #include <sys/proc.h>
   43 #include <sys/sched.h>
   44 #include <sys/malloc.h>
   45 #include <sys/queue.h>
   46 #include <sys/kernel.h>
   47 #include <sys/resourcevar.h>
   49 int
uiomove(void *cp, int n, struct uio *uio)
   51 {
   52         struct iovec *iov;
u_int cnt;
   54         int error = 0;
   55         struct proc *p;
p = uio->uio_procp;
   59 #ifdef DIAGNOSTIC
   60         if (uio->uio_rw != UIO_READ && uio->uio_rw != UIO_WRITE)
panic("uiomove: mode");
   62         if (uio->uio_segflg == UIO_USERSPACE && p != curproc)
panic("uiomove: proc");
   64 #endif
   65         while (n > 0 && uio->uio_resid) {
iov = uio->uio_iov;
cnt = iov->iov_len;
   68                 if (cnt == 0) {
uio->uio_iov++;
uio->uio_iovcnt--;
   71                         continue;
   72                 }
   73                 if (cnt > n)
cnt = n;
   75                 switch (uio->uio_segflg) {
   77                 case UIO_USERSPACE:
   78                         if (curcpu()->ci_schedstate.spc_schedflags &
SPCF_SHOULDYIELD)
preempt(NULL);
   81                         if (uio->uio_rw == UIO_READ)
error = copyout(cp, iov->iov_base, cnt);
   83                         else
error = copyin(iov->iov_base, cp, cnt);
   85                         if (error)
   86                                 return (error);
   87                         break;
   89                 case UIO_SYSSPACE:
   90                         if (uio->uio_rw == UIO_READ)
error = kcopy(cp, iov->iov_base, cnt);
   92                         else
error = kcopy(iov->iov_base, cp, cnt);
   94                         if (error)
   95                                 return(error);
   96                 }
iov->iov_base = (caddr_t)iov->iov_base + cnt;
iov->iov_len -= cnt;
uio->uio_resid -= cnt;
uio->uio_offset += cnt;
cp = (caddr_t)cp + cnt;
n -= cnt;
  103         }
  104         return (error);
  105 }
  107 /*
  108  * Give next character to user as result of read.
  109  */
  110 int
ureadc(int c, struct uio *uio)
  112 {
  113         struct iovec *iov;
  115         if (uio->uio_resid == 0)
  116 #ifdef DIAGNOSTIC
panic("ureadc: zero resid");
  118 #else
  119                 return (EINVAL);
  120 #endif
again:
  122         if (uio->uio_iovcnt <= 0)
  123 #ifdef DIAGNOSTIC
panic("ureadc: non-positive iovcnt");
  125 #else
  126                 return (EINVAL);
  127 #endif
iov = uio->uio_iov;
  129         if (iov->iov_len <= 0) {
uio->uio_iovcnt--;
uio->uio_iov++;
  132                 goto again;
  133         }
  134         switch (uio->uio_segflg) {
  136         case UIO_USERSPACE:
  137         {
  138                 char tmp = c;
  140                 if (copyout(&tmp, iov->iov_base, sizeof(char)) != 0)
  141                         return (EFAULT);
  142         }
  143                 break;
  145         case UIO_SYSSPACE:
  146                 *(char *)iov->iov_base = c;
  147                 break;
  148         }
iov->iov_base = (caddr_t)iov->iov_base + 1;
iov->iov_len--;
uio->uio_resid--;
uio->uio_offset++;
  153         return (0);
  154 }
  156 /*
  157  * General routine to allocate a hash table.
  158  */
  159 void *
hashinit(int elements, int type, int flags, u_long *hashmask)
  161 {
u_long hashsize, i;
LIST_HEAD(generic, generic) *hashtbl;
  165         if (elements <= 0)
panic("hashinit: bad cnt");
  167         for (hashsize = 1; hashsize < elements; hashsize <<= 1)
  168                 continue;
hashtbl = malloc(hashsize * sizeof(*hashtbl), type, flags);
  170         if (hashtbl == NULL)
  171                 return NULL;
  172         for (i = 0; i < hashsize; i++)
LIST_INIT(&hashtbl[i]);
  174         *hashmask = hashsize - 1;
  175         return (hashtbl);
  176 }
  178 /*
  179  * "Shutdown/startup hook" types, functions, and variables.
  180  */
  182 struct hook_desc_head startuphook_list =
TAILQ_HEAD_INITIALIZER(startuphook_list);
  184 struct hook_desc_head shutdownhook_list =
TAILQ_HEAD_INITIALIZER(shutdownhook_list);
  186 struct hook_desc_head mountroothook_list =
TAILQ_HEAD_INITIALIZER(mountroothook_list);
  189 void *
hook_establish(struct hook_desc_head *head, int tail, void (*fn)(void *),
  191     void *arg)
  192 {
  193         struct hook_desc *hdp;
hdp = (struct hook_desc *)malloc(sizeof (*hdp), M_DEVBUF, M_NOWAIT);
  196         if (hdp == NULL)
  197                 return (NULL);
hdp->hd_fn = fn;
hdp->hd_arg = arg;
  201         if (tail)
TAILQ_INSERT_TAIL(head, hdp, hd_list);
  203         else
TAILQ_INSERT_HEAD(head, hdp, hd_list);
  206         return (hdp);
  207 }
  209 void
hook_disestablish(struct hook_desc_head *head, void *vhook)
  211 {
  212         struct hook_desc *hdp;
  214 #ifdef DIAGNOSTIC
  215         for (hdp = TAILQ_FIRST(head); hdp != NULL;
hdp = TAILQ_NEXT(hdp, hd_list))
  217                 if (hdp == vhook)
  218                         break;
  219         if (hdp == NULL)
panic("hook_disestablish: hook not established");
  221 #endif
hdp = vhook;
TAILQ_REMOVE(head, hdp, hd_list);
free(hdp, M_DEVBUF);
  225 }
  227 /*
  228  * Run hooks.  Startup hooks are invoked right after scheduler_start but
  229  * before root is mounted.  Shutdown hooks are invoked immediately before the
  230  * system is halted or rebooted, i.e. after file systems unmounted,
  231  * after crash dump done, etc.
  232  */
  233 void
dohooks(struct hook_desc_head *head, int flags)
  235 {
  236         struct hook_desc *hdp;
  238         if ((flags & HOOK_REMOVE) == 0) {
TAILQ_FOREACH(hdp, head, hd_list) {
  240                         (*hdp->hd_fn)(hdp->hd_arg);
  241                 }
  242         } else {
  243                 while ((hdp = TAILQ_FIRST(head)) != NULL) {
TAILQ_REMOVE(head, hdp, hd_list);
  245                         (*hdp->hd_fn)(hdp->hd_arg);
  246                         if ((flags & HOOK_FREE) != 0)
free(hdp, M_DEVBUF);
  248                 }
  249         }
  250 }
  252 /*
  253  * "Power hook" types, functions, and variables.
  254  */
  256 struct powerhook_desc {
CIRCLEQ_ENTRY(powerhook_desc) sfd_list;
  258         void    (*sfd_fn)(int, void *);
  259         void    *sfd_arg;
  260 };
CIRCLEQ_HEAD(, powerhook_desc) powerhook_list =
CIRCLEQ_HEAD_INITIALIZER(powerhook_list);
  265 void *
powerhook_establish(void (*fn)(int, void *), void *arg)
  267 {
  268         struct powerhook_desc *ndp;
ndp = (struct powerhook_desc *)
malloc(sizeof(*ndp), M_DEVBUF, M_NOWAIT);
  272         if (ndp == NULL)
  273                 return NULL;
ndp->sfd_fn = fn;
ndp->sfd_arg = arg;
CIRCLEQ_INSERT_HEAD(&powerhook_list, ndp, sfd_list);
  279         return (ndp);
  280 }
  282 void
powerhook_disestablish(void *vhook)
  284 {
  285 #ifdef DIAGNOSTIC
  286         struct powerhook_desc *dp;
CIRCLEQ_FOREACH(dp, &powerhook_list, sfd_list)
  289                 if (dp == vhook)
  290                         break;
  291         if (dp == NULL)
panic("powerhook_disestablish: hook not established");
  293 #endif
CIRCLEQ_REMOVE(&powerhook_list, (struct powerhook_desc *)vhook,
sfd_list);
free(vhook, M_DEVBUF);
  298 }
  300 /*
  301  * Run power hooks.
  302  */
  303 void
dopowerhooks(int why)
  305 {
  306         struct powerhook_desc *dp;
  307         int s;
s = splhigh();
  310         if (why == PWR_RESUME) {
CIRCLEQ_FOREACH_REVERSE(dp, &powerhook_list, sfd_list) {
  312                         (*dp->sfd_fn)(why, dp->sfd_arg);
  313                 }
  314         } else {
CIRCLEQ_FOREACH(dp, &powerhook_list, sfd_list) {
  316                         (*dp->sfd_fn)(why, dp->sfd_arg);
  317                 }
  318         }
splx(s);
  320 }