fsck_helper.c

   1 /* This module implements functions that allow a controlled access to vital
   2  * information of fsck.
   3  *
   4  * No function from this module returns if failure occurs.
   5  * When something wrong occurs, the function aborts the program, immediately.
   6  */
   7
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <errno.h>
  11 #include <stdbool.h>
  12 #include <stdlib.h>
  13 #include <assert.h>
  14
  15 #include "fsck_helper.h"
  16 #include "sofs09.h"
  17
  18 static void printError (int errcode, char *cmd_name)
  19 {
  20     fprintf(stderr, "%s: error #%d: %s\n", cmd_name, errcode,\
  21             strerror(errcode));
  22 }
  23 #define FABORT(err, fname) \
  24     {\
  25         printError(-(err), fname);\
  26         exit(EXIT_FAILURE);\
  27     }
  28
  29 /* Fetch current disc superblock.
  30  * If the superblock was not read, it is read from disk.
  31  * No changes to the superblock are monitored. It is assumed the superblock is
  32  * used as read-only.
  33  *
  34  * argument sb is the address of a pointer to a SOSuperBlock
  35  *
  36  * The address to the superblock is placed in (*sb).
  37  */
  38 void fetch_superblock(SOSuperBlock **sb)
  39 {
  40     assert((*sb) != NULL);
  41
  42     static SOSuperBlock localsb;
  43     static bool localsb_valid = 0;
  44     int fret;
  45
  46     if (localsb_valid == false) {
  47         fret = soReadRawBlock(0, &localsb);
  48         if (fret < 0) FABORT(fret, "fetch_superblock");
  49         localsb_valid = true;
  50     }
  51
  52     (*sb) = &localsb;
  53 }
  54
  55 /* Inode control table */
  56
  57 static ic_t *ictable;
  58 static bool ictable_valid = false;
  59 static uint32_t ictable_size = 0;
  60
  61 static void ictable_free(void)
  62 {
  63     assert(ictable_valid == true);
  64
  65     free(ictable);
  66     ictable_valid = false;
  67 }
  68
  69 static void ictable_create(void)
  70 {
  71     assert (ictable_valid == false);
  72
  73     int r;
  74     SOSuperBlock *sb;
  75     fetch_superblock(&sb);
  76
  77     ictable = malloc(sizeof(ic_t)*(sb->itotal));
  78     if (ictable == NULL) FABORT(errno, "ictable_init");
  79
  80     ictable_size = sb->itotal;
  81     for (r = 0; r < ictable_size; ++r) {
  82         ictable[r] = bah;
  83     }
  84
  85     ictable_valid = true;
  86
  87     atexit(ictable_free);
  88 }
  89
  90 void ictable_set(uint32_t index, ic_t value)
  91 {
  92     if (ictable_valid == false) ictable_create();
  93
  94     assert(ictable_valid == true);
  95     assert(index < ictable_size);
  96
  97     ictable[index] = value;
  98 }
  99
 100 void ictable_get(uint32_t index, ic_t *value)
 101 {
 102     assert(value != NULL);
 103
 104     if (ictable_valid == false) ictable_create();
 105
 106     assert(ictable_valid == true);
 107     assert(index < ictable_size);
 108
 109     (*value) = ictable[index];
 110 }
 111
 112 /* Cluster control table */
 113 static cc_t *cctable;
 114 static bool cctable_valid = false;
 115 static uint32_t cctable_size = 0;
 116
 117 static void cctable_free(void)
 118 {
 119     assert(cctable_valid == true);
 120
 121     free(cctable);
 122     cctable_valid = false;
 123 }
 124
 125 static void cctable_create(void)
 126 {
 127     assert (cctable_valid == false);
 128
 129     int r;
 130     SOSuperBlock *sb;
 131     fetch_superblock(&sb);
 132
 133     cctable = malloc(sizeof(cc_t)*(sb->dzone_size));
 134     if (cctable == NULL) FABORT(errno, "cctable_init");
 135
 136     ictable_size = sb->dzone_size;
 137     for (r = 0; r < cctable_size; ++r) {
 138         cctable[r] = bah;
 139     }
 140
 141     cctable_valid = true;
 142
 143     atexit(cctable_free);
 144 }
 145
 146 void cctable_set(uint32_t index, cc_t value)
 147 {
 148     if (cctable_valid == false) cctable_create();
 149
 150     assert(cctable_valid == true);
 151     assert(index < cctable_size);
 152
 153     cctable[index] = value;
 154 }
 155
 156 void cctable_get(uint32_t index, cc_t *value)
 157 {
 158     assert(value != NULL);
 159
 160     if (cctable_valid == false) cctable_create();
 161
 162     assert(cctable_valid == true);
 163     assert(index < cctable_size);
 164
 165     (*value) = cctable[index];
 166 }