root/dev/raidframe/rf_psstatus.c

DEFINITIONS

1. rf_init_pss
2. rf_clean_pss
3. rf_ShutdownPSStatus
4. rf_ConfigurePSStatus
5. rf_MakeParityStripeStatusTable
6. rf_FreeParityStripeStatusTable
7. rf_LookupRUStatus
8. rf_PSStatusDelete
9. rf_RemoveFromActiveReconTable
10. rf_AllocPSStatus
11. rf_FreePSStatus
12. rf_RealPrintPSStatusTable
13. rf_PrintPSStatusTable

    1 /*      $OpenBSD: rf_psstatus.c,v 1.6 2002/12/16 07:01:04 tdeval Exp $  */
    2 /*      $NetBSD: rf_psstatus.c,v 1.5 2000/01/08 22:57:31 oster Exp $    */
    4 /*
    5  * Copyright (c) 1995 Carnegie-Mellon University.
    6  * All rights reserved.
    7  *
    8  * Author: Mark Holland
    9  *
   10  * Permission to use, copy, modify and distribute this software and
   11  * its documentation is hereby granted, provided that both the copyright
   12  * notice and this permission notice appear in all copies of the
   13  * software, derivative works or modified versions, and any portions
   14  * thereof, and that both notices appear in supporting documentation.
   15  *
   16  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
   17  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
   18  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   19  *
   20  * Carnegie Mellon requests users of this software to return to
   21  *
   22  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   23  *  School of Computer Science
   24  *  Carnegie Mellon University
   25  *  Pittsburgh PA 15213-3890
   26  *
   27  * any improvements or extensions that they make and grant Carnegie the
   28  * rights to redistribute these changes.
   29  */
   31 /*****************************************************************************
   32  *
   33  * psstatus.c
   34  *
   35  * The reconstruction code maintains a bunch of status related to the parity
   36  * stripes that are currently under reconstruction. This header file defines
   37  * the status structures.
   38  *
   39  *****************************************************************************/
   41 #include "rf_types.h"
   42 #include "rf_raid.h"
   43 #include "rf_general.h"
   44 #include "rf_debugprint.h"
   45 #include "rf_freelist.h"
   46 #include "rf_psstatus.h"
   47 #include "rf_shutdown.h"
   49 #define Dprintf1(s,a)                                                   \
   50 do {                                                                    \
   51         if (rf_pssDebug)                                                \
rf_debug_printf(s,                                      \
   53                     (void *)((unsigned long)a),                         \
NULL, NULL, NULL, NULL, NULL, NULL, NULL);          \
   55 } while(0)
   56 #define Dprintf2(s,a,b)                                                 \
   57 do {                                                                    \
   58         if (rf_pssDebug)                                                \
rf_debug_printf(s,                                      \
   60                     (void *)((unsigned long)a),                         \
   61                     (void *)((unsigned long)b),                         \
NULL, NULL, NULL, NULL, NULL, NULL);                \
   63 } while(0)
   64 #define Dprintf3(s,a,b,c)                                               \
   65 do {                                                                    \
   66         if (rf_pssDebug)                                                \
rf_debug_printf(s,                                      \
   68                     (void *)((unsigned long)a),                         \
   69                     (void *)((unsigned long)b),                         \
   70                     (void *)((unsigned long)c),                         \
NULL, NULL, NULL, NULL, NULL);                      \
   72 } while(0)
   74 void rf_RealPrintPSStatusTable(RF_Raid_t *, RF_PSStatusHeader_t *);
   76 #define RF_MAX_FREE_PSS         32
   77 #define RF_PSS_INC               8
   78 #define RF_PSS_INITIAL           4
   80 int  rf_init_pss(RF_ReconParityStripeStatus_t *, RF_Raid_t *);
   81 void rf_clean_pss(RF_ReconParityStripeStatus_t *, RF_Raid_t *);
   82 void rf_ShutdownPSStatus(void *);
   84 int
rf_init_pss(RF_ReconParityStripeStatus_t *p, RF_Raid_t *raidPtr)
   86 {
RF_Calloc(p->issued, raidPtr->numCol, sizeof(char), (char *));
   88         if (p->issued == NULL)
   89                 return (ENOMEM);
   90         return (0);
   91 }
   93 void
