rdswrite.c File Reference

#include <xinu.h>

Include dependency graph for rdswrite.c:

Go to the source code of this file.

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

Function Documentation

rdswrite()

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

Definition at line 9 of file rdswrite.c.

References dentry::dvminor, FALSE, getpid(), memcpy(), OK, rdscblk::rd_availsem, rdbuff::rd_blknum, RD_BLKSIZ, rdbuff::rd_block, rdscblk::rd_chnext, rdscblk::rd_comproc, rdscblk::rd_comruns, rdscblk::rd_ctnext, rdbuff::rd_next, rdbuff::rd_op, RD_OP_WRITE, RD_OPEN, rdbuff::rd_pid, rdbuff::rd_prev, rdbuff::rd_refcnt, rdscblk::rd_reqsem, rdscblk::rd_rhnext, rdscblk::rd_rtnext, rdscblk::rd_rtprev, rdscblk::rd_state, rdbuff::rd_status, RD_VALID, rdsbufalloc(), rdstab, resume(), semcount(), semreset(), signal(), SYSERR, and TRUE.

{
    struct  rdscblk *rdptr;     /* Pointer to control block */
    struct  rdbuff  *bptr;      /* Pointer to buffer on a list  */
    struct  rdbuff  *pptr;      /* Ptr to previous buff on list */
    struct  rdbuff  *nptr;      /* Ptr to next buffer on list   */
    bool8   found;          /* Was buff found during search?*/

    /* 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);
    }

    /* If request queue already contains a write request */
    /*    for the block, replace the contents        */

    bptr = rdptr->rd_rhnext;
    while (bptr != (struct rdbuff *)&rdptr->rd_rtnext) {
        if ( (bptr->rd_blknum == blk) &&
            (bptr->rd_op == RD_OP_WRITE) ) {
            memcpy(bptr->rd_block, buff, RD_BLKSIZ);
            return OK;
        }
        bptr = bptr->rd_next;
    }

    /* Search cache for cached copy of block */

    bptr = rdptr->rd_chnext;
    found = FALSE;
    while (bptr != (struct rdbuff *)&rdptr->rd_ctnext) {
        if (bptr->rd_blknum == blk) {
            if (bptr->rd_refcnt <= 0) {
                pptr = bptr->rd_prev;
                nptr = bptr->rd_next;

                /* Unlink node from cache list and reset*/
                /*   the available semaphore accordingly*/

                pptr->rd_next = bptr->rd_next;
                nptr->rd_prev = bptr->rd_prev;
                semreset(rdptr->rd_availsem,
                    semcount(rdptr->rd_availsem) - 1);
                found = TRUE;
            }
            break;
        }
        bptr = bptr->rd_next;
    }

    if ( !found ) {
        bptr = rdsbufalloc(rdptr);
    }

    /* Create a write request */

    memcpy(bptr->rd_block, buff, RD_BLKSIZ);
    bptr->rd_op = RD_OP_WRITE;
    bptr->rd_refcnt = 0;
    bptr->rd_blknum = blk;
    bptr->rd_status = RD_VALID;
    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;

    /* Signal semaphore to start communication process */

    signal(rdptr->rd_reqsem);
    return OK;
}

Here is the call graph for this function: