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 RCSID
  14     ("$Header$");
  15
  16 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  17 #ifndef AFS_LINUX22_ENV
  18 #include "rpc/types.h"
  19 #endif
  20 #ifdef  AFS_OSF_ENV
  21 #undef kmem_alloc
  22 #undef kmem_free
  23 #undef mem_alloc
  24 #undef mem_free
  25 #undef register
  26 #endif /* AFS_OSF_ENV */
  27 #include "afsincludes.h"        /* Afs-based standard headers */
  28 #include "afs/afs_stats.h"      /* statistics */
  29
  30 /* memory cache routines */
  31 static struct memCacheEntry *memCache;
  32 static int memCacheBlkSize = 8192;
  33 static int memMaxBlkNumber = 0;
  34 static int memAllocMaySleep = 0;
  35
  36 extern int cacheDiskType;
  37
  38 int
  39 afs_InitMemCache(int blkCount, int blkSize, int flags)
  40 {
  41     int index;
  42
  43     AFS_STATCNT(afs_InitMemCache);
  44     if (blkSize)
  45         memCacheBlkSize = blkSize;
  46
  47     memMaxBlkNumber = blkCount;
  48     memCache = (struct memCacheEntry *)
  49         afs_osi_Alloc(memMaxBlkNumber * sizeof(struct memCacheEntry));
  50     if (flags & AFSCALL_INIT_MEMCACHE_SLEEP) {
  51         memAllocMaySleep = 1;
  52     }
  53
  54     for (index = 0; index < memMaxBlkNumber; index++) {
  55         char *blk;
  56         (memCache + index)->size = 0;
  57         (memCache + index)->dataSize = memCacheBlkSize;
  58         LOCK_INIT(&((memCache + index)->afs_memLock), "afs_memLock");
  59         if (memAllocMaySleep) {
  60             blk = afs_osi_Alloc(memCacheBlkSize);
  61         } else {
  62             blk = afs_osi_Alloc_NoSleep(memCacheBlkSize);
  63         }
  64         if (blk == NULL)
  65             goto nomem;
  66         (memCache + index)->data = blk;
  67         memset((memCache + index)->data, 0, memCacheBlkSize);
  68     }
  69 #if defined(AFS_SGI62_ENV) || defined(AFS_HAVE_VXFS)
  70     afs_InitDualFSCacheOps((struct vnode *)0);
  71 #endif
  72
  73     return 0;
  74
  75   nomem:
  76     printf("afsd:  memCache allocation failure at %d KB.\n",
  77            (index * memCacheBlkSize) / 1024);
  78     while (--index >= 0) {
  79         afs_osi_Free((memCache + index)->data, memCacheBlkSize);
  80         (memCache + index)->data = NULL;
  81     }
  82     return ENOMEM;
  83
  84 }
  85
  86 int
  87 afs_MemCacheClose(struct osi_file *file)
  88 {
  89     return 0;
  90 }
  91
  92 #if defined(AFS_SUN57_64BIT_ENV) || defined(AFS_SGI62_ENV)
  93 void *
  94 afs_MemCacheOpen(ino_t blkno)
  95 #else
  96 void *
  97 afs_MemCacheOpen(afs_int32 blkno)
  98 #endif
  99 {
 100     struct memCacheEntry *mep;
 101
 102     if (blkno < 0 || blkno > memMaxBlkNumber) {
 103         osi_Panic("afs_MemCacheOpen: invalid block #");
 104     }
 105     mep = (memCache + blkno);
 106     afs_Trace3(afs_iclSetp, CM_TRACE_MEMOPEN, ICL_TYPE_INT32, blkno,
 107                ICL_TYPE_POINTER, mep, ICL_TYPE_POINTER, mep ? mep->data : 0);
 108     return (void *)mep;
 109 }
 110
 111 /*
 112  * this routine simulates a read in the Memory Cache
 113  */
 114 int
 115 afs_MemReadBlk(register struct osi_file *fP, int offset, void *dest,
 116                int size)
 117 {
 118     register struct memCacheEntry *mceP = (struct memCacheEntry *)fP;
 119     int bytesRead;
 120
 121     MObtainReadLock(&mceP->afs_memLock);
 122     AFS_STATCNT(afs_MemReadBlk);
 123     if (offset < 0) {
 124         MReleaseReadLock(&mceP->afs_memLock);
 125         return 0;
 126     }
 127     /* use min of bytes in buffer or requested size */
 128     bytesRead = (size < mceP->size - offset) ? size : mceP->size - offset;
 129
 130     if (bytesRead > 0) {
 131         AFS_GUNLOCK();
 132         memcpy(dest, mceP->data + offset, bytesRead);
 133         AFS_GLOCK();
 134     } else
 135         bytesRead = 0;
 136
 137     MReleaseReadLock(&mceP->afs_memLock);
 138     return bytesRead;
 139 }
 140
 141 /*
 142  * this routine simulates a readv in the Memory Cache
 143  */
 144 int
 145 afs_MemReadvBlk(register struct memCacheEntry *mceP, int offset,
 146                 struct iovec *iov, int nio, int size)
 147 {
 148     int i;
 149     int bytesRead;
 150     int bytesToRead;
 151
 152     MObtainReadLock(&mceP->afs_memLock);
 153     AFS_STATCNT(afs_MemReadBlk);
 154     if (offset < 0) {
 155         MReleaseReadLock(&mceP->afs_memLock);
 156         return 0;
 157     }
 158     /* use min of bytes in buffer or requested size */
 159     bytesRead = (size < mceP->size - offset) ? size : mceP->size - offset;
 160
 161     if (bytesRead > 0) {
 162         for (i = 0, size = bytesRead; i < nio && size > 0; i++) {
 163             bytesToRead = (size < iov[i].iov_len) ? size : iov[i].iov_len;
 164             AFS_GUNLOCK();
 165             memcpy(iov[i].iov_base, mceP->data + offset, bytesToRead);
 166             AFS_GLOCK();
 167             offset += bytesToRead;
 168             size -= bytesToRead;
 169         }
 170         bytesRead -= size;
 171     } else
 172         bytesRead = 0;
 173
 174     MReleaseReadLock(&mceP->afs_memLock);
 175     return bytesRead;
 176 }
 177
 178 int
 179 afs_MemReadUIO(ino_t blkno, struct uio *uioP)
 180 {
 181     register struct memCacheEntry *mceP =
 182         (struct memCacheEntry *)afs_MemCacheOpen(blkno);
 183     int length = mceP->size - AFS_UIO_OFFSET(uioP);
 184     afs_int32 code;
 185
 186     AFS_STATCNT(afs_MemReadUIO);
 187     MObtainReadLock(&mceP->afs_memLock);
 188     length = (length < AFS_UIO_RESID(uioP)) ? length : AFS_UIO_RESID(uioP);
 189     AFS_UIOMOVE(mceP->data + AFS_UIO_OFFSET(uioP), length, UIO_READ, uioP, code);
 190     MReleaseReadLock(&mceP->afs_memLock);
 191     return code;
 192 }
 193
 194 /*XXX: this extends a block arbitrarily to support big directories */
 195 int
 196 afs_MemWriteBlk(register struct osi_file *fP, int offset, void *src,
 197                 int size)
 198 {
 199     register struct memCacheEntry *mceP = (struct memCacheEntry *)fP;
 200     AFS_STATCNT(afs_MemWriteBlk);
 201     MObtainWriteLock(&mceP->afs_memLock, 560);
 202     if (size + offset > mceP->dataSize) {
 203         char *oldData = mceP->data;
 204
 205         if (memAllocMaySleep) {
 206             mceP->data = afs_osi_Alloc(size + offset);
 207         } else {
 208             mceP->data = afs_osi_Alloc_NoSleep(size + offset);
 209         }
 210         if (mceP->data == NULL) {       /* no available memory */
 211             mceP->data = oldData;       /* revert back change that was made */
 212             MReleaseWriteLock(&mceP->afs_memLock);
 213             afs_warn("afs: afs_MemWriteBlk mem alloc failure (%d bytes)\n",
 214                      size + offset);
 215             return -ENOMEM;
 216         }
 217
 218         /* may overlap, but this is OK */
 219         AFS_GUNLOCK();
 220         memcpy(mceP->data, oldData, mceP->size);
 221         AFS_GLOCK();
 222         afs_osi_Free(oldData, mceP->dataSize);
 223         mceP->dataSize = size + offset;
 224     }
 225     AFS_GUNLOCK();
 226     if (mceP->size < offset)
 227         memset(mceP->data + mceP->size, 0, offset - mceP->size);
 228     memcpy(mceP->data + offset, src, size);
 229     AFS_GLOCK();
 230     mceP->size = (size + offset < mceP->size) ? mceP->size : size + offset;
 231
 232     MReleaseWriteLock(&mceP->afs_memLock);
 233     return size;
 234 }
 235
 236 /*XXX: this extends a block arbitrarily to support big directories */
 237 int
 238 afs_MemWritevBlk(register struct memCacheEntry *mceP, int offset,
 239                  struct iovec *iov, int nio, int size)
 240 {
 241     int i;
 242     int bytesWritten;
 243     int bytesToWrite;
 244     AFS_STATCNT(afs_MemWriteBlk);
 245     MObtainWriteLock(&mceP->afs_memLock, 561);
 246     if (offset + size > mceP->dataSize) {
 247         char *oldData = mceP->data;
 248
 249         mceP->data = afs_osi_Alloc(size + offset);
 250
 251         /* may overlap, but this is OK */
 252         AFS_GUNLOCK();
 253         memcpy(mceP->data, oldData, mceP->size);
 254         AFS_GLOCK();
 255         afs_osi_Free(oldData, mceP->dataSize);
 256         mceP->dataSize = size + offset;
 257     }
 258     AFS_GUNLOCK();
 259     if (mceP->size < offset)
 260         memset(mceP->data + mceP->size, 0, offset - mceP->size);
 261     for (bytesWritten = 0, i = 0; i < nio && size > 0; i++) {
 262         bytesToWrite = (size < iov[i].iov_len) ? size : iov[i].iov_len;
 263         memcpy(mceP->data + offset, iov[i].iov_base, bytesToWrite);
 264         offset += bytesToWrite;
 265         bytesWritten += bytesToWrite;
 266         size -= bytesToWrite;
 267     }
 268     mceP->size = (offset < mceP->size) ? mceP->size : offset;
 269     AFS_GLOCK();
 270
 271     MReleaseWriteLock(&mceP->afs_memLock);
 272     return bytesWritten;
 273 }
 274
 275 int
 276 afs_MemWriteUIO(ino_t blkno, struct uio *uioP)
 277 {
 278     register struct memCacheEntry *mceP =
 279         (struct memCacheEntry *)afs_MemCacheOpen(blkno);
 280     afs_int32 code;
 281
 282     AFS_STATCNT(afs_MemWriteUIO);
 283     MObtainWriteLock(&mceP->afs_memLock, 312);
 284     if (AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP) > mceP->dataSize) {
 285         char *oldData = mceP->data;
 286
 287         mceP->data = afs_osi_Alloc(AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP));
 288
 289         AFS_GUNLOCK();
 290         memcpy(mceP->data, oldData, mceP->size);
 291         AFS_GLOCK();
 292
 293         afs_osi_Free(oldData, mceP->dataSize);
 294         mceP->dataSize = AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP);
 295     }
 296     if (mceP->size < AFS_UIO_OFFSET(uioP))
 297         memset(mceP->data + mceP->size, 0,
 298                (int)(AFS_UIO_OFFSET(uioP) - mceP->size));
 299     AFS_UIOMOVE(mceP->data + AFS_UIO_OFFSET(uioP), AFS_UIO_RESID(uioP), UIO_WRITE,
 300                 uioP, code);
 301     if (AFS_UIO_OFFSET(uioP) > mceP->size)
 302         mceP->size = AFS_UIO_OFFSET(uioP);
 303
 304     MReleaseWriteLock(&mceP->afs_memLock);
 305     return code;
 306 }
 307
 308 int
 309 afs_MemCacheTruncate(register struct osi_file *fP, int size)
 310 {
 311     register struct memCacheEntry *mceP = (struct memCacheEntry *)fP;
 312     AFS_STATCNT(afs_MemCacheTruncate);
 313
 314     MObtainWriteLock(&mceP->afs_memLock, 313);
 315     /* old directory entry; g.c. */
 316     if (size == 0 && mceP->dataSize > memCacheBlkSize) {
 317         afs_osi_Free(mceP->data, mceP->dataSize);
 318         mceP->data = afs_osi_Alloc(memCacheBlkSize);
 319         mceP->dataSize = memCacheBlkSize;
 320     }
 321
 322     if (size < mceP->size)
 323         mceP->size = size;
 324
 325     MReleaseWriteLock(&mceP->afs_memLock);
 326     return 0;
 327 }
 328
 329 int
 330 afs_MemCacheStoreProc(register struct rx_call *acall,
 331                       register struct osi_file *fP,
 332                       register afs_int32 alen, struct vcache *avc,
 333                       int *shouldWake, afs_size_t * abytesToXferP,
 334                       afs_size_t * abytesXferredP)
 335 {
 336     register struct memCacheEntry *mceP = (struct memCacheEntry *)fP;
 337
 338     register afs_int32 code;
 339     register int tlen;
 340     int offset = 0;
 341     struct iovec *tiov;         /* no data copying with iovec */
 342     int tnio;                   /* temp for iovec size */
 343
 344     AFS_STATCNT(afs_MemCacheStoreProc);
 345 #ifndef AFS_NOSTATS
 346     /*
 347      * In this case, alen is *always* the amount of data we'll be trying
 348      * to ship here.
 349      */
 350     *(abytesToXferP) = alen;
 351     *(abytesXferredP) = 0;
 352 #endif /* AFS_NOSTATS */
 353
 354     /*
 355      * We need to alloc the iovecs on the heap so that they are "pinned" rather than
 356      * declare them on the stack - defect 11272
 357      */
 358     tiov =
 359         (struct iovec *)osi_AllocSmallSpace(sizeof(struct iovec) *
 360                                             RX_MAXIOVECS);
 361     if (!tiov) {
 362         osi_Panic
 363             ("afs_MemCacheStoreProc: osi_AllocSmallSpace for iovecs returned NULL\n");
 364     }
 365 #ifdef notdef
 366     /* do this at a higher level now -- it's a parameter */
 367     /* for now, only do 'continue from close' code if file fits in one
 368      * chunk.  Could clearly do better: if only one modified chunk
 369      * then can still do this.  can do this on *last* modified chunk */
 370     tlen = avc->m.Length - 1;   /* byte position of last byte we'll store */
 371     if (shouldWake) {
 372         if (AFS_CHUNK(tlen) != 0)
 373             *shouldWake = 0;
 374         else
 375             *shouldWake = 1;
 376     }
 377 #endif /* notdef */
 378
 379     while (alen > 0) {
 380         tlen = (alen > AFS_LRALLOCSIZ ? AFS_LRALLOCSIZ : alen);
 381         RX_AFS_GUNLOCK();
 382         code = rx_WritevAlloc(acall, tiov, &tnio, RX_MAXIOVECS, tlen);
 383         RX_AFS_GLOCK();
 384         if (code <= 0) {
 385             code = rx_Error(acall);
 386             osi_FreeSmallSpace(tiov);
 387             return code ? code : -33;
 388         }
 389         tlen = code;
 390         code = afs_MemReadvBlk(mceP, offset, tiov, tnio, tlen);
 391         if (code != tlen) {
 392             osi_FreeSmallSpace(tiov);
 393             return -33;
 394         }
 395         RX_AFS_GUNLOCK();
 396         code = rx_Writev(acall, tiov, tnio, tlen);
 397         RX_AFS_GLOCK();
 398 #ifndef AFS_NOSTATS
 399         (*abytesXferredP) += code;
 400 #endif /* AFS_NOSTATS */
 401         if (code != tlen) {
 402             code = rx_Error(acall);
 403             osi_FreeSmallSpace(tiov);
 404             return code ? code : -33;
 405         }
 406         offset += tlen;
 407         alen -= tlen;
 408         /* if file has been locked on server, can allow store to continue */
 409         if (shouldWake && *shouldWake && (rx_GetRemoteStatus(acall) & 1)) {
 410             *shouldWake = 0;    /* only do this once */
 411             afs_wakeup(avc);
 412         }
 413     }
 414     osi_FreeSmallSpace(tiov);
 415     return 0;
 416 }
 417
 418 int
 419 afs_MemCacheFetchProc(register struct rx_call *acall,
 420                       register struct osi_file *fP, afs_size_t abase,
 421                       struct dcache *adc, struct vcache *avc,
 422                       afs_size_t * abytesToXferP, afs_size_t * abytesXferredP,
 423                       afs_int32 lengthFound)
 424 {
 425     register struct memCacheEntry *mceP = (struct memCacheEntry *)fP;
 426     register afs_int32 code;
 427     afs_int32 length;
 428     int moredata = 0;
 429     struct iovec *tiov;         /* no data copying with iovec */
 430     register int tlen, offset = 0;
 431     int tnio;                   /* temp for iovec size */
 432
 433     AFS_STATCNT(afs_MemCacheFetchProc);
 434     length = lengthFound;
 435     afs_Trace4(afs_iclSetp, CM_TRACE_MEMFETCH, ICL_TYPE_POINTER, avc,
 436                ICL_TYPE_POINTER, mceP, ICL_TYPE_OFFSET,
 437                ICL_HANDLE_OFFSET(abase), ICL_TYPE_INT32, length);
 438 #ifndef AFS_NOSTATS
 439     (*abytesToXferP) = 0;
 440     (*abytesXferredP) = 0;
 441 #endif /* AFS_NOSTATS */
 442     /*
 443      * We need to alloc the iovecs on the heap so that they are "pinned" rather than
 444      * declare them on the stack - defect 11272
 445      */
 446     tiov =
 447         (struct iovec *)osi_AllocSmallSpace(sizeof(struct iovec) *
 448                                             RX_MAXIOVECS);
 449     if (!tiov) {
 450         osi_Panic
 451             ("afs_MemCacheFetchProc: osi_AllocSmallSpace for iovecs returned NULL\n");
 452     }
 453     adc->validPos = abase;
 454     do {
 455         if (moredata) {
 456             RX_AFS_GUNLOCK();
 457             code = rx_Read(acall, (char *)&length, sizeof(afs_int32));
 458             length = ntohl(length);
 459             RX_AFS_GLOCK();
 460             if (code != sizeof(afs_int32)) {
 461                 code = rx_Error(acall);
 462                 osi_FreeSmallSpace(tiov);
 463                 return (code ? code : -1);      /* try to return code, not -1 */
 464             }
 465         }
 466         /*
 467          * The fetch protocol is extended for the AFS/DFS translator
 468          * to allow multiple blocks of data, each with its own length,
 469          * to be returned. As long as the top bit is set, there are more
 470          * blocks expected.
 471          *
 472          * We do not do this for AFS file servers because they sometimes
 473          * return large negative numbers as the transfer size.
 474          */
 475         if (avc->states & CForeign) {
 476             moredata = length & 0x80000000;
 477             length &= ~0x80000000;
 478         } else {
 479             moredata = 0;
 480         }
 481 #ifndef AFS_NOSTATS
 482         (*abytesToXferP) += length;
 483 #endif /* AFS_NOSTATS */
 484         while (length > 0) {
 485             tlen = (length > AFS_LRALLOCSIZ ? AFS_LRALLOCSIZ : length);
 486             RX_AFS_GUNLOCK();
 487             code = rx_Readv(acall, tiov, &tnio, RX_MAXIOVECS, tlen);
 488             RX_AFS_GLOCK();
 489 #ifndef AFS_NOSTATS
 490             (*abytesXferredP) += code;
 491 #endif /* AFS_NOSTATS */
 492             if (code <= 0) {
 493                 afs_Trace3(afs_iclSetp, CM_TRACE_FETCH64READ,
 494                            ICL_TYPE_POINTER, avc, ICL_TYPE_INT32, code,
 495                            ICL_TYPE_INT32, length);
 496                 osi_FreeSmallSpace(tiov);
 497                 return -34;
 498             }
 499             tlen = code;
 500             afs_MemWritevBlk(mceP, offset, tiov, tnio, tlen);
 501             offset += tlen;
 502             abase += tlen;
 503             length -= tlen;
 504             adc->validPos = abase;
 505             if (afs_osi_Wakeup(&adc->validPos) == 0)
 506                 afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAKE, ICL_TYPE_STRING,
 507                            __FILE__, ICL_TYPE_INT32, __LINE__,
 508                            ICL_TYPE_POINTER, adc, ICL_TYPE_INT32,
 509                            adc->dflags);
 510         }
 511     } while (moredata);
 512     /* max of two sizes */
 513     osi_FreeSmallSpace(tiov);
 514     return 0;
 515 }
 516
 517
 518 void
 519 shutdown_memcache(void)
 520 {
 521     register int index;
 522
 523     if (cacheDiskType != AFS_FCACHE_TYPE_MEM)
 524         return;
 525     memCacheBlkSize = 8192;
 526     for (index = 0; index < memMaxBlkNumber; index++) {
 527         LOCK_INIT(&((memCache + index)->afs_memLock), "afs_memLock");
 528         afs_osi_Free((memCache + index)->data, (memCache + index)->dataSize);
 529     }
 530     afs_osi_Free((char *)memCache,
 531                  memMaxBlkNumber * sizeof(struct memCacheEntry));
 532     memMaxBlkNumber = 0;
 533 }