rf_stripelocks.h

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*      $NetBSD: rf_stripelocks.h,v 1.6 2004/03/04 02:55:58 oster 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_ */

Cache object: c8c2d548f6c280976cbfb34cdd173a31

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/dev/raidframe/rf_stripelocks.h

FreeBSD/Linux Kernel Cross Reference
sys/dev/raidframe/rf_stripelocks.h