---

synchdisk.cc

Go to the documentation of this file.

// synchdisk.cc 
//      Routines to synchronously access the disk.  The physical disk 
//      is an asynchronous device (disk requests return immediately, and
//      an interrupt happens later on).  This is a layer on top of
//      the disk providing a synchronous interface (requests wait until
//      the request completes).
//
//      Use a semaphore to synchronize the interrupt handlers with the
//      pending requests.  And, because the physical disk can only
//      handle one operation at a time, use a lock to enforce mutual
//      exclusion.
//
// Copyright (c) 1992-1993 The Regents of the University of California.
// All rights reserved.  See copyright.h for copyright notice and limitation 
// of liability and disclaimer of warranty provisions.

#include "copyright.h"
#include "synchdisk.h"

//----------------------------------------------------------------------
// DiskRequestDone
//      Disk interrupt handler.  Need this to be a C routine, because 
//      C++ can't handle pointers to member functions.
//----------------------------------------------------------------------

static void
DiskRequestDone (int arg)
{
    SynchDisk* disk1 = (SynchDisk *)arg;

    disk1->RequestDone();
}

//----------------------------------------------------------------------
// SynchDisk::SynchDisk
//      Initialize the synchronous interface to the physical disk, in turn
//      initializing the physical disk.
//
//      "name" -- UNIX file name to be used as storage for the disk data
//         (usually, "DISK")
//----------------------------------------------------------------------

SynchDisk::SynchDisk(char* name)
{
    semaphore = new Semaphore("synch disk", 0);
    lock = new Lock("synch disk lock");
    disk = new Disk(name, DiskRequestDone, (int) this);
}

//----------------------------------------------------------------------
// SynchDisk::~SynchDisk
//      De-allocate data structures needed for the synchronous disk
//      abstraction.
//----------------------------------------------------------------------

SynchDisk::~SynchDisk()
{
    delete disk;
    delete lock;
    delete semaphore;
}

//----------------------------------------------------------------------
// SynchDisk::ReadSector
//      Read the contents of a disk sector into a buffer.  Return only
//      after the data has been read.
//
//      "sectorNumber" -- the disk sector to read
//      "data" -- the buffer to hold the contents of the disk sector
//----------------------------------------------------------------------

void
SynchDisk::ReadSector(int sectorNumber, char* data)
{
    lock->Acquire();                    // only one disk I/O at a time
    disk->ReadRequest(sectorNumber, data);
    semaphore->P();                     // wait for interrupt
    lock->Release();
}

//----------------------------------------------------------------------
// SynchDisk::WriteSector
//      Write the contents of a buffer into a disk sector.  Return only
//      after the data has been written.
//
//      "sectorNumber" -- the disk sector to be written
//      "data" -- the new contents of the disk sector
//----------------------------------------------------------------------

void
SynchDisk::WriteSector(int sectorNumber, char* data)
{
    lock->Acquire();                    // only one disk I/O at a time
    disk->WriteRequest(sectorNumber, data);
    semaphore->P();                     // wait for interrupt
    lock->Release();
}

//----------------------------------------------------------------------
// SynchDisk::RequestDone
//      Disk interrupt handler.  Wake up any thread waiting for the disk
//      request to finish.
//----------------------------------------------------------------------

void
SynchDisk::RequestDone()
{ 
    semaphore->V();
}

---

The University of Southern California does not screen or control the content on this website and thus does not guarantee the accuracy, integrity, or quality of such content. All content on this website is provided by and is the sole responsibility of the person from which such content originated, and such content does not necessarily reflect the opinions of the University administration or the Board of Trustees