sys/dev/raidframe/rf_diskqueue.h

   1 /*      $NetBSD: rf_diskqueue.h,v 1.22 2007/03/04 06:02:37 christos 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  * rf_diskqueue.h -- header file for disk queues
  32  *
  33  * see comments in rf_diskqueue.c
  34  *
  35  ****************************************************************************************/
  36
  37
  38 #ifndef _RF__RF_DISKQUEUE_H_
  39 #define _RF__RF_DISKQUEUE_H_
  40
  41 #include <sys/queue.h>
  42
  43 #include <dev/raidframe/raidframevar.h>
  44
  45 #include "rf_threadstuff.h"
  46 #include "rf_acctrace.h"
  47 #include "rf_alloclist.h"
  48 #include "rf_etimer.h"
  49 #include "rf_netbsd.h"
  50
  51
  52 #define RF_IO_NORMAL_PRIORITY 1
  53 #define RF_IO_LOW_PRIORITY    0
  54
  55 /* the data held by a disk queue entry */
  56 struct RF_DiskQueueData_s {
  57         RF_SectorNum_t sectorOffset;    /* sector offset into the disk */
  58         RF_SectorCount_t numSector;     /* number of sectors to read/write */
  59         RF_IoType_t type;       /* read/write/nop */
  60         void *buf;              /* buffer pointer */
  61         RF_StripeNum_t parityStripeID;  /* the RAID parity stripe ID this
  62                                          * access is for */
  63         RF_ReconUnitNum_t which_ru;     /* which RU within this parity stripe */
  64         int     priority;       /* the priority of this request */
  65         int     (*CompleteFunc) (void *, int);  /* function to be called upon
  66                                                  * completion */
  67         void   *argument;       /* argument to be passed to CompleteFunc */
  68         RF_Raid_t *raidPtr;     /* needed for simulation */
  69         RF_AccTraceEntry_t *tracerec;   /* perf mon only */
  70         RF_Etimer_t qtime;      /* perf mon only - time request is in queue */
  71         RF_DiskQueueData_t *next;
  72         RF_DiskQueueData_t *prev;
  73         RF_DiskQueue_t *queue;  /* the disk queue to which this req is
  74                                  * targeted */
  75         RF_DiskQueueDataFlags_t flags;  /* flags controlling operation */
  76
  77         struct proc *b_proc;    /* the b_proc from the original bp passed into
  78                                  * the driver for this I/O */
  79         struct buf *bp;         /* a bp to use to get this I/O done */
  80         /* TAILQ bits for a queue for completed I/O requests */
  81         TAILQ_ENTRY(RF_DiskQueueData_s) iodone_entries;
  82         int  error;             /* Indicate if an error occurred
  83                                    on this I/O (1=yes, 0=no) */
  84 };
  85
  86 /* note: "Create" returns type-specific queue header pointer cast to (void *) */
  87 struct RF_DiskQueueSW_s {
  88         RF_DiskQueueType_t queueType;
  89         void   *(*Create) (RF_SectorCount_t, RF_AllocListElem_t *, RF_ShutdownList_t **);       /* creation routine --
  90                                                                                                  * one call per queue in
  91                                                                                                  * system */
  92         void    (*Enqueue) (void *, RF_DiskQueueData_t *, int); /* enqueue routine */
  93         RF_DiskQueueData_t *(*Dequeue) (void *);        /* dequeue routine */
  94         RF_DiskQueueData_t *(*Peek) (void *);   /* peek at head of queue */
  95
  96         /* the rest are optional:  they improve performance, but the driver
  97          * will deal with it if they don't exist */
  98         int     (*Promote) (void *, RF_StripeNum_t, RF_ReconUnitNum_t); /* promotes priority of
  99                                                                          * tagged accesses */
 100 };
 101
 102 struct RF_DiskQueue_s {
 103         const RF_DiskQueueSW_t *qPtr;   /* access point to queue functions */
 104         void   *qHdr;           /* queue header, of whatever type */
 105         RF_DECLARE_MUTEX(mutex) /* mutex locking data structures */
 106         RF_DECLARE_COND(cond)   /* condition variable for
 107                                  * synchronization */
 108         long    numOutstanding; /* number of I/Os currently outstanding on
 109                                  * disk */
 110         long    maxOutstanding; /* max # of I/Os that can be outstanding on a
 111                                  * disk (in-kernel only) */
 112         int     curPriority;    /* the priority of accs all that are currently
 113                                  * outstanding */
 114         long    queueLength;    /* number of requests in queue */
 115         RF_DiskQueueFlags_t flags;      /* terminate, locked */
 116         RF_Raid_t *raidPtr;     /* associated array */
 117         dev_t   dev;            /* device number for kernel version */
 118         RF_SectorNum_t last_deq_sector; /* last sector number dequeued or
 119                                          * dispatched */
 120         int     col;    /* debug only */
 121         struct raidcinfo *rf_cinfo;     /* disks component info.. */
 122 };
 123 #define RF_DQ_LOCKED  0x02      /* no new accs allowed until queue is
 124                                  * explicitly unlocked */
 125
 126 /* macros setting & returning information about queues and requests */
 127 #define RF_QUEUE_EMPTY(_q)                  ((_q)->numOutstanding == 0)
 128 #define RF_QUEUE_FULL(_q)                   ((_q)->numOutstanding == (_q)->maxOutstanding)
 129
 130 #define RF_LOCK_QUEUE_MUTEX(_q_,_wh_)   RF_LOCK_MUTEX((_q_)->mutex)
 131 #define RF_UNLOCK_QUEUE_MUTEX(_q_,_wh_) RF_UNLOCK_MUTEX((_q_)->mutex)
 132
 133 /* whether it is ok to dispatch a regular request */
 134 #define RF_OK_TO_DISPATCH(_q_,_r_) \
 135   (RF_QUEUE_EMPTY(_q_) || \
 136     (!RF_QUEUE_FULL(_q_) && ((_r_)->priority >= (_q_)->curPriority)))
 137
 138 int rf_ConfigureDiskQueueSystem(RF_ShutdownList_t **);
 139 int rf_ConfigureDiskQueues(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
 140 void rf_DiskIOEnqueue(RF_DiskQueue_t *, RF_DiskQueueData_t *, int);
 141 void rf_DiskIOComplete(RF_DiskQueue_t *, RF_DiskQueueData_t *, int);
 142 int rf_DiskIOPromote(RF_DiskQueue_t *, RF_StripeNum_t,  RF_ReconUnitNum_t);
 143 RF_DiskQueueData_t *rf_CreateDiskQueueData(RF_IoType_t, RF_SectorNum_t,
 144                                            RF_SectorCount_t , void *,
 145                                            RF_StripeNum_t, RF_ReconUnitNum_t,
 146                                            int (*wakeF) (void *, int),
 147                                            void *,
 148                                            RF_AccTraceEntry_t *, RF_Raid_t *,
 149                                            RF_DiskQueueDataFlags_t,
 150                                            void *, int);
 151 void rf_FreeDiskQueueData(RF_DiskQueueData_t *);
 152 int rf_ConfigureDiskQueue(RF_Raid_t *, RF_DiskQueue_t *,
 153                           RF_RowCol_t, const RF_DiskQueueSW_t *,
 154                           RF_SectorCount_t, dev_t, int,
 155                           RF_ShutdownList_t **,
 156                           RF_AllocListElem_t *);
 157
 158 #endif                          /* !_RF__RF_DISKQUEUE_H_ */