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