geekos/src/geekos/blockdev.c

   1 /*
   2  * Block devices
   3  * Copyright (c) 2003 David H. Hovemeyer <daveho@cs.umd.edu>
   4  * $Revision: 1.1 $
   5  *
   6  * This is free software.  You are permitted to use,
   7  * redistribute, and modify it as specified in the file "COPYING".
   8  */
   9
  10 #include <geekos/errno.h>
  11 #include <geekos/screen.h>
  12 #include <geekos/string.h>
  13 #include <geekos/malloc.h>
  14 #include <geekos/int.h>
  15 #include <geekos/kthread.h>
  16 #include <geekos/synch.h>
  17 #include <geekos/blockdev.h>
  18
  19 /*#define BLOCKDEV_DEBUG */
  20 #ifdef BLOCKDEV_DEBUG
  21 #  define Debug(args...) Print(args)
  22 #else
  23 #  define Debug(args...)
  24 #endif
  25
  26 /* ----------------------------------------------------------------------
  27  * Private data and functions
  28  * ---------------------------------------------------------------------- */
  29
  30 /*
  31  * Lock protecting access/modification of block device list.
  32  */
  33 static struct Mutex s_blockdevLock;
  34
  35 /*
  36  * List datatype for list of block devices.
  37  */
  38 DEFINE_LIST(Block_Device_List, Block_Device);
  39 IMPLEMENT_LIST(Block_Device_List, Block_Device);
  40
  41 /*
  42  * The list in which all block devices in the system
  43  * are registered.
  44  */
  45 static struct Block_Device_List s_deviceList;
  46
  47 /*
  48  * Perform a block IO request.
  49  * Returns 0 if successful, error code on failure.
  50  */
  51 static int Do_Request(struct Block_Device *dev, enum Request_Type type, int blockNum, void *buf)
  52 {
  53     struct Block_Request *request;
  54     int rc;
  55
  56     request = Create_Request(dev, type, blockNum, buf);
  57     if (request == 0)
  58         return ENOMEM;
  59     Post_Request_And_Wait(request);
  60     rc = request->errorCode;
  61     Free(request);
  62     return rc;
  63 }
  64
  65 /* ----------------------------------------------------------------------
  66  * Public functions
  67  * ---------------------------------------------------------------------- */
  68
  69 /*
  70  * Register a block device.
  71  * This should be called by device drivers in their Init
  72  * functions to register all detected devices.
  73  * Returns 0 if successful, error code otherwise.
  74  */
  75 int Register_Block_Device(const char *name, struct Block_Device_Ops *ops,
  76     int unit, void *driverData, struct Thread_Queue *waitQueue,
  77     struct Block_Request_List *requestQueue)
  78 {
  79     struct Block_Device *dev;
  80
  81     KASSERT(ops != 0);
  82     KASSERT(waitQueue != 0);
  83     KASSERT(requestQueue != 0);
  84
  85     dev = (struct Block_Device*) Malloc(sizeof(*dev));
  86     if (dev == 0)
  87         return ENOMEM;
  88
  89     strcpy(dev->name, name);
  90     dev->ops = ops;
  91     dev->unit = unit;
  92     dev->inUse = false;
  93     dev->driverData = driverData;
  94     dev->waitQueue = waitQueue;
  95     dev->requestQueue = requestQueue;
  96
  97     Mutex_Lock(&s_blockdevLock);
  98     /* FIXME: handle name conflict with existing device */
  99     Debug("Registering block device %s\n", dev->name);
 100     Add_To_Back_Of_Block_Device_List(&s_deviceList, dev);
 101     Mutex_Unlock(&s_blockdevLock);
 102
 103     return 0;
 104 }
 105
 106 /*
 107  * Open a named block device.
 108  * Return 0 if successful, error code on error.
 109  */
 110 int Open_Block_Device(const char *name, struct Block_Device **pDev)
 111 {
 112     struct Block_Device *dev;
 113     int rc = 0;
 114
 115     Mutex_Lock(&s_blockdevLock);
 116
 117     dev = Get_Front_Of_Block_Device_List(&s_deviceList);
 118     while (dev != 0) {
 119         if (strcmp(dev->name, name) == 0)
 120             break;
 121         dev = Get_Next_In_Block_Device_List(dev);
 122     }
 123
 124     if (dev == 0)
 125         rc = ENODEV;
 126     else if (dev->inUse)
 127         rc = EBUSY;
 128     else {
 129         rc = dev->ops->Open(dev);
 130         if (rc == 0) {
 131             *pDev = dev;
 132             dev->inUse = true;
 133         }
 134     }
 135
 136     Mutex_Unlock(&s_blockdevLock);
 137
 138     return rc;
 139 }
 140
 141 /*
 142  * Close given block device.
 143  * Return 0 if successful, error code on error.
 144  */
 145 int Close_Block_Device(struct Block_Device *dev)
 146 {
 147     int rc;
 148
 149     Mutex_Lock(&s_blockdevLock);
 150
 151     KASSERT(dev->inUse);
 152     rc = dev->ops->Close(dev);
 153     if (rc == 0)
 154         dev->inUse = false;
 155
 156     Mutex_Unlock(&s_blockdevLock);
 157
 158     return rc;
 159 }
 160
 161 /*
 162  * Create a block device request to transfer a single block.
 163  */
 164 struct Block_Request *Create_Request(struct Block_Device *dev, enum Request_Type type,
 165     int blockNum, void *buf)
 166 {
 167     struct Block_Request *request = Malloc(sizeof(*request));
 168     if (request != 0) {
 169         request->dev = dev;
 170         request->type = type;
 171         request->blockNum = blockNum;
 172         request->buf = buf;
 173         request->state = PENDING;
 174         Clear_Thread_Queue(&request->waitQueue);
 175     }
 176     return request;
 177 }
 178
 179 /*
 180  * Send a block IO request to a device and wait for it to be handled.
 181  * Returns when the driver completes the requests or signals
 182  * an error.
 183  */
 184 void Post_Request_And_Wait(struct Block_Request *request)
 185 {
 186     struct Block_Device *dev;
 187
 188     KASSERT(request != 0);
 189
 190     dev = request->dev;
 191     KASSERT(dev != 0);
 192
 193     /* Send request to the driver */
 194     Debug("Posting block device request [@%x]...\n", request);
 195     Disable_Interrupts();
 196     Add_To_Back_Of_Block_Request_List(dev->requestQueue, request);
 197     Wake_Up(dev->waitQueue);
 198     Enable_Interrupts();
 199
 200     /* Wait for request to be processed */
 201     Disable_Interrupts();
 202     while (request->state == PENDING) {
 203         Debug("Waiting, state=%d\n", request->state);
 204         Wait(&request->waitQueue);
 205     }
 206     Debug("Wait completed!\n");
 207     Enable_Interrupts();
 208 }
 209
 210 /*
 211  * Wait for a block request to arrive.
 212  */
 213 struct Block_Request *Dequeue_Request(struct Block_Request_List *requestQueue,
 214     struct Thread_Queue *waitQueue)
 215 {
 216     struct Block_Request *request;
 217
 218     Disable_Interrupts();
 219     while (Is_Block_Request_List_Empty(requestQueue))
 220         Wait(waitQueue);
 221     request = Get_Front_Of_Block_Request_List(requestQueue);
 222     Remove_From_Front_Of_Block_Request_List(requestQueue);
 223     Enable_Interrupts();
 224
 225     return request;
 226 }
 227
 228 /*
 229  * Signal the completion of a block request.
 230  */
 231 void Notify_Request_Completion(struct Block_Request *request, enum Request_State state, int errorCode)
 232 {
 233     Disable_Interrupts();
 234     request->state = state;
 235     request->errorCode = errorCode;
 236     Wake_Up(&request->waitQueue);
 237     Enable_Interrupts();
 238 }
 239
 240 /*
 241  * Read a block from given device.
 242  * Return 0 if successful, error code on error.
 243  */
 244 int Block_Read(struct Block_Device *dev, int blockNum, void *buf)
 245 {
 246     return Do_Request(dev, BLOCK_READ, blockNum, buf);
 247 }
 248
 249 /*
 250  * Write a block to given device.
 251  * Return 0 if successful, error code on error.
 252  */
 253 int Block_Write(struct Block_Device *dev, int blockNum, void *buf)
 254 {
 255     return Do_Request(dev, BLOCK_WRITE, blockNum, buf);
 256 }
 257
 258 /*
 259  * Get number of blocks in given device.
 260  */
 261 int Get_Num_Blocks(struct Block_Device *dev)
 262 {
 263     return dev->ops->Get_Num_Blocks(dev);
 264 }
 265