Annotation of src/sys/dev/raidframe/rf_threadstuff.h, revision 1.2

1.2     ! oster       1: /*     $NetBSD: rf_threadstuff.h,v 1.1 1998/11/13 04:20:35 oster Exp $ */
1.1       oster       2: /*
                      3:  * Copyright (c) 1995 Carnegie-Mellon University.
                      4:  * All rights reserved.
                      5:  *
                      6:  * Author: Mark Holland, Daniel Stodolsky, 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: /*
                     30:  * threadstuff.h -- definitions for threads, locks, and synchronization
                     31:  *
                     32:  * The purpose of this file is provide some illusion of portability.
                     33:  * If the functions below can be implemented with the same semantics on
                     34:  * some new system, then at least the synchronization and thread control
                     35:  * part of the code should not require modification to port to a new machine.
                     36:  * the only other place where the pthread package is explicitly used is
                     37:  * threadid.h
                     38:  *
                     39:  * this file should be included above stdio.h to get some necessary defines.
                     40:  *
                     41:  */
                     42: 
                     43: #ifndef _RF__RF_THREADSTUFF_H_
                     44: #define _RF__RF_THREADSTUFF_H_
                     45: 
                     46: #include "rf_types.h"
1.2     ! oster      47: #include <sys/types.h>
        !            48: #include <sys/param.h>
        !            49: #ifdef _KERNEL
        !            50: #include <sys/systm.h>
        !            51: #include <sys/proc.h>
        !            52: #include <sys/kthread.h>
        !            53: #endif
