![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to discbuf.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 / bin / dump|
Return to discbuf.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / dump |
1.1 root 1: /*
2: * This file contains a
3: * mini disc buffer cache manager.
4: */
5: #include <stdio.h>
6: #include <discbuf.h>
7:
8: DISCBUF *dblist;
9: FILE *dbfp;
10:
11: /*
12: * Claim a buffer and
13: * read block `block' into it.
14: * Return a pointer to the
15: * buffer.
16: */
17: DISCBUF *
18: dbread(block)
19: long block;
20: {
21: register DISCBUF *dbp;
22:
23: dbp = dbgrab(block);
24: if ((dbp->db_flag&DB_OK) == 0) {
25: lseek(fileno(dbfp), BUFSIZ*dbp->db_block, 0);
26: if (read(fileno(dbfp), dbp->db_data, BUFSIZ) != BUFSIZ)
27: dbfatal("cache read error, block %ld", block);
28: dbp->db_flag |= DB_OK;
29: }
30: return (dbp);
31: }
32:
33: /*
34: * This routine grabs a buffer
35: * and declares it to be the contents
36: * of block `block'.
37: * The data in the block is set to
38: * all zeros.
39: */
40: DISCBUF *
41: dbzero(block)
42: long block;
43: {
44: register DISCBUF *dbp;
45: register char *p;
46: register n;
47:
48: dbp = dbgrab(block);
49: dbp->db_flag = DB_OK;
50: p = dbp->db_data;
51: n = BUFSIZ;
52: do {
53: *p++ = 0;
54: } while (--n);
55: return (dbp);
56: }
57:
58: /*
59: * Buffer grab.
60: * Try to find a buffer that
61: * has the block in it.
62: * If not, use the oldest free
63: * buffer.
64: */
65: DISCBUF *
66: dbgrab(block)
67: long block;
68: {
69: register DISCBUF *dbp1, *dbp2;
70: register DISCBUF *fbp1, *fbp2;
71:
72: dbp1 = fbp1 = fbp2 = NULL;
73: dbp2 = dblist;
74: while (dbp2!=NULL && dbp2->db_block!=block) {
75: if (dbp2->db_refc == 0) {
76: fbp1 = dbp1;
77: fbp2 = dbp2;
78: }
79: dbp1 = dbp2;
80: dbp2 = dbp2->db_fp;
81: }
82: if (dbp2 == NULL) {
83: if (fbp2 == NULL)
84: dbfatal("cache full");
85: dbp1 = fbp1;
86: dbp2 = fbp2;
87: if ((dbp2->db_flag&DB_DIRT) != 0)
88: dbwrite(dbp2);
89: dbp2->db_flag = 0;
90: dbp2->db_block = block;
91: }
92: ++dbp2->db_refc;
93: if (dbp1 != NULL) {
94: dbp1->db_fp = dbp2->db_fp;
95: dbp2->db_fp = dblist;
96: dblist = dbp2;
97: }
98: return (dbp2);
99: }
100:
101: /*
102: * Flush the buffer cache. All
103: * dirty buffers get written out to
104: * the disc.
105: * If `flag' is true the buffer
106: * cache is released.
107: */
108: dbflush(flag)
109: {
110: register DISCBUF *dbp;
111: register DISCBUF *fbp;
112:
113: dbp = dblist;
114: while (dbp != NULL) {
115: if ((dbp->db_flag&(DB_OK|DB_DIRT)) == (DB_OK|DB_DIRT))
116: dbwrite(dbp);
117: if (flag) {
118: fbp = dbp;
119: dbp = dbp->db_fp;
120: free((char *) fbp);
121: } else {
122: dbp->db_flag = 0;
123: dbp->db_refc = 0;
124: dbp = dbp->db_fp;
125: }
126: }
127: if (flag)
128: dblist = NULL;
129: }
130:
131: /*
132: * Allocate a buffer cache.
133: * The argument `nbuf' is the number
134: * of buffers to claim.
135: */
136: dbclaim(nbuf)
137: {
138: register DISCBUF *dbp;
139:
140: if (dblist != NULL)
141: dbfatal("already claimed");
142: while (nbuf--) {
143: if ((dbp = (DISCBUF *) malloc(sizeof(DISCBUF))) == NULL)
144: dbfatal("no memory");
145: dbp->db_flag = 0;
146: dbp->db_refc = 0;
147: dbp->db_fp = dblist;
148: dblist = dbp;
149: }
150: }
151:
152: /*
153: * Write a buffer to the disc.
154: */
155: dbwrite(dbp)
156: register DISCBUF *dbp;
157: {
158: lseek(fileno(dbfp), BUFSIZ*dbp->db_block, 0);
159: if (write(fileno(dbfp), dbp->db_data, BUFSIZ) != BUFSIZ)
160: dbfatal("cache write error, block %ld", dbp->db_block);
161: }
162:
163: /*
164: * Release a buffer.
165: * The reference count is updated
166: */
167: dbfree(dbp, flag)
168: register DISCBUF *dbp;
169: {
170: dbp->db_flag |= flag;
171: if (--dbp->db_refc < 0)
172: dbfatal("refc < 0");
173: }
174:
175: /*
176: * Fatal errors.
177: */
178: dbfatal(a)
179: {
180: fprintf(stderr, "discbuf: %r\n", &a);
181: exit(1);
182: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.