sys/dev/raidframe/rf_stripelocks.h

   1 /*      $NetBSD: rf_stripelocks.h,v 1.5.2.3 2004/09/21 13:32:55 skrll Exp $     */
   2 /*
   3  * Copyright (c) 1995 Carnegie-Mellon University.
   4  * All rights reserved.
   5  *
   6  * Author: Mark Holland
   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  *
  31  * stripelocks.h -- header file for locking stripes
  32  *
  33  * Note that these functions are called from the execution routines of certain
  34  * DAG Nodes, and so they must be NON-BLOCKING to assure maximum parallelism
  35  * in the DAG.  Accordingly, when a node wants to acquire a lock, it calls
  36  * AcquireStripeLock, supplying a pointer to a callback function.  If the lock
  37  * is free at the time of the call, 0 is returned, indicating that the lock
  38  * has been acquired.  If the lock is not free, 1 is returned, and a copy of
  39  * the function pointer and argument are held in the lock table.  When the
  40  * lock becomes free, the callback function is invoked.
  41  *
  42  *****************************************************************************/
  43
  44 #ifndef _RF__RF_STRIPELOCKS_H_
  45 #define _RF__RF_STRIPELOCKS_H_
  46
  47 #include <sys/buf.h>
  48 #include <dev/raidframe/raidframevar.h>
  49
  50 #include "rf_threadstuff.h"
  51 #include "rf_general.h"
  52
  53 struct RF_LockReqDesc_s {
  54         RF_IoType_t type;       /* read or write */
  55         RF_int64 start, stop;   /* start and end of range to be locked */
  56         RF_int64 start2, stop2; /* start and end of 2nd range to be locked */
  57         void    (*cbFunc) (struct buf *);       /* callback function */
  58         void   *cbArg;          /* argument to callback function */
  59         RF_LockReqDesc_t *next; /* next element in chain */
  60         RF_LockReqDesc_t *templink;     /* for making short-lived lists of
  61                                          * request descriptors */
  62 };
  63 #define RF_ASSERT_VALID_LOCKREQ(_lr_) { \
  64         RF_ASSERT(RF_IO_IS_R_OR_W((_lr_)->type)); \
  65 }
  66
  67 struct RF_StripeLockDesc_s {
  68         RF_StripeNum_t stripeID;/* the stripe ID */
  69         RF_LockReqDesc_t *granted;      /* unordered list of granted requests */
  70         RF_LockReqDesc_t *waitersH;     /* FIFO queue of all waiting reqs,
  71                                          * both read and write (Head and Tail) */
  72         RF_LockReqDesc_t *waitersT;
  73         int     nWriters;       /* number of writers either granted or waiting */
  74         RF_StripeLockDesc_t *next;      /* for hash table collision resolution */
  75 };
  76
  77 struct RF_LockTableEntry_s {
  78         RF_DECLARE_MUTEX(mutex) /* mutex on this hash chain */
  79         RF_StripeLockDesc_t *descList;  /* hash chain of lock descriptors */
  80 };
  81 /*
  82  * Initializes a stripe lock descriptor.  _defSize is the number of sectors
  83  * that we lock when there is no parity information in the ASM (e.g. RAID0).
  84  */
  85
  86 #define RF_INIT_LOCK_REQ_DESC(_lrd, _typ, _cbf, _cba, _asm, _defSize)                                           \
  87   {                                                                                                          \
  88     (_lrd).type    = _typ;                                                                                   \
  89     (_lrd).start2  = -1;                                                                                     \
  90     (_lrd).stop2   = -1;                                                                                     \
  91     if ((_asm)->parityInfo) {                                                                                \
  92       (_lrd).start = (_asm)->parityInfo->startSector;                                                        \
  93       (_lrd).stop  = (_asm)->parityInfo->startSector + (_asm)->parityInfo->numSector-1;                      \
  94       if ((_asm)->parityInfo->next) {                                                                        \
  95         (_lrd).start2  = (_asm)->parityInfo->next->startSector;                                              \
  96         (_lrd).stop2   = (_asm)->parityInfo->next->startSector + (_asm)->parityInfo->next->numSector-1;      \
  97       }                                                                                                      \
  98     } else {                                                                                                 \
  99       (_lrd).start = 0;                                                                                      \
 100       (_lrd).stop  = (_defSize);                                                                             \
 101     }                                                                                                        \
 102     (_lrd).templink= NULL;                                                                                   \
 103     (_lrd).cbFunc  = (_cbf);                                                                                 \
 104     (_lrd).cbArg   = (void *) (_cba);                                                                        \
 105   }
 106
 107 int rf_ConfigureStripeLockFreeList(RF_ShutdownList_t **);
 108 int rf_ConfigureStripeLocks(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
 109 int rf_AcquireStripeLock(RF_LockTableEntry_t *, RF_StripeNum_t, RF_LockReqDesc_t *);
 110 void rf_ReleaseStripeLock(RF_LockTableEntry_t *, RF_StripeNum_t, RF_LockReqDesc_t *);
 111
 112 #endif                          /* !_RF__RF_STRIPELOCKS_H_ */