#include <stdlib.h>
#include <memory.h>
#include <sys/types.h>
#include <netinet/in.h>
#include "udanax.h"
Include dependency graph for multiloaf.cxx:
Go to the source code of this file.
(to be defined)
Definition in file multiloaf.cxx.
|
|
Definition at line 352 of file multiloaf.cxx. |
|
|
Definition at line 96 of file multiloaf.cxx. Referenced by fdhash(). |
|
|
Definition at line 94 of file multiloaf.cxx. Referenced by dumpfdhashtable(), fdhash(), and initincorealloctables(). |
|
|
Definition at line 91 of file multiloaf.cxx. Referenced by dumpfdorderedtable(), findfreeenoughloafinbucket(), initincorealloctables(), and savepartialdiskalloctabletodisk(). |
|
|
Definition at line 90 of file multiloaf.cxx. Referenced by addtofreediskstructures(), changefreediskstructures(), dumpfdorderedtable(), and findfreeenoughloafinbucket(). |
|
||||||||||||
|
??? (to be defined) Definition at line 339 of file multiloaf.cxx. References addtofreediskstructures(), typediskloafptr::diskblocknumber, freediskentry::freespaceinloaf, freediskentry::partialdiskblocknumber, and SIZEOFUBERDISKHEADER. Referenced by uniqueoutloaf().
00342 {
00343 freediskentry stuff;
00344
00345 /* L("addallocatedloaftopartialallocedtables entering\n"); */
00346 stuff.partialdiskblocknumber = htonl(dp.diskblocknumber);
00347 stuff.freespaceinloaf = htons(sizeof(typeuberrawdiskloaf) - size - SIZEOFUBERDISKHEADER);
00348 addtofreediskstructures(&stuff);
00349 /* L("addallocatedloaftopartialallocedtables exiting\n"); */
00350 }
|
|
|
??? (to be defined) Definition at line 271 of file multiloaf.cxx. References fdhash(), fdhashtable, fdorderedtable, freediskconscell::next, SIZEOFFREEDISKBUCKET, and freediskconscell::stuff. Referenced by addallocatedloaftopartialallocedtables(), changefreediskstructures(), partialdiskalloc(), and readpartialdiskalloctablefromdisk().
00273 {
00274 freediskconscell *newcons;
00275 freediskentry *newde;
00276 int i;
00277
00278 /* L("entering addtofreediskstructures\n"); */
00279 /* dumpincoretables(); */
00280 newde = (freediskentry *) malloc(sizeof(freediskentry));
00281 newcons = (freediskconscell *) malloc(sizeof(freediskconscell));
00282 newcons->stuff = newde;
00283 *newde = *diskentry;
00284 i = ntohs(diskentry->freespaceinloaf) / SIZEOFFREEDISKBUCKET;
00285 /* L("orderedtable i = %d\n",i); */
00286 newcons->next = fdorderedtable[i];
00287 fdorderedtable[i] = newcons;
00288
00289 newcons = (freediskconscell *) malloc(sizeof(freediskconscell));
00290 newcons->stuff = newde;
00291 i = fdhash(ntohl(diskentry->partialdiskblocknumber));
00292 /* L("hashtable i = %d\n",i); */
00293 newcons->next = fdhashtable[i];
00294 fdhashtable[i] = newcons;
00295
00296 /* dumpincoretables(); */
00297 /* L("exiting addtofreediskstructures\n"); */
00298 }
|
|
||||||||||||
|
??? (to be defined) Definition at line 409 of file multiloaf.cxx. References addtofreediskstructures(), assert, fdhash(), fdhashtable, fdorderedtable, freediskentry::freespaceinloaf, freediskconscell::next, NULL, freediskentry::partialdiskblocknumber, SIZEOFFREEDISKBUCKET, and freediskconscell::stuff. Referenced by partialdiskalloc().
00412 {
00413 int temp;
00414 freediskconscell *ptr, *newptr = NULL, *oldptr;
00415
00416 /* first change hash table */
00417 /* L("entering changefreediskstructures-----------------\n"); */
00418 /* dumpfdhashtable(); */
00419 temp = fdhash(ntohl(diskentry->partialdiskblocknumber));
00420 oldptr = 0;
00421 for (ptr = fdhashtable[temp]; ptr; ptr = ptr->next) {
00422 if (ptr->stuff->partialdiskblocknumber == diskentry->partialdiskblocknumber) {
00423 newptr = ptr;
00424 break;
00425 }
00426 oldptr = ptr;
00427 }
00428
00429 if (oldptr == newptr)
00430 assert(0); // in hashfromdiskblock not found
00431
00432 if (oldptr == 0) {
00433 fdhashtable[temp] = newptr->next;
00434 } else {
00435 oldptr->next = newptr->next;
00436 }
00437 /* next change ordered table */
00438 /* dumpfdhashtable(); */
00439 /* L(" I changefreediskstructures---------------\n"); */
00440 /* dumpfdorderedtable(); */
00441 temp = ntohs(diskentry->freespaceinloaf) / SIZEOFFREEDISKBUCKET;
00442 oldptr = 0;
00443 for (ptr = fdorderedtable[temp]; ptr; ptr = ptr->next) {
00444 if (ptr->stuff->partialdiskblocknumber == diskentry->partialdiskblocknumber) {
00445 newptr = ptr;
00446 break;
00447 }
00448 oldptr = ptr;
00449 }
00450 if (oldptr == 0) {
00451 fdorderedtable[temp] = newptr->next;
00452 } else {
00453 oldptr->next = newptr->next;
00454 }
00455 /* last change size in entry */
00456 newptr->stuff->freespaceinloaf = htons(newsize);
00457 addtofreediskstructures(newptr->stuff); /* just call standard routine */
00458 /* then delete stuff left lying around do this more efficiently later */
00459 free((char *)newptr->stuff);
00460 free((char *)newptr);
00461 /* dumpfdorderedtable(); */
00462 /* L(" X changefreediskstructures++++++++++++++++++++\n"); */
00463 }
|
|
|
??? (to be defined) Definition at line 125 of file multiloaf.cxx. References dumpfreediskentry(), fdhashtable, FDHASHTABLESIZE, L, freediskconscell::next, and freediskconscell::stuff. Referenced by dumpincoretables().
00126 {
00127 #ifndef DISTRIBUTION
00128 int i;
00129 freediskconscell *ptr;
00130
00131 L("dumping fdhashtable\n");
00132 for (i = 0; i < FDHASHTABLESIZE; i++) {
00133 if (fdhashtable[i]) {
00134 L("hashtable[%d]\n ", i);
00135 for (ptr = fdhashtable[i]; ptr; ptr = ptr->next)
00136 dumpfreediskentry(ptr->stuff);
00137 }
00138 }
00139 L("exiting dumping fdhashtable\n");
00140 #endif
00141 }
|
|
|
??? (to be defined) Definition at line 151 of file multiloaf.cxx. References dumpfreediskentry(), fdorderedtable, L, freediskconscell::next, NUMBEROFFREEDISKBUCKETS, SIZEOFFREEDISKBUCKET, and freediskconscell::stuff. Referenced by dumpincoretables().
00152 {
00153 #ifndef DISTRIBUTION
00154 int i;
00155 freediskconscell *ptr;
00156
00157 L("dumping fdorderedtable\n");
00158 for (i = 0; i < NUMBEROFFREEDISKBUCKETS; i++) {
00159 if (fdorderedtable[i]) {
00160 L("fdorderedtable[%d] s = %d\n", i, (i + 1) * SIZEOFFREEDISKBUCKET);
00161 for (ptr = fdorderedtable[i]; ptr; ptr = ptr->next) {
00162 dumpfreediskentry(ptr->stuff);
00163 }
00164 }
00165 }
00166 L("exiting dumping fdorderedtable\n");
00167 #endif
00168 }
|
|
|
??? (to be defined) Definition at line 108 of file multiloaf.cxx. References freediskentry::freespaceinloaf, L, and freediskentry::partialdiskblocknumber. Referenced by dumpfdhashtable(), and dumpfdorderedtable().
00110 {
00111 #ifndef DISTRIBUTION
00112 L("partialdiskblocknumber = %d freespaceinloaf = %d\n", ntohl(ptr->partialdiskblocknumber),
00113 ntohs(ptr->freespaceinloaf));
00114 #endif
00115 }
|
|
|
??? (to be defined) Definition at line 178 of file multiloaf.cxx. References dumpfdhashtable(), and dumpfdorderedtable(). Referenced by findandallocateinsidediskblocknumber(), and partialdiskalloc().
00179 {
00180 #ifndef DISTRIBUTION
00181 dumpfdorderedtable();
00182 dumpfdhashtable();
00183 #endif
00184 }
|
|
|
??? (to be defined) Definition at line 257 of file multiloaf.cxx. References FDHASHMULT, and FDHASHTABLESIZE. Referenced by addtofreediskstructures(), and changefreediskstructures().
00259 {
00260 return abs(diskblocknumber * FDHASHMULT) % FDHASHTABLESIZE;
00261 }
|
|
||||||||||||||||
|
??? (to be defined) Definition at line 473 of file multiloaf.cxx. References assert, dumphexstuff(), dumpincoretables(), humber, intof, L, movmem, and typeuberdiskloaf::numberofunterloafs. Referenced by partialdiskalloc().
00477 {
00478 char *lp;
00479 int number;
00480 int i;
00481 int temp;
00482 short loaftemp;
00483
00484 /* L("entering findandallocateinsidediskblocknumber\n"); */
00485 lp = /* (char * *)&loafp->fakepartialuberloaf; */ (char *)loafp + 6;
00486 /* zzz 1999** */
00487 number = ntohs(loafp->numberofunterloafs);
00488 for (i = 0; i < number; i++) {
00489 temp = intof((humber) lp);
00490 lp += temp;
00491 }
00492 /* L("2temp = %d lp = %x loafp = %x i = %d n = %d size = %d \n",temp,lp,loafp,i,0,size);
00493 * L("lp - loafp = %d ",lp-(char*)loafp); */
00494 loaftemp = ntohs(loafp->numberofunterloafs) + 1;
00495 loafp->numberofunterloafs = htons(loaftemp);
00496 temp = sizeof(typeuberrawdiskloaf) - (lp - (char *)loafp) - size;
00497 #ifndef DISTRIBUTION
00498 if (temp < 0) {
00499 dumphexstuff(lp);
00500 dumphexstuff((char *) loafp);
00501 L("2temp = %d lp = %x loafp = %x i = %d size = %d \n", temp, (int) lp, (int) loafp, i, size);
00502 L("lp - loafp = %d ", lp - (char *)loafp);
00503 L("expression = %d diskblocknumber = %d number = %d\n", temp, diskblocknumber, number);
00504 dumpincoretables();
00505 assert(0); // expression negative in findandallocateinsidediskblocknumber
00506 L("expression negative in findandallocateinsidediskblocknumber");
00507 return i;
00508 }
00509 #endif
00510 movmem(lp, lp + size, sizeof(typeuberrawdiskloaf) - (lp - (char *)loafp) - size);
00511 /* L(" B findandallocateinsidediskblocknumber\n"); */
00512 /* dumphexstuff(loafp); */
00513 return i;
00514 }
|
|
|
??? (to be defined) Definition at line 362 of file multiloaf.cxx. References fdorderedtable, freediskentry::freespaceinloaf, freediskconscell::next, NULL, NUMBEROFFREEDISKBUCKETS, SIZEOFFREEDISKBUCKET, and freediskconscell::stuff. Referenced by partialdiskalloc().
00364 {
00365 int i;
00366 freediskconscell *ptr;
00367
00368 for (i = size / SIZEOFFREEDISKBUCKET + 1; i < (int) NUMBEROFFREEDISKBUCKETS; i++) {
00369 for (ptr = fdorderedtable[i]; ptr; ptr->next) {
00370 if ((int) ntohs(ptr->stuff->freespaceinloaf) >= size)
00371 return ptr->stuff;
00372 }
00373 }
00374 return NULL;
00375 }
|
|
||||||||||||
|
??? (to be defined) Definition at line 615 of file multiloaf.cxx. References humber, intof, lengthof, and typeuberdiskloaf::numberofunterloafs. Referenced by changerefcount(), findnumberofdamnsons(), readloaf(), and writeloaf().
00618 {
00619 char *lp;
00620 unsigned int number, n;
00621 int i;
00622 unsigned int temp;
00623
00624 /* L("findinsideloaf ninsideloaf = %x \n",ninsideloaf); */
00625 /* L("findinsideloaf loafp = %x \n",loafp); */
00626 /* L("findinsideloaf lp = %x \n",lp); */
00627 lp = /* (char *)&loafp->fakepartialuberloaf; */ (char *)loafp + 6;
00628
00629 number = ntohs(loafp->numberofunterloafs);
00630 /* L("findinsideloaf number = %x \n",number); */
00631 for (i = 0; i < (int) number; i++) {
00632 n = lengthof((humber) loafp);
00633 /* L("findinsideloaf n = %x \n",n); */
00634 if (i == ninsideloaf) {
00635 /* L("findinsideloaf returning lp = %x \n",lp); */
00636 return lp;
00637 }
00638 temp = intof((humber) lp);
00639 if (n >= temp) {
00640 lp += n;
00641 } else {
00642 lp += temp;
00643 }
00644 }
00645 /* L("findinsideloaf returningNULL substitute\n"); */
00646 return lp;
00647 }
|
|
|
??? (to be defined) Definition at line 194 of file multiloaf.cxx. References fdhashtable, FDHASHTABLESIZE, fdorderedtable, NULL, and NUMBEROFFREEDISKBUCKETS. Referenced by initenffile(), and initheader().
00195 { /* since these tables are extern i.e. initialized, this routine is just a start
00196 * at restartability */
00197 int i;
00198
00199 for (i = 0; i < NUMBEROFFREEDISKBUCKETS; i++)
00200 fdorderedtable[i] = NULL;
00201
00202 for (i = 0; i < FDHASHTABLESIZE; i++)
00203 fdhashtable[i] = NULL;
00204 }
|
|
|
??? (to be defined) Definition at line 580 of file multiloaf.cxx. References humber, intof, lengthof, and typeuberdiskloaf::numberofunterloafs. Referenced by changerefcount().
00582 {
00583 char *lp;
00584 unsigned int number, n;
00585 int i;
00586 int ret;
00587 unsigned int temp;
00588
00589 ret = 0;
00590 lp = /* (char *)&loafp->fakepartialuberloaf; */ (char *)loafp + 6;
00591 number = ntohs(loafp->numberofunterloafs);
00592 for (i = 0; i < (int) number; i++) {
00593 n = lengthof((humber) /* loafp */ lp); /* ECH 8-29-88 */
00594 temp = intof((humber) lp);
00595 if (n >= temp) {
00596 lp += n;
00597 } else {
00598 lp += temp;
00599 }
00600 if (n != temp) {
00601 ret++;
00602 }
00603 }
00604 return ret;
00605 }
|
|
||||||||||||
|
??? (to be defined) Definition at line 524 of file multiloaf.cxx. References actuallyreadrawloaf(), addtofreediskstructures(), assert, changefreediskstructures(), diskalloc(), typediskloafptr::diskblocknumber, dumpincoretables(), findandallocateinsidediskblocknumber(), findfreeenoughloafinbucket(), freediskentry::freespaceinloaf, typediskloafptr::insidediskblocknumber, L, NUMBYTESINLOAF, freediskentry::partialdiskblocknumber, and SIZEOFUBERDISKHEADER. Referenced by orglwritepart2(), and uniqueoutloaf().
00527 {
00528 freediskentry diskentry, *freeentry;
00529 typediskloafptr dlp;
00530 typeuberdiskloaf loaf;
00531
00532 #ifndef DISTRIBUTION
00533 if (size != 1010 && size > 990) {
00534 L("partialdiskalloc size = %d\n", size);
00535 }
00536 #endif
00537 freeentry = findfreeenoughloafinbucket(size);
00538 /* L("partialdiskalloc freeentry = %x\n",freeentry); */
00539 if (!freeentry) {
00540 dlp = diskalloc();
00541 dlp.insidediskblocknumber = 0 /* 1 */ ;
00542 diskentry.partialdiskblocknumber = htonl(dlp.diskblocknumber);
00543 diskentry.freespaceinloaf = htons(NUMBYTESINLOAF - size - SIZEOFUBERDISKHEADER);
00544 addtofreediskstructures(&diskentry);
00545 /* L("partialdiskblock returning true with diskblocknumber = %d\n",dlp.diskblocknumber); */
00546 *newloafp = true;
00547 return dlp;
00548 } else {
00549 if (size >= ntohs(freeentry->freespaceinloaf)) {
00550 dumpincoretables();
00551 #ifndef DISTRIBUTION
00552 L("size = %d number = %d\n ", size, ntohl(freeentry->partialdiskblocknumber));
00553 assert(0); // partialdiskalloc found loaf too small
00554 #else
00555 assert(0);
00556 #endif
00557 }
00558 dlp.diskblocknumber = ntohl(freeentry->partialdiskblocknumber);
00559 actuallyreadrawloaf((typeuberrawdiskloaf *) & loaf, ntohl(freeentry->partialdiskblocknumber));
00560 dlp.insidediskblocknumber = findandallocateinsidediskblocknumber(dlp.diskblocknumber, size, &loaf);
00561
00562 if (dlp.insidediskblocknumber > 100)
00563 assert(0); // partialdiskalloc insidediskblocknumber >100
00564
00565 changefreediskstructures(freeentry, (int) (ntohs(freeentry->freespaceinloaf) - size));
00566 *newloafp = false;
00567 /* L("leaving partialdiskalloc o\n"); */
00568 return dlp;
00569 }
00570 }
|
|
|
??? (to be defined) Definition at line 308 of file multiloaf.cxx. References actuallyreadrawloaf(), addtofreediskstructures(), assert, diskfree(), freediskarray::nextdiskblocknumber, NFREEENTRYS, and PARTIALFREEDISKLOCATION. Referenced by readallocinfo().
00309 {
00310 int first = true;
00311
00312 freediskarray loaf;
00313 int blocknumber;
00314 for (blocknumber = PARTIALFREEDISKLOCATION; blocknumber; blocknumber = ntohl(loaf.nextdiskblocknumber)) {
00315 /* L("readpartialdiskalloctablefromdisk reading block# %d\n",blocknumber); */
00316
00317 actuallyreadrawloaf((typeuberrawdiskloaf *) &loaf, blocknumber);
00318 if (!first)
00319 diskfree(blocknumber);
00320
00321 first = false;
00322 if (ntohl(loaf.numberofentrysinthisblock) > NFREEENTRYS)
00323 assert(0); // numberofentrysinthisblock too big!
00324
00325 int i;
00326 for (i = 0; i < (int) ntohl(loaf.numberofentrysinthisblock); i++)
00327 addtofreediskstructures(&(loaf.freeentryarray[i]));
00328 }
00329 }
|
|
|
??? (to be defined) Definition at line 214 of file multiloaf.cxx. References actuallywriteloaf(), diskalloc(), typediskloafptr::diskblocknumber, fdorderedtable, freediskarray::freeentryarray, freediskconscell::next, freediskarray::nextdiskblocknumber, NFREEENTRYS, freediskarray::numberofentrysinthisblock, NUMBEROFFREEDISKBUCKETS, PARTIALFREEDISKLOCATION, and freediskconscell::stuff. Referenced by diskallocexit().
00215 {
00216 freediskarray loaf;
00217 int blocknumber, i;
00218 int bucket;
00219 freediskconscell *ptr;
00220 typediskloafptr diskalloc(), dl;
00221
00222 bucket = 0;
00223 ptr = fdorderedtable[bucket];
00224 blocknumber = PARTIALFREEDISKLOCATION;
00225 for (i = 0;; i++, ptr = ptr->next) {
00226 for (; ptr == 0;) {
00227 bucket++;
00228 if (bucket >= NUMBEROFFREEDISKBUCKETS) {
00229 /* goto endofbuckets; */
00230 loaf.numberofentrysinthisblock = htonl(i);
00231 loaf.nextdiskblocknumber = 0;
00232 actuallywriteloaf((typeuberrawdiskloaf *) & loaf, blocknumber);
00233 return;
00234 }
00235 ptr = fdorderedtable[bucket];
00236 }
00237 loaf.freeentryarray[i] = *(ptr->stuff);
00238 if (i >= (int) NFREEENTRYS - 1) {
00239 dl = diskalloc();
00240 loaf.nextdiskblocknumber = htonl(dl.diskblocknumber);
00241 loaf.numberofentrysinthisblock = htonl(NFREEENTRYS);
00242 actuallywriteloaf((typeuberrawdiskloaf *) & loaf, blocknumber);
00243 i = 0;
00244 blocknumber = dl.diskblocknumber;
00245 }
00246 }
00247 }
|
|
|
Definition at line 98 of file multiloaf.cxx. Referenced by addtofreediskstructures(), changefreediskstructures(), dumpfdhashtable(), and initincorealloctables(). |
|
|
Definition at line 92 of file multiloaf.cxx. Referenced by addtofreediskstructures(), changefreediskstructures(), dumpfdorderedtable(), findfreeenoughloafinbucket(), initincorealloctables(), and savepartialdiskalloctabletodisk(). |
1.3.4