1.1       oster      54: 
                     55: #define rf_create_managed_mutex(a,b) _rf_create_managed_mutex(a,b,__FILE__,__LINE__)
                     56: #define rf_create_managed_cond(a,b) _rf_create_managed_cond(a,b,__FILE__,__LINE__)
                     57: #define rf_init_managed_threadgroup(a,b) _rf_init_managed_threadgroup(a,b,__FILE__,__LINE__)
                     58: #define rf_init_threadgroup(a) _rf_init_threadgroup(a,__FILE__,__LINE__)
                     59: #define rf_destroy_threadgroup(a) _rf_destroy_threadgroup(a,__FILE__,__LINE__)
                     60: 
                     61: int _rf_init_threadgroup(RF_ThreadGroup_t *g, char *file, int line);
                     62: int _rf_destroy_threadgroup(RF_ThreadGroup_t *g, char *file, int line);
                     63: int _rf_init_managed_threadgroup(RF_ShutdownList_t **listp,
                     64:        RF_ThreadGroup_t *g, char *file, int line);
                     65: 
                     66: #include <sys/lock.h>
                     67: #define decl_simple_lock_data(a,b) a struct simplelock b;
                     68: #define simple_lock_addr(a) ((struct simplelock *)&(a))
                     69: 
                     70: typedef struct proc *RF_Thread_t;
                     71: typedef void *RF_ThreadArg_t;
                     72: 
                     73: #define RF_DECLARE_MUTEX(_m_)           decl_simple_lock_data(,(_m_))
                     74: #define RF_DECLARE_STATIC_MUTEX(_m_)    decl_simple_lock_data(static,(_m_))
                     75: #define RF_DECLARE_EXTERN_MUTEX(_m_)    decl_simple_lock_data(extern,(_m_))
                     76: 
                     77: #define RF_DECLARE_COND(_c_)            int _c_;
                     78: #define RF_DECLARE_STATIC_COND(_c_)     static int _c_;
                     79: #define RF_DECLARE_EXTERN_COND(_c_)     extern int _c_;
                     80: 
                     81: #define RF_LOCK_MUTEX(_m_)              simple_lock(&(_m_))
                     82: #define RF_UNLOCK_MUTEX(_m_)            simple_unlock(&(_m_))
                     83: 
                     84: /*
                     85:  * In NetBSD, kernel threads are simply processes which share several
                     86:  * substructures and never run in userspace.
                     87:  *
                     88:  * XXX Note, NetBSD does not yet have a wakeup_one(), so we always
                     89:  * XXX get Thundering Herd when a condition occurs.
                     90:  */
                     91: #define RF_WAIT_COND(_c_,_m_)           { \
                     92:        RF_UNLOCK_MUTEX(_m_); \
                     93:        tsleep(&_c_, PRIBIO | PCATCH, "rfwcond", 0); \
                     94:        RF_LOCK_MUTEX(_m_); \
                     95: }
                     96: #define RF_SIGNAL_COND(_c_)            wakeup(&(_c_))
                     97: #define RF_BROADCAST_COND(_c_)         wakeup(&(_c_))
                     98: #define        RF_CREATE_THREAD(_handle_, _func_, _arg_) \
                     99:        kthread_create((void (*) __P((void *)))(_func_), (void *)(_arg_), \
                    100:            (struct proc **)&(_handle_), "raid")
                    101: 
                    102: struct RF_ThreadGroup_s {
                    103:   int  created;
                    104:   int  running;
                    105:   int  shutdown;
                    106:   RF_DECLARE_MUTEX(mutex)
                    107:   RF_DECLARE_COND(cond)
                    108: };
                    109: 
                    110: /*
                    111:  * Someone has started a thread in the group
                    112:  */
                    113: #define RF_THREADGROUP_STARTED(_g_) { \
                    114:        RF_LOCK_MUTEX((_g_)->mutex); \
                    115:        (_g_)->created++; \
                    116:        RF_UNLOCK_MUTEX((_g_)->mutex); \
                    117: }
                    118: 
                    119: /*
                    120:  * Thread announcing that it is now running
                    121:  */
                    122: #define RF_THREADGROUP_RUNNING(_g_) { \
                    123:        RF_LOCK_MUTEX((_g_)->mutex); \
                    124:        (_g_)->running++; \
                    125:        RF_UNLOCK_MUTEX((_g_)->mutex); \
                    126:        RF_SIGNAL_COND((_g_)->cond); \
                    127: }
                    128: 
                    129: /*
                    130:  * Thread announcing that it is now done
                    131:  */
                    132: #define RF_THREADGROUP_DONE(_g_) { \
                    133:        RF_LOCK_MUTEX((_g_)->mutex); \
                    134:        (_g_)->shutdown++; \
                    135:        RF_UNLOCK_MUTEX((_g_)->mutex); \
                    136:        RF_SIGNAL_COND((_g_)->cond); \
                    137: }
                    138: 
                    139: /*
                    140:  * Wait for all threads to start running
                    141:  */
                    142: #define RF_THREADGROUP_WAIT_START(_g_) { \
                    143:        RF_LOCK_MUTEX((_g_)->mutex); \
                    144:        while((_g_)->running < (_g_)->created) { \
                    145:                RF_WAIT_COND((_g_)->cond, (_g_)->mutex); \
                    146:        } \
                    147:        RF_UNLOCK_MUTEX((_g_)->mutex); \
                    148: }
                    149: 
                    150: /*
                    151:  * Wait for all threads to stop running
                    152:  */
                    153: #ifndef __NetBSD__
                    154: #define RF_THREADGROUP_WAIT_STOP(_g_) { \
                    155:        RF_LOCK_MUTEX((_g_)->mutex); \
                    156:        RF_ASSERT((_g_)->running == (_g_)->created); \
                    157:        while((_g_)->shutdown < (_g_)->running) { \
                    158:                RF_WAIT_COND((_g_)->cond, (_g_)->mutex); \
                    159:        } \
                    160:        RF_UNLOCK_MUTEX((_g_)->mutex); \
                    161: }
                    162: #else
                    163:   /* XXX Note that we've removed the assert.  That should get put back
                    164:      in once we actually get something like a kernel thread running */
                    165: #define RF_THREADGROUP_WAIT_STOP(_g_) { \
                    166:        RF_LOCK_MUTEX((_g_)->mutex); \
                    167:        while((_g_)->shutdown < (_g_)->running) { \
                    168:                RF_WAIT_COND((_g_)->cond, (_g_)->mutex); \
                    169:        } \
                    170:        RF_UNLOCK_MUTEX((_g_)->mutex); \
                    171: }
                    172: #endif
                    173: 
                    174: 
                    175: int rf_mutex_init(struct simplelock *);
                    176: int rf_mutex_destroy(struct simplelock *);
                    177: int _rf_create_managed_mutex(RF_ShutdownList_t **, struct simplelock *, 
                    178:                             char *, int);
                    179: int _rf_create_managed_cond(RF_ShutdownList_t **listp, int *, 
                    180:                            char *file, int line);
                    181: 
                    182: int rf_cond_init(int *c); /* XXX need to write?? */
                    183: int rf_cond_destroy(int *c); /* XXX need to write?? */
                    184: #endif /* !_RF__RF_THREADSTUFF_H_ */

CVSweb <webmaster@jp.NetBSD.org>