rdsread.c File Reference

#include <xinu.h>

Include dependency graph for rdsread.c:

Go to the source code of this file.

Functions
devcall	rdsread (struct dentry *devptr, char *buff, int32 blk)

Function Documentation

rdsread()

devcall rdsread	(	struct dentry *	devptr,
		char *	buff,
		int32	blk
	)

Definition at line 9 of file rdsread.c.

References dentry::dvminor, getpid(), memcpy(), OK, rdbuff::rd_blknum, RD_BLKSIZ, rdbuff::rd_block, rdscblk::rd_chnext, rdscblk::rd_comproc, rdscblk::rd_comruns, rdscblk::rd_ctnext, rdscblk::rd_free, RD_INVALID, rdbuff::rd_next, rdbuff::rd_op, RD_OP_READ, RD_OP_WRITE, RD_OPEN, rdbuff::rd_pid, rdbuff::rd_prev, rdbuff::rd_refcnt, rdscblk::rd_reqsem, rdscblk::rd_rhnext, rdscblk::rd_rtprev, rdscblk::rd_state, rdbuff::rd_status, rdsbufalloc(), rdstab, receive(), recvclr(), resume(), signal(), SYSERR, and TRUE.

{
    struct  rdscblk *rdptr;     /* Pointer to control block */
    struct  rdbuff  *bptr;      /* Pointer to buffer possibly   */
                    /*   in the request list    */
    struct  rdbuff  *nptr;      /* Pointer to "next" node on a  */
                    /*   list           */
    struct  rdbuff  *pptr;      /* Pointer to "previous" node   */
                    /*   on a list          */
    struct  rdbuff  *cptr;      /* Pointer that walks the cache */

    /* If device not currently in use, report an error */

    rdptr = &rdstab[devptr->dvminor];
    if (rdptr->rd_state != RD_OPEN) {
        return SYSERR;
    }

    /* Ensure rdsprocess is runnning */

    if ( ! rdptr->rd_comruns ) {
        rdptr->rd_comruns = TRUE;
        resume(rdptr->rd_comproc);
    }

    /* Search the cache for specified block */

    bptr = rdptr->rd_chnext;
    while (bptr != (struct rdbuff *)&rdptr->rd_ctnext) {
        if (bptr->rd_blknum == blk) {
            if (bptr->rd_status == RD_INVALID) {
                break;
            }
            memcpy(buff, bptr->rd_block, RD_BLKSIZ);
            return OK;
        }
        bptr = bptr->rd_next;
    }

    /* Search the request list for most recent occurrence of block */

    bptr = rdptr->rd_rtprev;  /* Start at tail of list */

    while (bptr != (struct rdbuff *)&rdptr->rd_rhnext) {
        if (bptr->rd_blknum == blk)  {

        /* If most recent request for block is write, copy data */

        if (bptr->rd_op == RD_OP_WRITE) {
            memcpy(buff, bptr->rd_block, RD_BLKSIZ);
            return OK;
        }
        break;
        }
        bptr = bptr->rd_prev;
    }

    /* Allocate a buffer and add read request to tail of req. queue */

    bptr = rdsbufalloc(rdptr);  
    bptr->rd_op = RD_OP_READ;
    bptr->rd_refcnt = 1;
    bptr->rd_blknum = blk;
    bptr->rd_status = RD_INVALID;
    bptr->rd_pid = getpid();

    /* Insert new request into list just before tail */

    pptr = rdptr->rd_rtprev;
    rdptr->rd_rtprev = bptr;
    bptr->rd_next = pptr->rd_next;
    bptr->rd_prev = pptr;
    pptr->rd_next = bptr;

    /* Prepare to receive message when read completes */

    recvclr();

    /* Signal the semaphore to start communication */

    signal(rdptr->rd_reqsem);

    /* Block to wait for a message */

    bptr = (struct rdbuff *)receive();
    if (bptr == (struct rdbuff *)SYSERR) {  
        return SYSERR;
    }
    memcpy(buff, bptr->rd_block, RD_BLKSIZ);
    bptr->rd_refcnt--;
    if (bptr->rd_refcnt <= 0) {

        /* Look for previous item in cache with the same block  */
        /*    number to see if this item was only being kept    */
        /*    until pending read completed          */
                
        cptr = rdptr->rd_chnext;
        while (cptr != bptr) {
            if (cptr->rd_blknum == blk) {

                /* Unlink from cache */

                pptr = bptr->rd_prev;
                nptr = bptr->rd_next;
                pptr->rd_next = nptr;
                nptr->rd_prev = pptr;

                /* Add to the free list */

                bptr->rd_next = rdptr->rd_free;
                rdptr->rd_free = bptr;
                break;
            }
            cptr = cptr->rd_next;
        }
    }
    return OK;
}

Here is the call graph for this function: