![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / 286_KERNEL / USRSRC / io|
Return to rm.c CVS log | Up to [MW Coherent from dump] / coherent / d / 286_KERNEL / USRSRC / io |
1.1 ! root 1: /* ! 2: * Block or character device RAM disk driver. ! 3: * AT COHERENT (286 and 386). ! 4: */ ! 5: ! 6: #include <sys/coherent.h> ! 7: #include <sys/con.h> ! 8: #include <sys/buf.h> ! 9: #include <errno.h> ! 10: #include <sys/devices.h> ! 11: #include <sys/inode.h> ! 12: #include <sys/stat.h> ! 13: #include <sys/seg.h> ! 14: #include <sys/uproc.h> ! 15: ! 16: /* ! 17: * Minor number encoding: dsssssss ! 18: * d drive number (0 or 1) ! 19: * sssssss allocation size: 0 to free, 1-127 allocsize (n*ASIZE*BSIZE bytes) ! 20: */ ! 21: #define rm_drive(dev) (minor(dev) >> 7) ! 22: #define rm_asize(dev) (minor(dev) & 0x7F) ! 23: #define ASIZE 128 /* allocation chunk size in blocks (64KB) */ ! 24: #define NUM_RM 2 /* number of ram disks ! 25: - tied to dev encoding (see above) */ ! 26: ! 27: int nulldev(); ! 28: int nonedev(); ! 29: int rmload(); ! 30: int rmuload(); ! 31: int rmopen(); ! 32: int rmclose(); ! 33: int rmread(); ! 34: int rmwrite(); ! 35: int rmblock(); ! 36: ! 37: CON rmcon = { ! 38: DFBLK|DFCHR, ! 39: RM_MAJOR, ! 40: rmopen, /* Open */ ! 41: rmclose, /* Close */ ! 42: rmblock, /* Block */ ! 43: rmread, /* Read */ ! 44: rmwrite, /* Write */ ! 45: nonedev, ! 46: nulldev, ! 47: nulldev, ! 48: rmload, /* Load */ ! 49: rmuload /* Unload */ ! 50: }; ! 51: ! 52: typedef struct rm { ! 53: #ifndef COH386 ! 54: fsize_t rm_size; /* Size in allocation chunks */ ! 55: paddr_t rm_paddr; /* Physical base of ram disc segment */ ! 56: SEG *rm_segp; /* Segment pointer of ram device */ ! 57: #else ! 58: off_t rm_size; /* Size in allocation chunks */ ! 59: SR rm_sr; ! 60: #endif ! 61: BUF rm_buf; /* Static buffer for raw requests */ ! 62: int rm_nopen; /* Open count to avoid blowups */ ! 63: } RM; ! 64: static RM rm[NUM_RM]; ! 65: ! 66: /* ! 67: * Load. ! 68: */ ! 69: static ! 70: rmload() ! 71: { ! 72: } ! 73: ! 74: /* ! 75: * Unload. ! 76: * Release the allocated buffers. ! 77: */ ! 78: static ! 79: rmuload() ! 80: { ! 81: int i; ! 82: ! 83: for (i = 0; i < NUM_RM; i++){ ! 84: if (rm[i].rm_size != 0) { ! 85: #ifndef COH386 ! 86: sfree(rm[i].rm_segp); ! 87: #else ! 88: unload(&rm[i].rm_sr); ! 89: sfree(rm[i].rm_sr.sr_segp); ! 90: #endif ! 91: } ! 92: } ! 93: } ! 94: ! 95: /* ! 96: * Open. ! 97: * Allocate on the first call. ! 98: * Increment the open count. ! 99: */ ! 100: static ! 101: rmopen(dev, mode) dev_t dev; int mode; ! 102: { ! 103: register RM *rmp; ! 104: #ifndef COH386 ! 105: register fsize_t asize, osize; ! 106: register SEG *segp; ! 107: #else ! 108: register off_t asize, osize; ! 109: #endif ! 110: ! 111: rmp = &rm[rm_drive(dev)]; ! 112: asize = rm_asize(dev); ! 113: osize = rmp->rm_size; ! 114: ! 115: /* Fail on read before creation or bogus size. */ ! 116: if ((mode == IPR && osize == 0) ! 117: || (asize != 0 && osize != 0 && asize != osize) ! 118: || (asize == 0 && osize == 0)) { ! 119: u.u_error = ENXIO; ! 120: return; ! 121: } ! 122: ! 123: #ifdef COH386 ! 124: if (ASIZE*BSIZE*asize > ctob(RAMSIZE)) { ! 125: u.u_error = ENOMEM; ! 126: return; ! 127: } ! 128: #endif ! 129: ! 130: /* ! 131: * Allocate as required. ! 132: * Ignore case asize==0 && osize!=0, handled by rmclose(). ! 133: * If asize!=0 && asize==osize, just bump the open count. ! 134: */ ! 135: if (asize != 0 && osize == 0) { ! 136: #ifndef COH386 ! 137: segp = rmp->rm_segp = salloc((fsize_t)ASIZE*BSIZE*asize, ! 138: SFSYST|SFNSWP|SFNCLR|SFHIGH); ! 139: if (segp == NULL) { ! 140: #else ! 141: rmp->rm_sr.sr_segp = ! 142: salloc((off_t)ASIZE*BSIZE*asize, SFSYST|SFNSWP|SFNCLR); ! 143: if (rmp->rm_sr.sr_segp == NULL) { ! 144: #endif ! 145: u.u_error = ENOMEM; ! 146: return; ! 147: } ! 148: rmp->rm_size = asize; ! 149: #ifndef COH386 ! 150: rmp->rm_paddr = segp->s_paddr; ! 151: rmp->rm_nopen = 0; ! 152: pclear(rmp->rm_paddr, 1024L); /* clear 1st 2 blocks */ ! 153: #else ! 154: rmp->rm_sr.sr_base = rm_drive(dev)==0 ? ! 155: ctob(RAM0) : ctob(RAM1); ! 156: rmp->rm_sr.sr_size = rmp->rm_sr.sr_segp->s_size; ! 157: doload(&rmp->rm_sr); ! 158: #endif ! 159: } ! 160: rmp->rm_nopen++; ! 161: } ! 162: ! 163: /* ! 164: * Close. ! 165: * Decrement the open count. ! 166: * Release the allocated buffer if minor number is 0. ! 167: */ ! 168: static ! 169: rmclose(dev) dev_t dev; ! 170: { ! 171: register RM *rmp; ! 172: #ifndef COH386 ! 173: register fsize_t asize, osize; ! 174: #else ! 175: register off_t asize, osize; ! 176: #endif ! 177: ! 178: rmp = &rm[rm_drive(dev)]; ! 179: asize = rm_asize(dev); ! 180: osize = rmp->rm_size; ! 181: ! 182: if (osize == 0 ! 183: || (asize != 0 && asize != osize) ! 184: || rmp->rm_nopen == 0) { ! 185: u.u_error = ENXIO; ! 186: return; ! 187: } ! 188: rmp->rm_nopen--; ! 189: if (asize == 0) { ! 190: if (rmp->rm_nopen != 0) { ! 191: #ifndef COH386 ! 192: u.u_error = EDBUSY; ! 193: #else ! 194: u.u_error = EBUSY; ! 195: #endif ! 196: return; ! 197: } ! 198: #ifndef COH386 ! 199: sfree(rmp->rm_segp); ! 200: #else ! 201: unload(&rmp->rm_sr); ! 202: sfree(rmp->rm_sr.sr_segp); ! 203: #endif ! 204: rmp->rm_size = 0; ! 205: } ! 206: } ! 207: ! 208: static ! 209: rmblock(bp) register BUF *bp; ! 210: { ! 211: #ifndef COH386 ! 212: paddr_t base; ! 213: register fsize_t asize, osize; ! 214: #else ! 215: vaddr_t base; ! 216: register off_t asize, osize; ! 217: #endif ! 218: dev_t dev; ! 219: register RM *rmp; ! 220: ! 221: dev = bp->b_dev; ! 222: rmp = &rm[rm_drive(dev)]; ! 223: asize = rm_asize(dev); ! 224: osize = rmp->rm_size; ! 225: if (osize == 0 || asize != osize) { ! 226: bp->b_flag |= BFERR; ! 227: u.u_error = ENXIO; ! 228: /* ! 229: * Make sure last block requested is within range of device. ! 230: */ ! 231: } else if ((bp->b_bno + bp->b_count/BSIZE - 1) >= asize*ASIZE) { ! 232: bp->b_flag |= BFERR; ! 233: u.u_error = EIO; ! 234: } else { ! 235: #ifndef COH386 ! 236: base = rmp->rm_paddr + (paddr_t)bp->b_bno * BSIZE; ! 237: #else ! 238: base = rmp->rm_sr.sr_base + (paddr_t)bp->b_bno * BSIZE; ! 239: #endif ! 240: if (bp->b_req == BREAD) ! 241: #ifndef COH386 ! 242: plrcopy(base, bp->b_paddr, (fsize_t)bp->b_count); ! 243: #else ! 244: dmaout(bp->b_count, bp->b_paddr, base); ! 245: #endif ! 246: else ! 247: #ifndef COH386 ! 248: plrcopy(bp->b_paddr, base, (fsize_t)bp->b_count); ! 249: #else ! 250: dmaout(bp->b_count, bp->b_paddr, base); ! 251: #endif ! 252: } ! 253: bdone(bp); ! 254: } ! 255: ! 256: /* ! 257: * The read routine calls the common raw I/O processing code, ! 258: * using a static buffer header in the driver. ! 259: */ ! 260: static ! 261: rmread(dev, iop) register dev_t dev; IO *iop; ! 262: { ! 263: register BUF *bufp; ! 264: ! 265: bufp = &rm[rm_drive(dev)].rm_buf; ! 266: ioreq(bufp, iop, dev, BREAD, BFIOC|BFRAW); ! 267: } ! 268: ! 269: /* ! 270: * The write routine is just like the read routine, ! 271: * except that the function code is write instead of read. ! 272: */ ! 273: static ! 274: rmwrite(dev, iop) register dev_t dev; IO *iop; ! 275: { ! 276: register BUF *bufp; ! 277: ! 278: bufp = &rm[rm_drive(dev)].rm_buf; ! 279: ioreq(bufp, iop, dev, BWRITE, BFIOC|BFRAW); ! 280: } ! 281: ! 282: /* end of rm.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.