rf_clean_pss(RF_ReconParityStripeStatus_t *p, RF_Raid_t *raidPtr)
   95 {
RF_Free(p->issued, raidPtr->numCol * sizeof(char));
   97 }
   99 void
rf_ShutdownPSStatus(void *arg)
  101 {
RF_Raid_t *raidPtr = (RF_Raid_t *) arg;
RF_FREELIST_DESTROY_CLEAN_ARG(raidPtr->pss_freelist, next,
  105             (RF_ReconParityStripeStatus_t *), rf_clean_pss, raidPtr);
  106 }
  108 int
rf_ConfigurePSStatus(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
RF_Config_t *cfgPtr)
  111 {
  112         int rc;
raidPtr->pssTableSize = RF_PSS_DEFAULT_TABLESIZE;
RF_FREELIST_CREATE(raidPtr->pss_freelist, RF_MAX_FREE_PSS, RF_PSS_INC,
  116             sizeof(RF_ReconParityStripeStatus_t));
  117         if (raidPtr->pss_freelist == NULL)
  118                 return (ENOMEM);
rc = rf_ShutdownCreate(listp, rf_ShutdownPSStatus, raidPtr);
  120         if (rc) {
RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
  122                              " rc=%d.\n", __FILE__, __LINE__, rc);
rf_ShutdownPSStatus(raidPtr);
  124                 return (rc);
  125         }
RF_FREELIST_PRIME_INIT_ARG(raidPtr->pss_freelist, RF_PSS_INITIAL, next,
  127             (RF_ReconParityStripeStatus_t *), rf_init_pss, raidPtr);
  128         return (0);
  129 }
  132 /*****************************************************************************
  133  * Sets up the pss table.
  134  * We pre-allocate a bunch of entries to avoid as much as possible having to
  135  * malloc up hash chain entries.
  136  *****************************************************************************/
RF_PSStatusHeader_t *
rf_MakeParityStripeStatusTable(RF_Raid_t *raidPtr)
  139 {
RF_PSStatusHeader_t *pssTable;
  141         int i, j, rc;
RF_Calloc(pssTable, raidPtr->pssTableSize, sizeof(RF_PSStatusHeader_t),
  144             (RF_PSStatusHeader_t *));
  145         for (i = 0; i < raidPtr->pssTableSize; i++) {
rc = rf_mutex_init(&pssTable[i].mutex);
  147                 if (rc) {
RF_ERRORMSG3("Unable to init mutex file %s line %d"
  149                                      " rc=%d.\n", __FILE__, __LINE__, rc);
  150                         /* Fail and deallocate. */
  151                         for (j = 0; j < i; j++) {
rf_mutex_destroy(&pssTable[i].mutex);
  153                         }
RF_Free(pssTable, raidPtr->pssTableSize *
  155                             sizeof(RF_PSStatusHeader_t));
  156                         return (NULL);
  157                 }
  158         }
  159         return (pssTable);
  160 }
  162 void
rf_FreeParityStripeStatusTable(RF_Raid_t *raidPtr,
RF_PSStatusHeader_t *pssTable)
  165 {
  166         int i;
  168         if (rf_pssDebug)
rf_RealPrintPSStatusTable(raidPtr, pssTable);
  170         for (i = 0; i < raidPtr->pssTableSize; i++) {
  171                 if (pssTable[i].chain) {
printf("ERROR: pss hash chain not null at recon"
  173                                " shutdown.\n");
  174                 }
rf_mutex_destroy(&pssTable[i].mutex);
  176         }
RF_Free(pssTable, raidPtr->pssTableSize * sizeof(RF_PSStatusHeader_t));
  178 }
  181 /*
  182  * Looks up the status structure for a parity stripe.
  183  * If the create_flag is on, returns the status structure, creating it if
  184  * it doesn't exist. Otherwise returns NULL if the status structure does
  185  * not exist already.
  186  *
  187  * The flags tell whether or not to create it if it doesn't exist + what
  188  * flags to set initially.
  189  *
  190  * ASSUMES THE PSS DESCRIPTOR IS LOCKED UPON ENTRY.
  191  */
