rom/filesys/SFS/FS/cachedio.c

   1 #include "asmsupport.h"
   2
   3 #include <dos/dos.h>
   4 #include <exec/lists.h>
   5 #include <exec/types.h>
   6 #include <proto/exec.h>
   7
   8 #include "cachedio_protos.h"
   9 #include "deviceio.h"
  10 #include "deviceio_protos.h"
  11 #include "req_protos.h"
  12
  13 #define removem(n)    (n)->mln_Succ->mln_Pred=(n)->mln_Pred; (n)->mln_Pred->mln_Succ=(n)->mln_Succ
  14 #define addtailm(l,n) (n)->mln_Succ=(l)->mlh_TailPred->mln_Succ; (l)->mlh_TailPred->mln_Succ=(n); (n)->mln_Pred=(l)->mlh_TailPred; (l)->mlh_TailPred=(n)
  15 #define addheadm(l,n) (n)->mln_Succ=(l)->mlh_Head; (n)->mln_Pred=(struct MinNode *)(l); (l)->mlh_Head->mln_Pred=(n); (l)->mlh_Head=(n);
  16
  17 #include "debug.h"
  18
  19 #include "globals.h"
  20
  21 static LONG copybackiocache(struct IOCache *ioc);
  22
  23 /* Internal structures */
  24
  25 struct IOCache {
  26   struct MinNode node;   /* LRU chain */
  27
  28   struct IOCache *nexthash;
  29   struct IOCache *prevhash;
  30
  31   void *data;
  32
  33   ULONG block;           /* Unused IOCache has blocks = 0 */
  34   ULONG blocks;
  35
  36   ULONG dirty[4];        /* Set bits indicate blocks which need to be written to disk. */
  37   ULONG valid[4];        /* Set bits indicate blocks which contain up-to-date data. */
  38
  39   UBYTE bits;            /* See defines below */
  40   UBYTE locked;          /* Indicates that lruiocache should not return this iocache */
  41   UWORD pad3;
  42
  43   /* Possible combinations for dirty and valid:
  44
  45      dirty         : Illegal value.
  46      valid         : Block is the same as on disk.
  47      valid & dirty : Block is newer than the one on disk and must be flushed.
  48      (none)        : Block has not yet been read from disk. */
  49
  50 };
  51
  52 /* defines for IOCache bits */
  53
  54 #define IOC_DIRTY  (1)   /* IOCache contains dirty data */
  55
  56 /*
  57
  58 Functions making use of the IOCache mechanism:
  59
  60 read - reads one or more blocks into a buffer.
  61 write - writes one or more blocks from a buffer.
  62
  63 The IOCache system is a simple caching mechanism intended to
  64 make maximum use of small reads.  The filesystem likes to
  65 read single blocks, which are usually only 512 bytes in
  66 size.  Most harddisks however can read a lot more data in a
  67 single access without a speed penalty.
  68
  69 This is where the IOCaches come in.  Instead of reading just
  70 512 bytes, the system will read for example 4096 bytes.  It
  71 reads this information into IOCache buffers.  The data
  72 actually required is copied from the IOCache into the
  73 supplied buffer.
  74
  75 This makes Writes a little bit more complex.  Because data
  76 can reside in the cache each Write must be checked to see if
  77 one of the IOCaches doesn't need to be updated or flushed.
  78 Whether an IOCache must be updated or flushed depends on the
  79 mode the cache operates in.  WriteThrough caching means the
  80 buffers are just updated and kept in memory.  Otherwise a
  81 buffer is simply marked invalid.
  82
  83 */
  84
  85
  86
  87 void hashit(struct IOCache *ioc) {
  88   WORD hashentry=(ioc->block>>globals->iocache_shift) & (IOC_HASHSIZE-1);
  89
  90   ioc->nexthash=globals->ioc_hashtable[hashentry];
  91   if(ioc->nexthash!=0) {
  92     ioc->nexthash->prevhash=ioc;
  93   }
  94   ioc->prevhash=0;
  95   globals->ioc_hashtable[hashentry]=ioc;
  96 }
  97
  98
  99
 100 static void dehash(struct IOCache *ioc) {
 101   if(ioc->blocks!=0) {
 102     if(ioc->nexthash!=0) {
 103       ioc->nexthash->prevhash=ioc->prevhash;
 104     }
 105     if(ioc->prevhash!=0) {
 106       ioc->prevhash->nexthash=ioc->nexthash;
 107     }
 108     else {
 109       globals->ioc_hashtable[ (ioc->block>>globals->iocache_shift) & (IOC_HASHSIZE-1)]=ioc->nexthash;    /* Aug 11 1998: changed '=0' to '=ioc->nexthash' !! */
 110     }
 111   }
 112
 113   ioc->nexthash=0;
 114   ioc->prevhash=0;
 115 }
 116
 117
 118
 119 void invalidateiocache(struct IOCache *ioc) {
 120   dehash(ioc);
 121   ioc->blocks=0;
 122   ioc->block=0;
 123   ioc->bits=0;
 124 //  ioc->dirtylow=255;
 125 //  ioc->dirtyhigh=0;
 126
 127   ioc->dirty[0]=0;
 128   ioc->dirty[1]=0;
 129   ioc->dirty[2]=0;
 130   ioc->dirty[3]=0;
 131
 132   ioc->valid[0]=0;
 133   ioc->valid[1]=0;
 134   ioc->valid[2]=0;
 135   ioc->valid[3]=0;
 136 }
 137
 138
 139
 140 void freeIOCache(struct MinList *lruhead) {
 141
 142   /* Frees all IOCache buffers attached to the passed in list and the
 143      listheader itself.  If lruhead is zero then this function does
 144      nothing. */
 145
 146   if(lruhead!=0) {
 147     while(lruhead->mlh_TailPred != (struct MinNode *)lruhead) {
 148       struct IOCache *ioc=(struct IOCache *)lruhead->mlh_Head;
 149
 150       removem(lruhead->mlh_Head);
 151
 152       FreeVec(ioc);
 153     }
 154
 155     FreeMem(lruhead, sizeof(struct MinList));
 156   }
 157 }
 158
 159
 160
 161 struct MinList *allocate(ULONG size, LONG n) {
 162   struct MinList *lruhead;
 163
 164   /* Allocates n IOCache buffers of /size/ bytes and attaches
 165      them to the returned MinList.  The MinList is returned
 166      and is zero if there wasn't enough memory. */
 167
 168   if((lruhead=AllocMem(sizeof(struct MinList), globals->bufmemtype))!=0) {
 169     struct IOCache *ioc;
 170
 171     lruhead->mlh_Head=(struct MinNode *)&lruhead->mlh_Tail;
 172     lruhead->mlh_Tail=0;
 173     lruhead->mlh_TailPred=(struct MinNode *)lruhead;
 174
 175     size+=sizeof(struct IOCache)+16;
 176
 177     while(--n>=0 && (ioc=AllocVec(size, globals->bufmemtype))!=0) {
 178       ioc->blocks=0;       // Mar 11 1999: Added this line to avoid that dehash() makes a mess of things.
 179       ioc->nexthash=0;
 180       ioc->prevhash=0;
 181       ioc->locked=0;
 182       invalidateiocache(ioc);
 183
 184       /* ioc->data is aligned to 16 byte boundaries. */
 185       ioc->data=(UBYTE *)((IPTR)((UBYTE *)ioc+sizeof(struct IOCache)+15) & (~0x0F));
 186
 187       addtailm(lruhead, &ioc->node);
 188     }
 189
 190     if(n<0) {
 191       return(lruhead);
 192     }
 193
 194     freeIOCache(lruhead);
 195   }
 196
 197   return(0);
 198 }
 199
 200
 201
 202 ULONG queryiocache_lines(void) {
 203   return(globals->iocache_lines);
 204 }
 205
 206
 207
 208 ULONG queryiocache_readaheadsize(void) {
 209   return(globals->iocache_sizeinblocks << globals->shifts_block);
 210 }
 211
 212
 213
 214 BYTE queryiocache_copyback(void) {
 215   return(globals->iocache_copyback);
 216 }
 217
 218
 219
 220 LONG setiocache(ULONG lines, ULONG readahead, BYTE copyback) {
 221   struct MinList *lruhead;
 222   ULONG sizeinblocks=readahead>>globals->shifts_block;
 223   WORD shift;
 224
 225   /* This function changes the size and type of the IOCache.  The
 226      old Cache settings will remain in effect if the new ones
 227      couldn't be applied due to lack of memory.
 228
 229      When this function is called first time, there are no old
 230      settings! */
 231
 232   if(sizeinblocks<4) {
 233     shift=1;
 234   }
 235   else if(sizeinblocks<8) {
 236     shift=2;
 237   }
 238   else if(sizeinblocks<16) {
 239     shift=3;
 240   }
 241   else if(sizeinblocks<32) {
 242     shift=4;
 243   }
 244   else if(sizeinblocks<64) {
 245     shift=5;
 246   }
 247   else if(sizeinblocks<128) {
 248     shift=6;
 249   }
 250   else {
 251     shift=7;
 252   }
 253
 254   sizeinblocks=1<<shift;
 255
 256   if(lines<4) {
 257     lines=4;
 258   }
 259   else if(lines>1024) {
 260     lines=1024;
 261   }
 262
 263   if((lruhead=allocate(sizeinblocks<<globals->shifts_block, lines))!=0) {
 264     LONG errorcode=0;
 265
 266     if(globals->iocache_lruhead==0 || (errorcode=flushiocache())==0) {
 267       WORD m=IOC_HASHSIZE;
 268
 269       globals->iocache_sizeinblocks=sizeinblocks;
 270       globals->iocache_lines=lines;
 271       globals->iocache_copyback=copyback;
 272       if(copyback==FALSE) {
 273         globals->iocache_readonwrite=TRUE;
 274       }
 275       globals->iocache_mask=sizeinblocks-1;
 276       globals->iocache_shift=shift;
 277
 278       freeIOCache(globals->iocache_lruhead);
 279       globals->iocache_lruhead=lruhead;
 280
 281       if(globals->iocache_readonwrite==FALSE && globals->iocache_copyback!=FALSE) {
 282         globals->ioc_buffer=(struct IOCache *)globals->iocache_lruhead->mlh_Head;
 283         globals->ioc_buffer->locked=TRUE;
 284       }
 285
 286       while(--m>=0) {
 287         globals->ioc_hashtable[m]=0;
 288       }
 289     }
 290     else {
 291       freeIOCache(lruhead);
 292     }
 293
 294     return(errorcode);
 295   }
 296
 297   return(ERROR_NO_FREE_STORE);
 298 }
 299
 300
 301
 302
 303 /* The IOCache is automatically disabled when iocache_lines == 0 */
 304
 305 LONG initcachedio(UBYTE *devicename, IPTR unit, ULONG flags, struct DosEnvec *de)
 306 {
 307   LONG errorcode;
 308
 309   if((errorcode=initdeviceio(devicename, unit, flags, de))==0) {
 310
 311     /* Note: There MUST be atleast 4 IOCache_lines for cachedio to work correctly at the moment!! */
 312
 313     if((setiocache(8, 8192, TRUE))==0) {
 314       return(0);
 315     }
 316   }
 317
 318   return(errorcode);
 319 }
 320
 321
 322
 323 void cleanupcachedio(void) {
 324
 325   /* Only call this if initcachedio() was succesful. */
 326
 327   flushiocache();    /*** returns an errorcode... */
 328   freeIOCache(globals->iocache_lruhead);
 329   globals->iocache_lruhead=0;
 330
 331   globals->iocache_lines=0;
 332
 333   cleanupdeviceio();
 334 }
 335
 336
 337
 338 struct IOCache *findiocache(BLCK block) {
 339   struct IOCache *ioc=globals->ioc_hashtable[ (block>>globals->iocache_shift) & (IOC_HASHSIZE-1) ];
 340
 341   /* For internal use only.  This function will find the IOCache, if available.
 342      It won't move the block to the end of the LRU chain though -- use locateiocache
 343      instead. */
 344
 345   while(ioc!=0) {
 346     if(block>=ioc->block && block<ioc->block+ioc->blocks) {
 347       return(ioc);
 348     }
 349
 350     ioc=ioc->nexthash;
 351   }
 352
 353   return(0);
 354 }
 355
 356
 357
 358 struct IOCache *locateiocache(BLCK block) {
 359   struct IOCache *ioc;
 360
 361   if((ioc=findiocache(block))!=0) {
 362     removem(&ioc->node);
 363     addtailm(globals->iocache_lruhead, &ioc->node);
 364   }
 365
 366   return(ioc);
 367 }
 368
 369
 370
 371 LONG lruiocache(struct IOCache **returned_ioc) {
 372   struct IOCache *ioc;
 373   LONG errorcode;
 374
 375   /* Must be volatile to keep ioc variable value up to date regardless of
 376      compiler optimizations */
 377   volatile struct MinList *ioclist = globals->iocache_lruhead;
 378
 379   /* Returns the least recently used IOCache */
 380
 381   do {
 382     ioc=(struct IOCache *) ioclist->mlh_Head;
 383
 384     removem(&ioc->node);
 385     addtailm(globals->iocache_lruhead, &ioc->node);
 386
 387   } while(ioc->locked!=0);
 388
 389   if((errorcode=copybackiocache(ioc))!=0) {
 390     return(errorcode);
 391   }
 392   invalidateiocache(ioc);
 393
 394   *returned_ioc=ioc;
 395
 396   return(0);
 397 }
 398
 399
 400
 401 void reuseiocache(struct IOCache *ioc) {
 402
 403   /* This function makes sure that the passed in IOCache is reused
 404      as quickly as possible.  This is a good idea if you used an IOCache
 405      and you're certain it won't be needed again.  In such a case you
 406      can call this function so this cache is the first to be reused. */
 407
 408   removem(&ioc->node);
 409   addheadm(globals->iocache_lruhead, &ioc->node);
 410 }
 411
 412
 413
 414 LONG validateiocache(struct IOCache *ioc, ULONG blockoffset, ULONG blocks) {
 415   LONG errorcode;
 416
 417   /* This function will read the missing data from this IOCache from disk
 418      and merge it with any existing dirty blocks.  To reduce copying it
 419      will either use the newly read IOCache or the current IOCache to
 420      store the final result.  It will switch the data pointers so there is
 421      no need for rehashing. */
 422
 423   if(globals->iocache_readonwrite!=FALSE || bmtsto(ioc->valid, blockoffset, blocks)!=0) {
 424     return(0);
 425   }
 426
 427 //  _DEBUG(("validateiocache: ioc->block = %ld, ioc->blocks = %ld, ioc->dirty = 0x%08lx, ioc->valid = 0x%08lx\n", ioc->block, ioc->blocks, ioc->dirty[0], ioc->valid[0]));
 428
 429   if((errorcode=transfer(DIO_READ, globals->ioc_buffer->data, ioc->block, ioc->blocks))==0) {
 430     LONG i=globals->iocache_sizeinblocks;
 431
 432 //    _DEBUG(("validateiocache: BMCNTO returned %ld\n", BMCNTO(ioc->dirty, 0, ioc->blocks)));
 433
 434     if(bmcnto(ioc->dirty, 0, ioc->blocks) < globals->iocache_sizeinblocks/2) {
 435       void *data;
 436
 437       /* Copying the dirty blocks to the new IOCache. */
 438
 439 //      _DEBUG(("validateiocache: Using new IOCache\n"));
 440
 441       while(--i>=0) {
 442         if(bmtsto(ioc->dirty, i, 1)!=FALSE) {
 443           CopyMemQuick((UBYTE *)ioc->data + (i<<globals->shifts_block), (UBYTE *)globals->ioc_buffer->data + (i<<globals->shifts_block), globals->bytes_block);
 444         }
 445       }
 446
 447       data=globals->ioc_buffer->data;
 448       globals->ioc_buffer->data=ioc->data;
 449       ioc->data=data;
 450     }
 451     else {
 452
 453       /* Copying the newly read blocks to the existing IOCache. */
 454
 455 //      _DEBUG(("validateiocache: Using existing IOCache\n"));
 456
 457       while(--i>=0) {
 458         if(bmtstz(ioc->dirty, i, 1)!=FALSE) {
 459           CopyMemQuick((UBYTE *)globals->ioc_buffer->data + (i<<globals->shifts_block), (UBYTE *)ioc->data + (i<<globals->shifts_block), globals->bytes_block);
 460         }
 461       }
 462     }
 463
 464     ioc->valid[0]=0xFFFFFFFF;
 465     ioc->valid[1]=0xFFFFFFFF;
 466     ioc->valid[2]=0xFFFFFFFF;
 467     ioc->valid[3]=0xFFFFFFFF;
 468   }
 469
 470   return(errorcode);
 471 }
 472
 473
 474
 475 static LONG copybackiocache(struct IOCache *ioc) {
 476   LONG errorcode=0;
 477   LONG dirtylow, dirtyhigh;
 478
 479   /* Writes out any dirty data, and resets the dirty bit.
 480
 481      For extra efficiency this function will in case of a physical
 482      disk-access also flush any buffers following this one, to avoid
 483      physical head movement. */
 484
 485 //  _DEBUG(("copybackiocache: ioc->block = %ld\n", ioc->block));
 486
 487   while(ioc!=0 && ioc->blocks!=0 && (ioc->bits & IOC_DIRTY)!=0) {
 488
 489     _DEBUG(("copybackiocache: ioc->dirty=%p (@=%08x) ioc->blocks-1=%d\n", ioc->dirty, AROS_BE2LONG(*(ULONG*)ioc->dirty), ioc->blocks-1));
 490
 491     if((dirtyhigh=bmflo(ioc->dirty, ioc->blocks-1))<0) {
 492       _DEBUG(("copybackiocache: Say what?\n"));
 493       break;
 494 //    dirtyhigh = ioc->blocks-1;
 495     }
 496
 497     dirtylow=bmffo(ioc->dirty, 4, 0);
 498
 499 //    _DEBUG(("copybackiocache: dirtylow = %ld, dirtyhigh = %ld, ioc->dirty = 0x%08lx\n", dirtylow, dirtyhigh, ioc->dirty[0]));
 500
 501     /* dirtylow and dirtyhigh are known.  Now, to check if we can write
 502        all these changes in a single write we check if all the blocks
 503        between dirtylow and dirtyhigh are VALID (not dirty, although
 504        most of them probably will be dirty). */
 505
 506     if(bmffz(ioc->valid, 4, dirtylow)<dirtyhigh) {
 507 //      _DEBUG(("copybackiocache: calling validateiocache\n"));
 508       if((errorcode=validateiocache(ioc, 0, ioc->blocks))!=0) {
 509         break;
 510       }
 511     }
 512
 513     if((errorcode=transfer(DIO_WRITE, (UBYTE *)ioc->data + (dirtylow<<globals->shifts_block), ioc->block + dirtylow, dirtyhigh - dirtylow + 1))!=0) {
 514       break;
 515     }
 516
 517     ioc->bits&=~IOC_DIRTY;
 518     ioc->dirty[0]=0;
 519     ioc->dirty[1]=0;
 520     ioc->dirty[2]=0;
 521     ioc->dirty[3]=0;
 522 //    ioc->dirtylow=255;
 523 //    ioc->dirtyhigh=0;
 524
 525     ioc=findiocache(ioc->block+ioc->blocks);
 526   }
 527
 528   return(errorcode);
 529 }
 530
 531
 532
 533 LONG flushiocache(void) {
 534   struct IOCache *ioc;
 535   LONG errorcode=0;
 536
 537   /* Writes all dirty data to disk, but keeps the cached data for
 538      later reads.  Use this to ensure data is comitted to disk
 539      when doing critical operations. */
 540
 541   ioc=(struct IOCache *)globals->iocache_lruhead->mlh_Head;
 542
 543   while(ioc->node.mln_Succ!=0) {
 544     if((errorcode=copybackiocache(ioc))!=0) {
 545       break;
 546     }
 547
 548     ioc=(struct IOCache *)(ioc->node.mln_Succ);
 549   }
 550
 551   if(errorcode==0) {
 552     update();
 553   }
 554
 555 //  _DEBUG(("flushiocache: errorcode = %ld\n", errorcode));
 556
 557   return(errorcode);
 558 }
 559
 560
 561
 562 void invalidateiocaches(void) {
 563   struct IOCache *ioc;
 564
 565   /* Clears all buffers in the IOCache.  This should be used BEFORE
 566      directly writing to the disk (for example, call this before
 567      ACTION_INHIBIT(TRUE)).  Before calling this function make
 568      sure all pending changes have been flushed using flushiocache() */
 569
 570   ioc=(struct IOCache *)globals->iocache_lruhead->mlh_Head;
 571
 572   while(ioc->node.mln_Succ!=0) {
 573     invalidateiocache(ioc);
 574
 575     ioc=(struct IOCache *)(ioc->node.mln_Succ);
 576   }
 577 }
 578
 579
 580
 581 /*
 582 void copyiocachetobuffer(struct IOCache *ioc, BLCK *block, UBYTE **buffer, ULONG *blocks) {
 583   ULONG blockoffset=*block-ioc->block;
 584   ULONG blocklength=ioc->blocks-blockoffset;
 585
 586   if(*blocks<blocklength) {
 587     blocklength=*blocks;
 588   }
 589
 590   if(((ULONG)(*buffer) & 0x00000003) != 0) {
 591     CopyMem((UBYTE *)ioc->data + (blockoffset<<shifts_block), *buffer, blocklength<<shifts_block);
 592   }
 593   else {
 594     CopyMemQuick((UBYTE *)ioc->data + (blockoffset<<shifts_block), *buffer, blocklength<<shifts_block);
 595   }
 596
 597   *block+=blocklength;
 598   *blocks-=blocklength;
 599   *buffer+=blocklength<<shifts_block;
 600 }
 601 */
 602
 603
 604 LONG readintocache(BLCK block, struct IOCache **returned_ioc) {
 605   struct IOCache *ioc;
 606   LONG errorcode=0;
 607
 608   if((ioc=locateiocache(block))==0) {
 609     if((errorcode=lruiocache(&ioc))==0) {
 610       ULONG blockstart=block & ~globals->iocache_mask;
 611       ULONG blocklength=globals->iocache_sizeinblocks;
 612
 613       if(blockstart+blocklength>globals->blocks_total) {
 614         blocklength=globals->blocks_total-blockstart;
 615       }
 616
 617       if((errorcode=transfer(DIO_READ, ioc->data, blockstart, blocklength))==0) {
 618         ioc->block=blockstart;
 619         ioc->blocks=blocklength;
 620
 621         ioc->valid[0]=0xFFFFFFFF;
 622         ioc->valid[1]=0xFFFFFFFF;
 623         ioc->valid[2]=0xFFFFFFFF;
 624         ioc->valid[3]=0xFFFFFFFF;
 625
 626         hashit(ioc);
 627       }
 628     }
 629   }
 630
 631   *returned_ioc=ioc;
 632
 633   return(errorcode);
 634 }
 635
 636
 637
 638 LONG readonwriteintocache(BLCK block, struct IOCache **returned_ioc) {
 639   struct IOCache *ioc;
 640   LONG errorcode=0;
 641
 642   /* Only does a physical read if iocache_readonwrite is TRUE */
 643
 644   if((ioc=locateiocache(block))==0) {
 645     if((errorcode=lruiocache(&ioc))==0) {
 646       ULONG blockstart=block & ~globals->iocache_mask;
 647       ULONG blocklength=globals->iocache_sizeinblocks;
 648
 649       if(blockstart+blocklength>globals->blocks_total) {
 650         blocklength=globals->blocks_total-blockstart;
 651       }
 652
 653       if(globals->iocache_readonwrite==FALSE || (errorcode=transfer(DIO_READ, ioc->data, blockstart, blocklength))==0) {
 654         ioc->block=blockstart;
 655         ioc->blocks=blocklength;
 656
 657         if(globals->iocache_readonwrite!=FALSE) {
 658           ioc->valid[0]=0xFFFFFFFF;
 659           ioc->valid[1]=0xFFFFFFFF;
 660           ioc->valid[2]=0xFFFFFFFF;
 661           ioc->valid[3]=0xFFFFFFFF;
 662         }
 663
 664         hashit(ioc);
 665       }
 666     }
 667   }
 668
 669   *returned_ioc=ioc;
 670
 671   return(errorcode);
 672 }
 673
 674
 675
 676 static LONG copybackoverlappingiocaches(BLCK block, ULONG blocks) {
 677   struct IOCache *ioc;
 678   BLCK lastblock;
 679   LONG errorcode=0;
 680
 681   /* This function copies back any IOCaches which fall (partially) in the
 682      region specified by the input parameters. */
 683
 684   lastblock=(block+blocks-1) & ~globals->iocache_mask;
 685   block=block & ~globals->iocache_mask;
 686
 687   while(block<=lastblock) {                       // Aug 6 1998: Changed '<' into '<='.
 688     if((ioc=locateiocache(block))!=0) {
 689       if((errorcode=copybackiocache(ioc))!=0) {
 690         break;
 691       }
 692     }
 693     block+=globals->iocache_sizeinblocks;
 694   }
 695
 696   return(errorcode);
 697 }
 698
 699
 700
 701 LONG readbytes(BLCK block, UBYTE *buffer, UWORD offsetinblock, UWORD bytes) {
 702   struct IOCache *ioc;
 703   LONG errorcode;
 704
 705   /* This function is intended to copy data directly from a IOCache buffer
 706      which was read.  It can be used for small amounts of data only (1 to
 707      bytes_block bytes)
 708
 709      This function will fall back to reading a single block if the cache
 710      is disabled. */
 711
 712   if((errorcode=readintocache(block, &ioc))==0 && (errorcode=validateiocache(ioc, block-ioc->block, 1))==0) {
 713     CopyMem((UBYTE *)ioc->data+((block-ioc->block)<<globals->shifts_block) + offsetinblock, buffer, bytes);
 714   }
 715
 716   return(errorcode);
 717 }
 718
 719
 720
 721 LONG writebytes(BLCK block, UBYTE *buffer, UWORD offsetinblock, UWORD bytes) {
 722   struct IOCache *ioc;
 723   LONG errorcode;
 724
 725   /* This function is intended to copy data directly into a IOCache buffer
 726      which was read.  It can be used for small amounts of data only (1 to
 727      bytes_block bytes).
 728
 729      This function will fall back to reading/modifying/writing a single
 730      block if the cache or copyback caching is disabled. */
 731
 732   if((errorcode=readintocache(block, &ioc))==0 && (errorcode=validateiocache(ioc, block-ioc->block, 1))==0) {
 733     CopyMem(buffer, (UBYTE *)ioc->data + ((block-ioc->block)<<globals->shifts_block) + offsetinblock, bytes);
 734     if(globals->iocache_copyback==FALSE) {
 735       errorcode=write(block, (UBYTE *)ioc->data+((block-ioc->block)<<globals->shifts_block), 1);
 736     }
 737     else {
 738       bmset(ioc->dirty, 4, block-ioc->block, 1);
 739       ioc->bits|=IOC_DIRTY;
 740     }
 741   }
 742
 743   return(errorcode);
 744 }
 745
 746
 747
 748 LONG read(BLCK block, UBYTE *buffer, ULONG blocks) {
 749   LONG errorcode=0;
 750
 751   if(blocks!=0) {
 752
 753     /* The readahead caching system works simple; if the data-request is lesser
 754        than or equal to the line-size than we first try to locate the data in
 755        the cache.  If it is available it is copied and returned.  If the data
 756        isn't available then it is read into the cache, and copied afterwards.
 757
 758        Large requests are processed seperately and don't go through the cache.
 759        The idea is that large requests are quite fast when loaded from the HD
 760        anyway.  Also, to be able to properly speed up even large requests you'd
 761        also need a substantially larger cache, which isn't what we want here. */
 762
 763     if(globals->iocache_lines!=0 && blocks<=globals->iocache_sizeinblocks>>1) {        // ****** // dit kan sneller, als het ondanks het te grote request toch in de cache staat!
 764       struct IOCache *ioc;
 765
 766       while(errorcode==0 && blocks!=0) {
 767         if((errorcode=readintocache(block, &ioc))==0) {
 768           ULONG blockoffset=block-ioc->block;
 769           ULONG blocklength=ioc->blocks-blockoffset;
 770
 771           if(blocks<blocklength) {
 772             blocklength=blocks;
 773           }
 774
 775           if((errorcode=validateiocache(ioc, blockoffset, blocklength))!=0) {
 776             break;
 777           }
 778
 779           if(((IPTR)buffer & 0x00000003) != 0) {
 780             CopyMem((UBYTE *)ioc->data + (blockoffset<<globals->shifts_block), buffer, blocklength<<globals->shifts_block);
 781           }
 782           else {
 783             CopyMemQuick((UBYTE *)ioc->data + (blockoffset<<globals->shifts_block), buffer, blocklength<<globals->shifts_block);
 784           }
 785
 786           block+=blocklength;
 787           blocks-=blocklength;
 788           buffer+=blocklength<<globals->shifts_block;
 789         }
 790       }
 791     }
 792     else {
 793       if((errorcode=copybackoverlappingiocaches(block, blocks))==0) {
 794         errorcode=transfer(DIO_READ, buffer, block, blocks);
 795       }
 796     }
 797   }
 798
 799   return(errorcode);
 800 }
 801
 802
 803
 804 void writethroughoverlappingiocaches(BLCK block, ULONG blocks, UBYTE *buffer) {
 805   struct IOCache *ioc;
 806   BLCK firstblock;
 807   BLCK lastblock;
 808
 809   /* This function copies data from the buffer to any IOCaches which fall (partially)
 810      in the region specified by the input parameters. */
 811
 812   firstblock=block & ~globals->iocache_mask;
 813   lastblock=(block+blocks-1) & ~globals->iocache_mask;
 814
 815   while(firstblock<=lastblock) {
 816     if((ioc=locateiocache(firstblock))!=0) {
 817       ULONG offsetinline;
 818       BLCK startinline;
 819       UBYTE *src;
 820       UBYTE *dst;
 821       ULONG maxinline, overlappedblocks;
 822
 823 //      _DEBUG(("IOCACHE: found overlapping cache (%ld-%ld) for block %ld of %ld blocks\n",ioc->block,ioc->block+ioc->blocks-1,block,blocks));
 824
 825       /* |-------|            |-----|               |-------|            |---------|
 826            |=======|        |=========|           |=======|                |=====|
 827
 828       block  blocks  firstblock  offsetinline  overlappedblocks
 829       ---------------------------------------------------------
 830         1      20        0           1                7     21 -( 0 + 1) = 20
 831                          8           0                8     21 -( 8 + 0) = 13
 832                         16           0                5     21 -(16 + 0) = 5
 833       ---------------------------------------------------------
 834         1       3        0           1                3      4 -( 0 + 1) = 3
 835        20       3       16           4                3     23 -(16 + 4) = 3
 836       ---------------------------------------------------------  */
 837
 838       offsetinline=firstblock<block ? block-firstblock : 0;
 839       startinline=firstblock+offsetinline;
 840       maxinline=ioc->blocks-offsetinline;
 841       overlappedblocks=block+blocks-startinline;
 842
 843       if(overlappedblocks>maxinline) {
 844         overlappedblocks=maxinline;
 845       }
 846
 847       /* startblock and endblock (exclusive) now contain the region to be
 848          overwritten in this IOCache. */
 849
 850       if(globals->iocache_copyback!=FALSE && (ioc->bits & IOC_DIRTY)!=0) {
 851
 852         /* Copyback mode is active!  We need to unmark any dirty blocks
 853            which are now overwritten. */
 854
 855         bmclr(ioc->dirty, 4, offsetinline, overlappedblocks);
 856       }
 857
 858       bmset(ioc->valid, 4, offsetinline, overlappedblocks);
 859
 860       src=buffer + ((startinline-block)<<globals->shifts_block);
 861       dst=(UBYTE *)ioc->data + (offsetinline<<globals->shifts_block);
 862
 863       if(((IPTR)buffer & 0x00000003) != 0) {
 864         CopyMem(src, dst, overlappedblocks<<globals->shifts_block);
 865       }
 866       else {
 867         CopyMemQuick(src, dst, overlappedblocks<<globals->shifts_block);
 868       }
 869     }
 870
 871     firstblock+=globals->iocache_sizeinblocks;
 872   }
 873 }
 874
 875
 876
 877 LONG writethrough(BLCK block, UBYTE *buffer, ULONG blocks) {
 878
 879   /* This function writes data to disk, it writes through existing
 880      cache buffers but doesn't cause reads if cache is in copyback
 881      mode. */
 882
 883   if(globals->iocache_lines!=0) {
 884     writethroughoverlappingiocaches(block,blocks,buffer);
 885   }
 886
 887   return(transfer(DIO_WRITE,buffer,block,blocks));
 888 }
 889
 890
 891
 892 LONG write(BLCK block, UBYTE *buffer, ULONG blocks) {
 893
 894   if(globals->iocache_lines!=0) {
 895     ULONG maxblocks=globals->iocache_sizeinblocks>>2;
 896
 897     if(maxblocks==0) {
 898       maxblocks=1;
 899     }
 900
 901     if(globals->iocache_copyback!=FALSE && blocks<=maxblocks) {
 902       struct IOCache *ioc;
 903       struct IOCache *ioc2;
 904       LONG errorcode;
 905
 906       if((errorcode=readonwriteintocache(block, &ioc))==0) {              /* a trick, which works because cachesystem consists of atleast 4 blocks. */
 907         if((errorcode=readonwriteintocache(block+blocks-1, &ioc2))==0) {
 908           WORD offsetinline=block-ioc->block;
 909
 910           writethroughoverlappingiocaches(block, blocks, buffer);  /* This function kills dirty blocks if needed. */
 911
 912           ioc->bits|=IOC_DIRTY;
 913
 914           if(ioc==ioc2) {
 915             bmset(ioc->dirty, 4, offsetinline, blocks);
 916             bmset(ioc->valid, 4, offsetinline, blocks);
 917           }
 918           else {
 919             LONG blocks2=globals->iocache_sizeinblocks-offsetinline;
 920
 921             ioc2->bits|=IOC_DIRTY;
 922
 923             bmset(ioc->dirty,  4, offsetinline, blocks2);
 924             bmset(ioc->valid,  4, offsetinline, blocks2);
 925             bmset(ioc2->dirty, 4, 0, blocks-blocks2);
 926             bmset(ioc2->valid, 4, 0, blocks-blocks2);
 927           }
 928         }
 929       }
 930
 931       return(errorcode);
 932     }
 933   }
 934
 935   return(writethrough(block, buffer, blocks));
 936 }
 937
 938
 939
 940 LONG getbuffer(UBYTE **tempbuffer, ULONG *maxblocks) {
 941   struct IOCache *ioc;
 942
 943   lruiocache(&ioc);         /** Might fail!!  Make sure it never does! */
 944   reuseiocache(ioc);
 945   *tempbuffer=ioc->data;
 946   *maxblocks=globals->iocache_sizeinblocks;
 947
 948   return(0);
 949 }