Return to dskqopt.c CVS log

Up to [XINU] / xinu / sys / LSI

Annotation of xinu/sys/LSI/dskqopt.c, revision 1.1.1.1

1.1       root        1: /* dskqopt.c - dskqopt */
                      2: 
                      3: #include <conf.h>
                      4: #include <kernel.h>
                      5: #include <disk.h>
                      6: 
                      7: /*------------------------------------------------------------------------
                      8:  *  dskqopt  --  optimize requests to read/write/seek to the same block
                      9:  *------------------------------------------------------------------------
                     10:  */
                     11: dskqopt(p, q, drptr)
                     12: struct dreq    *p, *q, *drptr;
                     13: {
                     14:        char    *to, *from;
                     15:        int     i;
                     16:        DBADDR  block;
                     17: 
                     18:        /* By definition, sync requests cannot be optimized.  Also,     */
                     19:        /* cannot optimize read requests if already reading.            */
                     20: 
                     21:        if (drptr->drop==DSYNC || (drptr->drop==DREAD && p->drop==DREAD))
                     22:                return(SYSERR);
                     23: 
                     24:        if (drptr->drop == DSEEK) {     /* ignore extraneous seeks      */
                     25:                freebuf(drptr);
                     26:                return(OK);
                     27:        }
                     28: 
                     29:        if (p->drop == DSEEK) {         /* replace existing seeks       */
                     30:                drptr->drnext = p->drnext;
                     31:                q->drnext = drptr;
                     32:                freebuf(p);
                     33:                return(OK);
                     34:        }
                     35: 
                     36:        if (p->drop==DWRITE && drptr->drop==DWRITE) {   /* dup write    */
                     37:                drptr->drnext = p->drnext;
                     38:                q->drnext = drptr;
                     39:                freebuf(p->drbuff);
                     40:                freebuf(p);
                     41:                return(OK);
                     42:        }
                     43: 
                     44:        if (drptr->drop==DREAD && p->drop==DWRITE) {    /* satisfy read */
                     45:                to = drptr->drbuff;
                     46:                from = p->drbuff;
                     47:                for (i=0 ; i<DBUFSIZ ; i++)
                     48:                        *to++ = *from++;
                     49:                return(OK);
                     50:        }
                     51: 
                     52:        if (drptr->drop==DWRITE && p->drop==DREAD) {    /* sat. old read*/
                     53:                block = drptr->drdba;
                     54:                from = drptr->drbuff;
                     55:                for (; p!=DRNULL && p->drdba==block ; p=p->drnext) {
                     56:                        q->drnext = p->drnext;
                     57:                        to = p->drbuff;
                     58:                        for (i=0 ; i<DBUFSIZ ; i++)
                     59:                                *to++ = *from++;
                     60:                        p->drstat = OK;
                     61:                        ready(p->drpid, RESCHNO);                       
                     62:                }
                     63:                drptr->drnext = p;
                     64:                q->drnext = drptr;
                     65:                resched();
                     66:                return(OK);
                     67:        }
                     68:        return(SYSERR);
                     69: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.