sys/dev/raidframe/rf_mcpair.c

   1 /*      $NetBSD: rf_mcpair.c,v 1.21 2006/11/16 01:33:23 christos Exp $  */
   2 /*
   3  * Copyright (c) 1995 Carnegie-Mellon University.
   4  * All rights reserved.
   5  *
   6  * Author: Jim Zelenka
   7  *
   8  * Permission to use, copy, modify and distribute this software and
   9  * its documentation is hereby granted, provided that both the copyright
  10  * notice and this permission notice appear in all copies of the
  11  * software, derivative works or modified versions, and any portions
  12  * thereof, and that both notices appear in supporting documentation.
  13  *
  14  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  15  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
  16  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  17  *
  18  * Carnegie Mellon requests users of this software to return to
  19  *
  20  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  21  *  School of Computer Science
  22  *  Carnegie Mellon University
  23  *  Pittsburgh PA 15213-3890
  24  *
  25  * any improvements or extensions that they make and grant Carnegie the
  26  * rights to redistribute these changes.
  27  */
  28
  29 /* rf_mcpair.c
  30  * an mcpair is a structure containing a mutex and a condition variable.
  31  * it's used to block the current thread until some event occurs.
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __KERNEL_RCSID(0, "$NetBSD: rf_mcpair.c,v 1.21 2006/11/16 01:33:23 christos Exp $");
  36
  37 #include <dev/raidframe/raidframevar.h>
  38
  39 #include "rf_archs.h"
  40 #include "rf_threadstuff.h"
  41 #include "rf_mcpair.h"
  42 #include "rf_debugMem.h"
  43 #include "rf_general.h"
  44 #include "rf_shutdown.h"
  45 #include "rf_netbsd.h"
  46
  47 #include <sys/pool.h>
  48 #include <sys/proc.h>
  49
  50 #define RF_MAX_FREE_MCPAIR 128
  51 #define RF_MIN_FREE_MCPAIR  24
  52
  53 static void rf_ShutdownMCPair(void *);
  54
  55 static void
  56 rf_ShutdownMCPair(void *ignored)
  57 {
  58         pool_destroy(&rf_pools.mcpair);
  59 }
  60
  61 int
  62 rf_ConfigureMCPair(RF_ShutdownList_t **listp)
  63 {
  64
  65         rf_pool_init(&rf_pools.mcpair, sizeof(RF_MCPair_t),
  66                      "rf_mcpair_pl", RF_MIN_FREE_MCPAIR, RF_MAX_FREE_MCPAIR);
  67         rf_ShutdownCreate(listp, rf_ShutdownMCPair, NULL);
  68
  69         return (0);
  70 }
  71
  72 RF_MCPair_t *
  73 rf_AllocMCPair(void)
  74 {
  75         RF_MCPair_t *t;
  76
  77         t = pool_get(&rf_pools.mcpair, PR_WAITOK);
  78         simple_lock_init(&t->mutex);
  79         t->cond = 0;
  80         t->flag = 0;
  81
  82         return (t);
  83 }
  84
  85 void
  86 rf_FreeMCPair(RF_MCPair_t *t)
  87 {
  88         pool_put(&rf_pools.mcpair, t);
  89 }
  90
  91 /* the callback function used to wake you up when you use an mcpair to
  92    wait for something */
  93 void
  94 rf_MCPairWakeupFunc(RF_MCPair_t *mcpair)
  95 {
  96         RF_LOCK_MUTEX(mcpair->mutex);
  97         mcpair->flag = 1;
  98         wakeup(&(mcpair->cond));
  99         RF_UNLOCK_MUTEX(mcpair->mutex);
 100 }