RF_ReconParityStripeStatus_t *
rf_LookupRUStatus(RF_Raid_t *raidPtr, RF_PSStatusHeader_t *pssTable,
RF_StripeNum_t psID, RF_ReconUnitNum_t which_ru, RF_PSSFlags_t flags,
  195     int *created)
  196 {
RF_PSStatusHeader_t *hdr = &pssTable[RF_HASH_PSID(raidPtr, psID)];
RF_ReconParityStripeStatus_t *p, *pssPtr = hdr->chain;
  200         *created = 0;
  201         for (p = pssPtr; p; p = p->next) {
  202                 if (p->parityStripeID == psID && p->which_ru == which_ru)
  203                         break;
  204         }
  206         if (!p && (flags & RF_PSS_CREATE)) {
Dprintf2("PSS: creating pss for psid %ld ru %d.\n",
psID, which_ru);
p = rf_AllocPSStatus(raidPtr);
p->next = hdr->chain;
hdr->chain = p;
p->parityStripeID = psID;
p->which_ru = which_ru;
p->flags = flags;
p->rbuf = NULL;
p->writeRbuf = NULL;
p->xorBufCount = 0;
p->blockCount = 0;
p->procWaitList = NULL;
p->blockWaitList = NULL;
p->bufWaitList = NULL;
  223                 *created = 1;
  224         } else
  225                 if (p) {
  226                         /*
  227                          * We didn't create, but we want to specify
  228                          * some new status.
  229                          */
p->flags |= flags;      /*
  231                                                  * Add in whatever flags we're
  232                                                  * specifying.
  233                                                  */
  234                 }
  235         if (p && (flags & RF_PSS_RECON_BLOCKED)) {
  236                 /* If we're asking to block recon, bump the count. */
p->blockCount++;
Dprintf3("raid%d: Blocked recon on psid %ld. count now %d.\n",
raidPtr->raidid, psID, p->blockCount);
  240         }
  241         return (p);
  242 }
  245 /*
  246  * Deletes an entry from the parity stripe status table. Typically used
  247  * when an entry has been allocated solely to block reconstruction, and
  248  * no recon was requested while recon was blocked. Assumes the hash
  249  * chain is ALREADY LOCKED.
  250  */
  251 void
rf_PSStatusDelete(RF_Raid_t *raidPtr, RF_PSStatusHeader_t *pssTable,
RF_ReconParityStripeStatus_t *pssPtr)
  254 {
RF_PSStatusHeader_t *hdr =
  256             &(pssTable[RF_HASH_PSID(raidPtr, pssPtr->parityStripeID)]);
RF_ReconParityStripeStatus_t *p = hdr->chain, *pt = NULL;
  259         while (p) {
  260                 if (p == pssPtr) {
  261                         if (pt)
pt->next = p->next;
  263                         else
hdr->chain = p->next;
p->next = NULL;
rf_FreePSStatus(raidPtr, p);
  267                         return;
  268                 }
pt = p;
p = p->next;
  271         }
RF_ASSERT(0);           /* We must find it here. */
  273 }
  276 /*
  277  * Deletes an entry from the ps status table after reconstruction has
  278  * completed.
  279  */
  280 void
rf_RemoveFromActiveReconTable(RF_Raid_t *raidPtr, RF_RowCol_t row,
RF_StripeNum_t psid, RF_ReconUnitNum_t which_ru)
  283 {
RF_PSStatusHeader_t *hdr =
  285             &(raidPtr->reconControl[row]
  286              ->pssTable[RF_HASH_PSID(raidPtr, psid)]);
RF_ReconParityStripeStatus_t *p, *pt;
RF_CallbackDesc_t *cb, *cb1;
RF_LOCK_MUTEX(hdr->mutex);
  291         for (pt = NULL, p = hdr->chain; p; pt = p, p = p->next) {
  292                 if ((p->parityStripeID == psid) && (p->which_ru == which_ru))
  293                         break;
  294         }
  295         if (p == NULL) {
rf_PrintPSStatusTable(raidPtr, row);
  297         }
RF_ASSERT(p);           /* It must be there. */
Dprintf2("PSS: deleting pss for psid %ld ru %d.\n", psid, which_ru);
  302         /* Delete this entry from the hash chain. */
  303         if (pt)
pt->next = p->next;
  305         else
hdr->chain = p->next;
p->next = NULL;
RF_UNLOCK_MUTEX(hdr->mutex);
  311         /* Wake-up anyone waiting on the parity stripe ID. */
cb = p->procWaitList;
p->procWaitList = NULL;
  314         while (cb) {
Dprintf1("Waking up access waiting on parity stripe ID %ld.\n",
p->parityStripeID);
cb1 = cb->next;
  318                 (cb->callbackFunc) (cb->callbackArg);
  320                 /*
  321                  * THIS IS WHAT THE ORIGINAL CODE HAD... the extra 0 is bogus,
  322                  * IMHO.
  323                  */
  324                 /* (cb->callbackFunc)(cb->callbackArg, 0); */
rf_FreeCallbackDesc(cb);
cb = cb1;
  327         }
rf_FreePSStatus(raidPtr, p);
  330 }
