Return to sw.c CVS log

Up to [Research Unix] / researchv10no / sys / io

Annotation of researchv10no/sys/io/sw.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * indirect driver for swapping
                      3:  */
                      4: 
                      5: #include "sys/param.h"
                      6: #include "sys/systm.h"
                      7: #include "sys/buf.h"
                      8: #include "sys/conf.h"
                      9: #include "sys/user.h"
                     10: #include "sys/inode.h"
                     11: #include "sys/map.h"
                     12: 
                     13: struct buf rswbuf;
                     14: extern struct map swapmap[];
                     15: extern int swmapcnt;
                     16: extern struct map argmap[];
                     17: extern int argcnt;
                     18: 
                     19: int swopen(), swstrategy(), swread(), swwrite();
                     20: 
                     21: struct bdevsw swbdev = bdinit(swopen, nulldev, swstrategy, 0);
                     22: 
                     23: struct cdevsw swcdev = cdinit(swopen, nulldev, swread, swwrite, nodev);
                     24: 
                     25: /*
                     26:  * presumably called for the first time on boot
                     27:  */
                     28: swopen(dev, flag)
                     29: dev_t dev;
                     30: int flag;
                     31: {
                     32:        static int opened;
                     33: 
                     34:        if (opened)
                     35:                return;
                     36:        opened++;
                     37:        swfree(0);
                     38: }
                     39: 
                     40: swstrategy(bp)
                     41:        register struct buf *bp;
                     42: {
                     43:        register clicks_t sz;
                     44:        register daddr_t off;
                     45:        register int seg;
                     46:        dev_t dev;
                     47: 
                     48:        sz = btoc(bp->b_bcount);
                     49:        off = bp->b_blkno % dmmax;
                     50:        seg = bp->b_blkno / dmmax;
                     51:        dev = swdevt[seg % nswdevt].sw_dev;
                     52:        if (bdevsw[major(dev)] == 0)
                     53:                panic("swstrategy");
                     54:        bp->b_blkno = seg / nswdevt;
                     55:        bp->b_blkno *= dmmax;
                     56:        bp->b_blkno += off;
                     57:        bp->b_dev = dev;
                     58:        if (bp->b_blkno+sz > swdevt[seg % nswdevt].sw_size
                     59:        ||  off+sz > dmmax) {
                     60:                bp->b_flags |= B_ERROR;
                     61:                iodone(bp);
                     62:                return;
                     63:        }
                     64:        (*bdevsw[major(dev)]->d_strategy)(bp);
                     65: }
                     66: 
                     67: swread(dev)
                     68: {
                     69: 
                     70:        physio(swstrategy, &rswbuf, dev, B_READ, minphys);
                     71: }
                     72: 
                     73: swwrite(dev)
                     74: {
                     75: 
                     76:        physio(swstrategy, &rswbuf, dev, B_WRITE, minphys);
                     77: }
                     78: 
                     79: /*
                     80:  * System call swapon(name) enables swapping on device name,
                     81:  * which must be in the swdevsw.  Return EBUSY
                     82:  * if already swapping on this device.
                     83:  * silly; this should just be an ioctl.
                     84:  *
                     85:  * -- assume swapping on a regular filesystem,
                     86:  * so directly calling thought bdevsw is what we want.
                     87:  * some day this will be unfortunate.
                     88:  */
                     89: vswapon()
                     90: {
                     91:        struct a {
                     92:                char *fname;
                     93:        };
                     94:        register struct inode *ip;
                     95:        dev_t dev;
                     96:        register int i;
                     97: 
                     98:        ip = namei(((struct a *)u.u_ap)->fname, SEGUDATA, &nilargnamei, 1);
                     99:        if (ip == NULL)
                    100:                return;
                    101:        if ((ip->i_mode&IFMT) != IFBLK || ip->i_fstyp != 0) {
                    102:                u.u_error = EINVAL;
                    103:                iput(ip);
                    104:                return;
                    105:        }
                    106:        dev = (dev_t)ip->i_un.i_rdev;
                    107:        iput(ip);
                    108:        for (i = 0; i < nswdevt; i++) {
                    109:                if (swdevt[i].sw_dev != dev)
                    110:                        continue;
                    111:                if (swdevt[i].sw_freed) {
                    112:                        u.u_error = EBUSY;
                    113:                        return;
                    114:                }
                    115:                swfree(i);
                    116:                return;
                    117:        }
                    118:        u.u_error = ENODEV;
                    119: }
                    120: 
                    121: /*
                    122:  * Swfree(index) frees the index'th portion of the swap map.
                    123:  * Each of the nswdevt devices provides 1/nswdev'th of the swap
                    124:  * space, which is laid out with blocks of dmmax pages circularly
                    125:  * among the devices.
                    126:  * rmalloc starts at 1, so give the first dmmax/2 pages of the first device
                    127:  * to the arg device.
                    128:  * quietly opens the device, with no trace in inode table
                    129:  * subsequently really opening and closing the device may cause trouble?
                    130:  */
                    131: swfree(index)
                    132:        register int index;
                    133: {
                    134:        register swblk_t bno;
                    135:        register int nblk;
                    136:        register int xsize;
                    137:        extern int argcnt, swmapcnt;
                    138: 
                    139:        bdevopen(swdevt[index].sw_dev);
                    140:        if (u.u_error)
                    141:                return;
                    142:        xsize = swdevt[index].sw_size * nswdevt;
                    143:        xsize += index * dmmax;
                    144:        xsize -= (nswdevt - 1) * (swdevt[index].sw_size % dmmax);
                    145:        for (bno = dmmax * index; bno < xsize; bno += dmmax * nswdevt) {
                    146:                nblk = xsize - bno;
                    147:                if (nblk > dmmax)
                    148:                        nblk = dmmax;
                    149:                if (bno)
                    150:                        rmfree(swapmap, nblk, (int)bno);
                    151:                else {
                    152:                        argdev = swdevt[0].sw_dev;
                    153:                        rminit(argmap, argcnt, nblk/2-CLSIZE, CLSIZE);
                    154:                        rminit(swapmap, swmapcnt, nblk/2, nblk/2);
                    155:                }
                    156:        }
                    157:        swdevt[index].sw_freed = 1;
                    158: }

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