rom/filesys/SFS/FS/adminspaces.c

   1 #include <dos/dos.h>
   2 #include <exec/types.h>
   3
   4 #include "adminspaces.h"
   5
   6 #include "bitmap_protos.h"
   7 #include "cachebuffers_protos.h"
   8 #include "debug.h"
   9 #include "fs.h"
  10 #include "transactions_protos.h"
  11 #include "asmsupport.h"
  12 #include "req_protos.h"
  13 #include "globals.h"
  14
  15 extern LONG readcachebuffercheck(struct CacheBuffer **,ULONG,ULONG);
  16
  17 LONG allocadminspace(struct CacheBuffer **returned_cb) {
  18   struct CacheBuffer *cb;
  19   BLCK adminspaceblock=globals->block_adminspace;
  20   LONG errorcode;
  21
  22   /* Returns a new, cleared CacheBuffer with blckno correctly
  23      initialised.  This function can only be called from
  24      within an operation.  *returned_cb is not destroyed
  25      when there was an error. */
  26
  27   while((errorcode=readcachebuffercheck(&cb,adminspaceblock,ADMINSPACECONTAINER_ID))==0) {
  28     struct fsAdminSpaceContainer *asc=cb->data;
  29     struct fsAdminSpace *as=asc->adminspace;
  30     LONG adminspaces=(globals->bytes_block-sizeof(struct fsAdminSpaceContainer))/sizeof(struct fsAdminSpace);
  31
  32     while(adminspaces-->0) {
  33       WORD bitoffset;
  34
  35       if(as->be_space!=0 && (bitoffset=bfffz(BE2L(as->be_bits),0)) < 32) {
  36         BLCK emptyadminblock=BE2L(as->be_space)+bitoffset;
  37
  38         preparecachebuffer(cb);
  39
  40         as->be_bits|=L2BE(1<<(31-bitoffset));
  41
  42         if((errorcode=storecachebuffer(cb))!=0) {
  43           return(errorcode);
  44         }
  45
  46         if((cb=newcachebuffer(emptyadminblock))==0) {
  47           return(ERROR_NO_FREE_STORE);
  48         }
  49
  50         *returned_cb=cb;
  51
  52         return(0);
  53       }
  54       as++;
  55     }
  56
  57     if((adminspaceblock=BE2L(asc->be_next))==0) {
  58       ULONG startblock;
  59
  60       /* If we get here it means current adminspace areas are all filled.
  61          We would now need to find a new area and create a fsAdminSpace
  62          structure in one of the AdminSpaceContainer blocks.  If these
  63          don't have any room left for new adminspace areas a new
  64          AdminSpaceContainer would have to be created first which is
  65          placed as the first block in the newly found admin area. */
  66
  67       adminspaceblock=globals->block_adminspace;
  68
  69       if((errorcode=findandmarkspace(32,&startblock))==0) {
  70         while((errorcode=readcachebuffercheck(&cb,adminspaceblock,ADMINSPACECONTAINER_ID))==0) {
  71           struct fsAdminSpaceContainer *asc=cb->data;
  72           struct fsAdminSpace *as=asc->adminspace;
  73           LONG adminspaces=(globals->bytes_block-sizeof(struct fsAdminSpaceContainer))/sizeof(struct fsAdminSpace);
  74
  75           while(adminspaces-->0 && as->be_space!=0) {
  76             as++;
  77           }
  78
  79           if(adminspaces>=0) {
  80             /* Found a unused AdminSpace in this AdminSpaceContainer! */
  81
  82             preparecachebuffer(cb);
  83
  84             as->be_space=L2BE(startblock);
  85             as->be_bits=0;
  86
  87             errorcode=storecachebuffer(cb);
  88             break;
  89           }
  90
  91           if(BE2L(asc->be_next)==0) {
  92
  93             /* Oh-oh... we marked our new adminspace area in use, but we couldn't
  94                find space to store a fsAdminSpace structure in the existing
  95                fsAdminSpaceContainer blocks.  This means we need to create and
  96                link a new fsAdminSpaceContainer as the first block in our newly
  97                marked adminspace. */
  98
  99             preparecachebuffer(cb);
 100
 101             asc->be_next=L2BE(startblock);
 102
 103             if((errorcode=storecachebuffer(cb))!=0) {
 104               return(errorcode);
 105             }
 106
 107             /* Now preparing new AdminSpaceContainer */
 108
 109             if((cb=newcachebuffer(startblock))==0) {
 110               return(ERROR_NO_FREE_STORE);
 111             }
 112
 113             asc=cb->data;
 114
 115             asc->bheader.id=ADMINSPACECONTAINER_ID;
 116             asc->bheader.be_ownblock=L2BE(startblock);
 117             asc->be_previous=L2BE(adminspaceblock);
 118
 119             asc->adminspace[0].be_space=L2BE(startblock);
 120             asc->adminspace[0].be_bits=L2BE(0x80000000);
 121             asc->bits=32;
 122
 123             if((errorcode=storecachebuffer(cb))!=0) {
 124               return(errorcode);
 125             }
 126
 127             adminspaceblock=startblock;
 128             break;   /* Breaks through to outer loop! */
 129           }
 130
 131           adminspaceblock=BE2L(asc->be_next);
 132         }
 133       }
 134
 135       if(errorcode!=0) {
 136         return(errorcode);
 137       }
 138     }
 139   }
 140
 141   return(errorcode);
 142 }
 143
 144
 145
 146 LONG freeadminspace(BLCK block) {
 147   struct CacheBuffer *cb;
 148   BLCK adminspaceblock=globals->block_adminspace;
 149   LONG errorcode;
 150
 151   _DEBUG(("freeadminspace: Entry -- freeing block %ld\n",block));
 152
 153   while((errorcode=readcachebuffercheck(&cb,adminspaceblock,ADMINSPACECONTAINER_ID))==0) {
 154     struct fsAdminSpaceContainer *asc=cb->data;
 155     struct fsAdminSpace *as=asc->adminspace;
 156     LONG adminspaces=(globals->bytes_block-sizeof(struct fsAdminSpaceContainer))/sizeof(struct fsAdminSpace);
 157
 158     while(adminspaces-->0) {
 159       if(block>=BE2L(as->be_space) && block<BE2L(as->be_space)+32) {
 160         WORD bitoffset=block-BE2L(as->be_space);
 161
 162         /* block to be freed has been located */
 163
 164         _DEBUG(("freeadminspace: Block to be freed is located in AdminSpaceContainer block at %ld\n",adminspaceblock));
 165
 166         preparecachebuffer(cb);
 167
 168         as->be_bits&=~(L2BE(1<<(31-bitoffset)));
 169
 170         if((errorcode=storecachebuffer(cb))==0) {
 171           errorcode=addfreeoperation(block);
 172         }
 173
 174         /*** Extra code need to be added here to free the AdminSpace structure if it isn't
 175              being used anymore.  This could mean that the entire AdminSpaceBlock could no
 176              longer be needed either.... */
 177
 178         return(errorcode);
 179       }
 180
 181       as++;
 182     }
 183
 184     if((adminspaceblock=BE2L(asc->be_next))==0) {
 185       break;
 186     }
 187   }
 188
 189   if(errorcode==0) {
 190     /*** Strange.  We have been looking for the block to free, but couldn't find it in any
 191          of the AdminSpace containers... */
 192
 193     req("Unable to free an administration block.\nThe block cannot be found.", "Ok");
 194
 195     return(ERROR_OBJECT_NOT_FOUND);
 196   }
 197
 198   return(errorcode);
 199 }