irix kill efs and start pruning pre-65
[openafs.git] / src / afs / afs_memcache.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include "afs/param.h"
12
13
14 #include "afs/sysincludes.h"    /* Standard vendor system headers */
15 #ifndef AFS_LINUX22_ENV
16 #include "rpc/types.h"
17 #endif
18 #include "afsincludes.h"        /* Afs-based standard headers */
19 #include "afs/afs_stats.h"      /* statistics */
20
21 /* memory cache routines */
22 static struct memCacheEntry *memCache;
23 static int memCacheBlkSize = 8192;
24 static int memMaxBlkNumber = 0;
25
26 extern int cacheDiskType;
27
28 int
29 afs_InitMemCache(int blkCount, int blkSize, int flags)
30 {
31     int index;
32
33     AFS_STATCNT(afs_InitMemCache);
34     if (blkSize)
35         memCacheBlkSize = blkSize;
36
37     memMaxBlkNumber = blkCount;
38     memCache = (struct memCacheEntry *)
39         afs_osi_Alloc(memMaxBlkNumber * sizeof(struct memCacheEntry));
40
41     for (index = 0; index < memMaxBlkNumber; index++) {
42         char *blk;
43         (memCache + index)->size = 0;
44         (memCache + index)->dataSize = memCacheBlkSize;
45         LOCK_INIT(&((memCache + index)->afs_memLock), "afs_memLock");
46         blk = afs_osi_Alloc(memCacheBlkSize);
47         if (blk == NULL)
48             goto nomem;
49         (memCache + index)->data = blk;
50         memset((memCache + index)->data, 0, memCacheBlkSize);
51     }
52 #if defined(AFS_HAVE_VXFS)
53     afs_InitDualFSCacheOps((struct vnode *)0);
54 #endif
55
56     return 0;
57
58   nomem:
59     printf("afsd:  memCache allocation failure at %d KB.\n",
60            (index * memCacheBlkSize) / 1024);
61     while (--index >= 0) {
62         afs_osi_Free((memCache + index)->data, memCacheBlkSize);
63         (memCache + index)->data = NULL;
64     }
65     return ENOMEM;
66
67 }
68
69 int
70 afs_MemCacheClose(struct osi_file *file)
71 {
72     return 0;
73 }
74
75 void *
76 afs_MemCacheOpen(afs_dcache_id_t *ainode)
77 {
78     struct memCacheEntry *mep;
79
80     if (ainode->mem < 0 || ainode->mem > memMaxBlkNumber) {
81         osi_Panic("afs_MemCacheOpen: invalid block #");
82     }
83     mep = (memCache + ainode->mem);
84     afs_Trace3(afs_iclSetp, CM_TRACE_MEMOPEN, ICL_TYPE_INT32, ainode->mem,
85                ICL_TYPE_POINTER, mep, ICL_TYPE_POINTER, mep ? mep->data : 0);
86     return (void *)mep;
87 }
88
89 /*
90  * this routine simulates a read in the Memory Cache 
91  */
92 int
93 afs_MemReadBlk(register struct osi_file *fP, int offset, void *dest,
94                int size)
95 {
96     register struct memCacheEntry *mceP = (struct memCacheEntry *)fP;
97     int bytesRead;
98
99     ObtainReadLock(&mceP->afs_memLock);
100     AFS_STATCNT(afs_MemReadBlk);
101     if (offset < 0) {
102         ReleaseReadLock(&mceP->afs_memLock);
103         return 0;
104     }
105     /* use min of bytes in buffer or requested size */
106     bytesRead = (size < mceP->size - offset) ? size : mceP->size - offset;
107
108     if (bytesRead > 0) {
109         AFS_GUNLOCK();
110         memcpy(dest, mceP->data + offset, bytesRead);
111         AFS_GLOCK();
112     } else
113         bytesRead = 0;
114
115     ReleaseReadLock(&mceP->afs_memLock);
116     return bytesRead;
117 }
118
119 /*
120  * this routine simulates a readv in the Memory Cache 
121  */
122 int
123 afs_MemReadvBlk(register struct memCacheEntry *mceP, int offset,
124                 struct iovec *iov, int nio, int size)
125 {
126     int i;
127     int bytesRead;
128     int bytesToRead;
129
130     ObtainReadLock(&mceP->afs_memLock);
131     AFS_STATCNT(afs_MemReadBlk);
132     if (offset < 0) {
133         ReleaseReadLock(&mceP->afs_memLock);
134         return 0;
135     }
136     /* use min of bytes in buffer or requested size */
137     bytesRead = (size < mceP->size - offset) ? size : mceP->size - offset;
138
139     if (bytesRead > 0) {
140         for (i = 0, size = bytesRead; i < nio && size > 0; i++) {
141             bytesToRead = (size < iov[i].iov_len) ? size : iov[i].iov_len;
142             AFS_GUNLOCK();
143             memcpy(iov[i].iov_base, mceP->data + offset, bytesToRead);
144             AFS_GLOCK();
145             offset += bytesToRead;
146             size -= bytesToRead;
147         }
148         bytesRead -= size;
149     } else
150         bytesRead = 0;
151
152     ReleaseReadLock(&mceP->afs_memLock);
153     return bytesRead;
154 }
155
156 int
157 afs_MemReadUIO(afs_dcache_id_t *ainode, struct uio *uioP)
158 {
159     register struct memCacheEntry *mceP =
160         (struct memCacheEntry *)afs_MemCacheOpen(ainode);
161     int length = mceP->size - AFS_UIO_OFFSET(uioP);
162     afs_int32 code;
163
164     AFS_STATCNT(afs_MemReadUIO);
165     ObtainReadLock(&mceP->afs_memLock);
166     length = (length < AFS_UIO_RESID(uioP)) ? length : AFS_UIO_RESID(uioP);
167     AFS_UIOMOVE(mceP->data + AFS_UIO_OFFSET(uioP), length, UIO_READ, uioP, code);
168     ReleaseReadLock(&mceP->afs_memLock);
169     return code;
170 }
171
172 int
173 afs_MemWriteBlk(register struct osi_file *fP, int offset, void *src,
174                 int size)
175 {
176     register struct memCacheEntry *mceP = (struct memCacheEntry *)fP;
177     struct iovec tiov;
178
179     tiov.iov_base = src;
180     tiov.iov_len = size;
181     return afs_MemWritevBlk(mceP, offset, &tiov, 1, size);
182 }
183
184 /*XXX: this extends a block arbitrarily to support big directories */
185 int
186 afs_MemWritevBlk(register struct memCacheEntry *mceP, int offset,
187                  struct iovec *iov, int nio, int size)
188 {
189     int i;
190     int bytesWritten;
191     int bytesToWrite;
192     AFS_STATCNT(afs_MemWriteBlk);
193     ObtainWriteLock(&mceP->afs_memLock, 561);
194     if (offset + size > mceP->dataSize) {
195         char *oldData = mceP->data;
196
197         mceP->data = afs_osi_Alloc(size + offset);
198         if (mceP->data == NULL) {       /* no available memory */
199             mceP->data = oldData;       /* revert back change that was made */
200             ReleaseWriteLock(&mceP->afs_memLock);
201             afs_warn("afs: afs_MemWriteBlk mem alloc failure (%d bytes)\n",
202                      size + offset);
203             return -ENOMEM;
204         }
205
206         /* may overlap, but this is OK */
207         AFS_GUNLOCK();
208         memcpy(mceP->data, oldData, mceP->size);
209         AFS_GLOCK();
210         afs_osi_Free(oldData, mceP->dataSize);
211         mceP->dataSize = size + offset;
212     }
213     AFS_GUNLOCK();
214     if (mceP->size < offset)
215         memset(mceP->data + mceP->size, 0, offset - mceP->size);
216     for (bytesWritten = 0, i = 0; i < nio && size > 0; i++) {
217         bytesToWrite = (size < iov[i].iov_len) ? size : iov[i].iov_len;
218         memcpy(mceP->data + offset, iov[i].iov_base, bytesToWrite);
219         offset += bytesToWrite;
220         bytesWritten += bytesToWrite;
221         size -= bytesToWrite;
222     }
223     mceP->size = (offset < mceP->size) ? mceP->size : offset;
224     AFS_GLOCK();
225
226     ReleaseWriteLock(&mceP->afs_memLock);
227     return bytesWritten;
228 }
229
230 int
231 afs_MemWriteUIO(afs_dcache_id_t *ainode, struct uio *uioP)
232 {
233     register struct memCacheEntry *mceP =
234         (struct memCacheEntry *)afs_MemCacheOpen(ainode);
235     afs_int32 code;
236
237     AFS_STATCNT(afs_MemWriteUIO);
238     ObtainWriteLock(&mceP->afs_memLock, 312);
239     if (AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP) > mceP->dataSize) {
240         char *oldData = mceP->data;
241
242         mceP->data = afs_osi_Alloc(AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP));
243         if (mceP->data == NULL) {       /* no available memory */
244             mceP->data = oldData;       /* revert back change that was made */
245             ReleaseWriteLock(&mceP->afs_memLock);
246             afs_warn("afs: afs_MemWriteBlk mem alloc failure (%ld bytes)\n",
247                      (long)(AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP)));
248             return -ENOMEM;
249         }
250
251         AFS_GUNLOCK();
252         memcpy(mceP->data, oldData, mceP->size);
253         AFS_GLOCK();
254
255         afs_osi_Free(oldData, mceP->dataSize);
256         mceP->dataSize = AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP);
257     }
258     if (mceP->size < AFS_UIO_OFFSET(uioP))
259         memset(mceP->data + mceP->size, 0,
260                (int)(AFS_UIO_OFFSET(uioP) - mceP->size));
261     AFS_UIOMOVE(mceP->data + AFS_UIO_OFFSET(uioP), AFS_UIO_RESID(uioP), UIO_WRITE,
262                 uioP, code);
263     if (AFS_UIO_OFFSET(uioP) > mceP->size)
264         mceP->size = AFS_UIO_OFFSET(uioP);
265
266     ReleaseWriteLock(&mceP->afs_memLock);
267     return code;
268 }
269
270 int
271 afs_MemCacheTruncate(register struct osi_file *fP, int size)
272 {
273     register struct memCacheEntry *mceP = (struct memCacheEntry *)fP;
274     AFS_STATCNT(afs_MemCacheTruncate);
275
276     ObtainWriteLock(&mceP->afs_memLock, 313);
277     /* old directory entry; g.c. */
278     if (size == 0 && mceP->dataSize > memCacheBlkSize) {
279         char *oldData = mceP->data;
280         mceP->data = afs_osi_Alloc(memCacheBlkSize);
281         if (mceP->data == NULL) {       /* no available memory */
282             mceP->data = oldData;
283             ReleaseWriteLock(&mceP->afs_memLock);
284             afs_warn("afs: afs_MemWriteBlk mem alloc failure (%d bytes)\n",
285                      memCacheBlkSize);
286         } else {
287             afs_osi_Free(oldData, mceP->dataSize);
288             mceP->dataSize = memCacheBlkSize;
289         }
290     }
291
292     if (size < mceP->size)
293         mceP->size = size;
294
295     ReleaseWriteLock(&mceP->afs_memLock);
296     return 0;
297 }
298
299
300 void
301 shutdown_memcache(void)
302 {
303     register int index;
304
305     if (cacheDiskType != AFS_FCACHE_TYPE_MEM)
306         return;
307     memCacheBlkSize = 8192;
308     for (index = 0; index < memMaxBlkNumber; index++) {
309         LOCK_INIT(&((memCache + index)->afs_memLock), "afs_memLock");
310         afs_osi_Free((memCache + index)->data, (memCache + index)->dataSize);
311     }
312     afs_osi_Free((char *)memCache,
313                  memMaxBlkNumber * sizeof(struct memCacheEntry));
314     memMaxBlkNumber = 0;
315 }