RF_ReconParityStripeStatus_t *
rf_AllocPSStatus(RF_Raid_t *raidPtr)
  334 {
RF_ReconParityStripeStatus_t *p;
RF_FREELIST_GET_INIT_ARG(raidPtr->pss_freelist, p, next,
  338             (RF_ReconParityStripeStatus_t *), rf_init_pss, raidPtr);
  339         if (p) {
bzero(p->issued, raidPtr->numCol);
  341         }
p->next = NULL;
  343         /*
  344          * No need to initialize here b/c the only place we're called from is
  345          * the above Lookup.
  346          */
  347         return (p);
  348 }
  350 void
rf_FreePSStatus(RF_Raid_t *raidPtr, RF_ReconParityStripeStatus_t *p)
  352 {
RF_ASSERT(p->procWaitList == NULL);
RF_ASSERT(p->blockWaitList == NULL);
RF_ASSERT(p->bufWaitList == NULL);
RF_FREELIST_FREE_CLEAN_ARG(raidPtr->pss_freelist, p, next,
rf_clean_pss, raidPtr);
  359 }
  361 void
rf_RealPrintPSStatusTable(RF_Raid_t *raidPtr, RF_PSStatusHeader_t *pssTable)
  363 {
  364         int i, j, procsWaiting, blocksWaiting, bufsWaiting;
RF_ReconParityStripeStatus_t *p;
RF_CallbackDesc_t *cb;
printf("\nParity Stripe Status Table\n");
  369         for (i = 0; i < raidPtr->pssTableSize; i++) {
  370                 for (p = pssTable[i].chain; p; p = p->next) {
procsWaiting = blocksWaiting = bufsWaiting = 0;
  372                         for (cb = p->procWaitList; cb; cb = cb->next)
procsWaiting++;
  374                         for (cb = p->blockWaitList; cb; cb = cb->next)
blocksWaiting++;
  376                         for (cb = p->bufWaitList; cb; cb = cb->next)
bufsWaiting++;
printf("PSID %ld RU %d : blockCount %d %d/%d/%d"
  379                             " proc/block/buf waiting, issued ",
  380                             (long) p->parityStripeID, p->which_ru,
p->blockCount, procsWaiting, blocksWaiting,
bufsWaiting);
  383                         for (j = 0; j < raidPtr->numCol; j++)
printf("%c", (p->issued[j]) ? '1' : '0');
  385                         if (!p->flags)
printf(" flags: (none)");
  387                         else {
  388                                 if (p->flags & RF_PSS_UNDER_RECON)
printf(" under-recon");
  390                                 if (p->flags & RF_PSS_FORCED_ON_WRITE)
printf(" forced-w");
  392                                 if (p->flags & RF_PSS_FORCED_ON_READ)
printf(" forced-r");
  394                                 if (p->flags & RF_PSS_RECON_BLOCKED)
printf(" blocked");
  396                                 if (p->flags & RF_PSS_BUFFERWAIT)
printf(" bufwait");
  398                         }
printf("\n");
  400                 }
  401         }
  402 }
  404 void
rf_PrintPSStatusTable(RF_Raid_t *raidPtr, RF_RowCol_t row)
  406 {
RF_PSStatusHeader_t *pssTable = raidPtr->reconControl[row]->pssTable;
rf_RealPrintPSStatusTable(raidPtr, pssTable);
  409 }