# ubixfs.c

Go to the documentation of this file.

    00001 /*****************************************************************************************
    00002  Copyright (c) 2002-2004 The UbixOS Project
    00003  All rights reserved.
    00004
    00005  Redistribution and use in source and binary forms, with or without modification, are
    00006  permitted provided that the following conditions are met:
    00007
    00008  Redistributions of source code must retain the above copyright notice, this list of
    00009  conditions, the following disclaimer and the list of authors.  Redistributions in binary
    00010  form must reproduce the above copyright notice, this list of conditions, the following
    00011  disclaimer and the list of authors in the documentation and/or other materials provided
    00012  with the distribution. Neither the name of the UbixOS Project nor the names of its
    00013  contributors may be used to endorse or promote products derived from this software
    00014  without specific prior written permission.
    00015
    00016  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
    00017  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
    00018  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
    00019  THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    00020  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
    00021  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    00022  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
    00023  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
    00024  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    00025
    00026  $Id: ubixfs_8c-source.html 88 2016-01-12 00:11:29Z reddawg $
    00027
    00028 *****************************************************************************************/
    00029
    00030 #include <ubixfs/ubixfs.h>
    00031 #include <ubixfs/dirCache.h>
    00032 #include <vfs/vfs.h>
    00033 #include <ubixos/types.h>
    00034 #include <ubixos/sched.h>
    00035 #include <ubixos/kpanic.h>
    00036 #include <ubixos/exec.h>
    00037 #include <lib/kmalloc.h>
    00038 #include <lib/string.h>
    00039 #include <lib/kprintf.h>
    00040 #include <assert.h>
    00041
    00042 /* Static defines */
    00043 static int ubixfs_loadData(fileDescriptor *fd,char *data,uInt32 size,uInt32 batIndex);
    00044
    00045
    00046 static int openFileUbixFS(const char *file, fileDescriptor *fd) {
    00047   //int x = 0;
    00048 /* mji  struct directoryEntry *dirEntry = (struct directoryEntry *)kmalloc(0x4000); */
    00049   struct cacheNode * cacheNode = NULL;
    00050   //struct directoryEntry * dirEntry = NULL;
    00051   struct ubixFSInfo *fsInfo = fd->mp->fsInfo;
    00052
    00053
    00054
    00055 /* kprintf("openFileUbixFS(%s), cwd: %s\n", file, _current->oInfo.cwd); */
    00056
    00057 //if (fsInfo->dirCache == NULL) kprintf("dirCache is null!\n");
    00058   assert(fd);
    00059   assert(fd->mp);
    00060   assert(fd->mp->device);
    00061   assert(fd->mp->device->devInfo);
    00062   assert(fd->mp->device->devInfo->read);
    00063   assert(fsInfo);
    00064   assert(fsInfo->dirCache);
    00065   assert(file);
    00066
    00067   if ((fd->mode & fileRead) == fileRead) {
    00068     do {
    00069       cacheNode = ubixfs_cacheFind(fsInfo->dirCache,(char *) file);
    00070       if (cacheNode == NULL) return 0;
    00071       if (cacheNode->present == 1) break;
    00072       assert(cacheNode->size);
    00073       if (*cacheNode->size != 0 && cacheNode->info == NULL) {
    00074         //kprintf("caching name(size): %s(%d)\n",cacheNode->name,*cacheNode->size);
    00075         cacheNode->info = kmalloc(UBIXFS_ALIGN(*cacheNode->size));
    00076         fd->size = *cacheNode->size;
    00077         assert(cacheNode->startCluster);
    00078         ubixfs_loadData(fd,
    00079                         cacheNode->info,
    00080                         *cacheNode->size,
    00081                         *cacheNode->startCluster);
    00082         cacheNode->present = 1;
    00083       } /* if */
    00084     } while(1);
    00085
    00086     assert(cacheNode);
    00087     if (cacheNode == NULL) return 0; /* this should be caught above */
    00088
    00089     fd->start    = *cacheNode->startCluster;
    00090     fd->size     = *cacheNode->size;
    00091     fd->perms    = *cacheNode->permissions;
    00092     fd->cacheNode = cacheNode; /* Directory Start Sector */
    00093     /*
    00094     if (cacheNode->size != 0x0 && cacheNode->info == NULL) {
    00095       cacheNode->info = kmalloc(UBIXFS_ALIGN(*cacheNode->size));
    00096       ubixfs_loadData(fd,cacheNode->info,cacheNode->size,cacheNode->startCluster);
    00097       cacheNode->present = 0x1;
    00098       }
    00099      */
    00100     return(0x1);
    00101   }
    00102   else
    00103     if ((fd->mode & fileWrite) == fileWrite) {
    00104 kprintf("Ouch! in filewrite!\n");
    00105 #if 0
    00106       fd->start    = dirEntry->startCluster;
    00107       fd->size     = dirEntry->size;
    00108       fd->perms    = dirEntry->permissions;
    00109      // fd->dirBlock = 0x0; /* Directory Start Sector */
    00110 #endif
    00111       return(0x1);
    00112     }
    00113
    00114   return 0;
    00115
    00116   }
    00117
    00118 int writeFileByte(int ch, fileDescriptor *fd, long offset) {
    00119
    00120   int blockCount = 0x0,batIndex = 0x0,batIndexPrev = 0x0;
    00121   uInt32 i = 0x0;
    00122   struct directoryEntry *dirEntry = 0x0;
    00123   struct ubixFSInfo *fsInfo = NULL;
    00124
    00125   assert(fd);
    00126   assert(fd->mp);
    00127   assert(fd->mp->diskLabel);
    00128
    00129   batIndexPrev = fd->start;
    00130   fsInfo = fd->mp->fsInfo;
    00131
    00132   /* Find Out How Many Blocks Long This File Is */
    00133   blockCount = (offset/4096);
    00134
    00135   /* Find The Block If It Doesn't Exist We Will Have To Allocate One */
    00136   for (i=0x0; i <= fd->mp->diskLabel->partitions[fd->mp->partition].pBatSize;
    00137        i++) {
    00138     batIndex = fsInfo->blockAllocationTable[batIndexPrev].nextBlock;
    00139     if (batIndex == 0x0) {
    00140       break;
    00141       }
    00142     batIndexPrev = batIndex;
    00143     }
    00144
    00145   if ((offset%4096 == 0) && (fd->status == fdRead)) {
    00146       fd->status = fdOpen;
    00147       }
    00148
    00149   /* If batIndex == 0x0 Then We Must Allocate A New Block */
    00150   if (batIndex == 0x0) {
    00151     for (i=1;i < fsInfo->batEntries;i++) {
    00152       if (fsInfo->blockAllocationTable[i].attributes == 0x0) {
    00153         fsInfo->blockAllocationTable[batIndexPrev].nextBlock = i;
    00154         fsInfo->blockAllocationTable[batIndex].nextBlock     = -1;
    00155         batIndex  = i;
    00156         fd->start = i;
    00157         break;
    00158         }
    00159       }
    00160     /* fd->mp->drive->read(fd->mp->drive->driveInfoStruct,diskLabel->partitions[0].pOffset+blockAllocationTable[batIndex].realSector,8,fd->buffer); */
    00161     fd->buffer[offset-(blockCount*4096)] = ch;
    00162     fd->mp->device->devInfo->write(fd->mp->device->devInfo->info,fd->buffer,fd->mp->diskLabel->partitions[fd->mp->partition].pOffset+fsInfo->blockAllocationTable[batIndex].realSector,8);
    00163     }
    00164   else {
    00165     if (fd->status != fdRead) {
    00166       fd->mp->device->devInfo->read(fd->mp->device->devInfo->info,fd->buffer,fd->mp->diskLabel->partitions[fd->mp->partition].pOffset+fsInfo->blockAllocationTable[batIndex].realSector,8);
    00167       fd->status = fdRead;
    00168       }
    00169     fd->buffer[offset-(blockCount*4096)] = ch;
    00170     fd->mp->device->devInfo->write(fd->mp->device->devInfo->info,fd->buffer,fd->mp->diskLabel->partitions[fd->mp->partition].pOffset+fsInfo->blockAllocationTable[batIndex].realSector,8);
    00171     }
    00172   if ((uInt32)offset > fd->size) {
    00173     fd->size = offset;
    00174     dirEntry = (struct directoryEntry *)kmalloc(4096);
    00175   /*
    00176     fd->mp->device->devInfo->read(fd->mp->device->devInfo->info,dirEntry,(fd->mp->diskLabel->partitions[fd->mp->partition].pOffset+fsInfo->blockAllocationTable[fd->dirBlock].realSector),8);
    00177   */
    00178     for (i=0x0;i<(4096/sizeof(struct directoryEntry));i++) {
    00179       if ((int)!strcmp(dirEntry[i].fileName,fd->fileName))
    00180         break;
    00181       }
    00182     dirEntry[i].size = fd->size;
    00183 /*
    00184     fd->mp->device->devInfo->write(fd->mp->device->devInfo->info,dirEntry,(fd->mp->diskLabel->partitions[fd->mp->partition].pOffset+fsInfo->blockAllocationTable[fd->dirBlock].realSector),8);
    00185 */
    00186     kfree(dirEntry);
    00187     }
    00188   return(ch);
    00189   }
    00190
    00191 /* Verified Functions */
    00192
    00193
    00194 int readUbixFS(fileDescriptor *fd,char *data,uInt32 offset,long size) {
    00195   int i = 0x0;
    00196   char *buffer = 0x0;
    00197   struct ubixFSInfo *fsInfo = NULL;
    00198
    00199   assert(fd);
    00200   assert(fd->mp);
    00201   assert(fd->mp->fsInfo);
    00202
    00203   fsInfo = fd->mp->fsInfo;
    00204
    00205   if (fd->cacheNode->present != 1)
    00206     kpanic("ERROR with cache node\n");
    00207
    00208   buffer = (char *)fd->cacheNode->info;
    00209
    00210   for (i=0x0; i<size; i++) {
    00211     if (offset > fd->size) {
    00212       /* Set File EOF If There Is Nothing To Do */
    00213       /* data[i] = '\0'; Is this safe? */
    00214       fd->status = fdEof;
    00215       return(size);
    00216       }
    00217     /* Copy Data From Buffer To Data */
    00218     data[i] = buffer[i + offset];
    00219     }
    00220   /* Return */
    00221   return(size);
    00222   }
    00223
    00224
    00225 /************************************************************************
    00226
    00227 Function: int writeUbixFS(fileDescriptor *fd,char *data,long offset,long size)
    00228 Description: Write Data Into File
    00229 Notes:
    00230
    00231 ************************************************************************/
    00232 int writeUbixFS(fileDescriptor *fd,char *data,long offset,long size) {
    00233   uInt32 blockOffset    = 0x0;
    00234   uInt32 blockIndex;
    00235   uInt32 blockIndexPrev;
    00236   uInt32 i              = 0x0;
    00237   struct ubixFSInfo *fsInfo = NULL;
    00238   struct directoryEntry *dirEntry = 0x0;
    00239
    00240   assert(fd);
    00241   assert(fd->mp);
    00242   assert(fd->mp->fsInfo);
    00243   assert(fd->mp->device);
    00244   assert(fd->mp->device->devInfo);
    00245
    00246   blockIndex = blockIndexPrev = fd->start;
    00247   fsInfo = fd->mp->fsInfo;
    00248
    00249   blockOffset = (offset/0x1000);
    00250
    00251   if (fd->size != 0x0) {
    00252     for (i = 0x0;i < blockOffset;i++) {
    00253       blockIndex = fsInfo->blockAllocationTable[blockIndexPrev].nextBlock;
    00254         if ((int)blockIndex == EOBC) {
    00255           blockIndex = getFreeBlocks(1,fd);
    00256           fsInfo->blockAllocationTable[blockIndexPrev].nextBlock = blockIndex;
    00257           fsInfo->blockAllocationTable[blockIndex].nextBlock = EOBC;
    00258           break;
    00259           }
    00260         blockIndexPrev = blockIndex;
    00261       }
    00262     }
    00263
    00264   fd->mp->device->devInfo->read(fd->mp->device->devInfo->info,fd->buffer,fd->mp->diskLabel->partitions[fd->mp->partition].pOffset+fsInfo->blockAllocationTable[blockIndex].realSector,blockSize);
    00265   for (i = 0x0;i < (uInt32)size;i++) {
    00266
    00267     fd->buffer[(offset- (blockOffset *0x1000))] = data[i];
    00268     offset++;
    00269
    00270     if (offset%4096 == 0x0) {
    00271       blockOffset++;
    00272       fd->mp->device->devInfo->write(fd->mp->device->devInfo->info,fd->buffer,fd->mp->diskLabel->partitions[fd->mp->partition].pOffset+fsInfo->blockAllocationTable[blockIndex].realSector,blockSize);
    00273
    00274       if (fsInfo->blockAllocationTable[blockIndex].nextBlock == EOBC) {
    00275         blockIndexPrev = blockIndex;
    00276         blockIndex = getFreeBlocks(1,fd);
    00277         fsInfo->blockAllocationTable[blockIndexPrev].nextBlock = blockIndex;
    00278         fsInfo->blockAllocationTable[blockIndex].nextBlock     = EOBC;
    00279         }
    00280       else {
    00281         blockIndex = fsInfo->blockAllocationTable[blockIndex].nextBlock;
    00282         fd->mp->device->devInfo->read(fd->mp->device->devInfo->info,fd->buffer,fd->mp->diskLabel->partitions[fd->mp->partition].pOffset+fsInfo->blockAllocationTable[blockIndex].realSector,blockSize);
    00283         }
    00284       }
    00285     }
    00286   fd->mp->device->devInfo->write(fd->mp->device->devInfo->info,fd->buffer,fd->mp->diskLabel->partitions[fd->mp->partition].pOffset+fsInfo->blockAllocationTable[blockIndex].realSector,blockSize);
    00287
    00288   if ((uInt32)offset > fd->size) {
    00289     fd->size = offset;
    00290     dirEntry = (struct directoryEntry *)kmalloc(4096);
    00291 /*
    00292     fd->mp->device->devInfo->read(fd->mp->device->devInfo->info,dirEntry,(fd->mp->diskLabel->partitions[fd->mp->partition].pOffset+fsInfo->blockAllocationTable[fd->dirBlock].realSector),blockSize);
    00293 */
    00294     for (i=0x0;i<(4096/sizeof(struct directoryEntry));i++) {
    00295       if ((int)!strcmp(dirEntry[i].fileName,fd->fileName))
    00296         break;
    00297       }
    00298     dirEntry[i].size = fd->size;
    00299     dirEntry[i].startCluster = fd->start;
    00300 /*
    00301     fd->mp->device->devInfo->write(fd->mp->device->devInfo->info,dirEntry,(fd->mp->diskLabel->partitions[fd->mp->partition].pOffset+fsInfo->blockAllocationTable[fd->dirBlock].realSector),blockSize);
    00302 */
    00303     kfree(dirEntry);
    00304     }
    00305   /* Return */
    00306   return(size);
    00307   }
    00308
    00309 void ubixFSUnlink(char *path,struct vfs_mountPoint *mp) {
    00310   int x=0;
    00311   struct directoryEntry *dirEntry = (struct directoryEntry *)kmalloc(0x1000);
    00312   struct ubixFSInfo *fsInfo = mp->fsInfo;
    00313
    00314   mp->device->devInfo->read(mp->device->devInfo->info,dirEntry,(mp->diskLabel->partitions[mp->partition].pOffset+fsInfo->blockAllocationTable[fsInfo->rootDir].realSector),8);
    00315
    00316   for (x=0;(uInt32)x<(4096/sizeof(struct directoryEntry));x++) {
    00317     if ((int)!strcmp(dirEntry[x].fileName,path)) {
    00318       dirEntry[x].attributes |= typeDeleted;
    00319       dirEntry[x].fileName[0] = '?';
    00320       mp->device->devInfo->write(mp->device->devInfo->info,dirEntry,(mp->diskLabel->partitions[mp->partition].pOffset+fsInfo->blockAllocationTable[fsInfo->rootDir].realSector),8);
    00321       return;
    00322       }
    00323     }
    00324   kprintf("File Not Found\n");
    00325   return;
    00326   }
    00327
    00328
    00329 /*****************************************************************************************
    00330
    00331 Function: static
    00332           int ubixfs_loadData(fileDescriptor *fd,char *data,uInt32 size,uInt32 batIndex)
    00333
    00334 Description: This will load the node data in from the disk
    00335
    00336 Notes:
    00337   07/23/2004 - This loads complete blocks from disk so it is aligned to 0x1000 not the
    00338                actual file size
    00339
    00340 *****************************************************************************************/
    00341 static int ubixfs_loadData(fileDescriptor *fd,char *data,uInt32 size,uInt32 batIndex) {
    00342   uInt32 i = 0x0;
    00343
    00344   struct ubixFSInfo *fsInfo = NULL;
    00345
    00346   assert(fd);
    00347   assert(fd->mp);
    00348   assert(fd->mp->fsInfo);
    00349
    00350   fsInfo = fd->mp->fsInfo;
    00351
    00352   size = UBIXFS_ALIGN(size);
    00353   /* Loop by block size */
    00354
    00355   for (i=0x0; i<size; i += (UBIXFS_BLOCKSIZE_BYTES)) {
    00356   /* Get next block if we are ready for it */
    00357     if (i != 0x0)
    00358       batIndex = fsInfo->blockAllocationTable[batIndex].nextBlock;
    00359   /* Read data in from media */
    00360     fd->mp->device->devInfo->read(fd->mp->device->devInfo->info,data+i,fd->mp->diskLabel->partitions[fd->mp->partition].pOffset+fsInfo->blockAllocationTable[batIndex].realSector,blockSize);
    00361     }
    00362   /* Return */
    00363   return(0x0);
    00364   }
    00365
    00366
    00367 /*****************************************************************************************
    00368
    00369 Function: int ubixfs_initialize()
    00370
    00371 Description: This will initialize a mount point it loads the BAT and Caches the rootDir
    00372
    00373 Notes:
    00374
    00375 *****************************************************************************************/
    00376 int ubixfs_initialize(struct vfs_mountPoint *mp) {
    00377   struct ubixFSInfo *fsInfo = 0x0;
    00378
    00379   assert(mp);
    00380   assert(mp->diskLabel);
    00381   assert(mp->diskLabel->partitions);
    00382
    00383   mp->fsInfo = (struct ubixFSInfo *)kmalloc(sizeof(struct ubixFSInfo));
    00384   assert(mp->fsInfo);
    00385
    00386   fsInfo = mp->fsInfo;
    00387   fsInfo->rootDir = 0x0; /* Root directory is always 0x0 on the UbixFS */
    00388
    00389   /*
    00390    Check the disk label to ensure this is an UbixFS partition
    00391   */
    00392   if ((mp->diskLabel->magicNum == UBIXDISKMAGIC) &&  (mp->diskLabel->magicNum2 == UBIXDISKMAGIC)) {
    00393
    00394     /* Allocate memory for BAT */
    00395     fsInfo->blockAllocationTable = (struct blockAllocationTableEntry *)kmalloc(mp->diskLabel->partitions[mp->partition].pBatSize * 512);
    00396     assert(fsInfo->blockAllocationTable);
    00397
    00398     /* Set up the amount of BAT entries */
    00399     fsInfo->batEntries = (mp->diskLabel->partitions[mp->partition].pBatSize*512) / sizeof(struct blockAllocationTableEntry);
    00400
    00401     /* Read the BAT to memory */
    00402     assert(mp->device->devInfo->read);
    00403     mp->device->devInfo->read(mp->device->devInfo->info,
    00404                              fsInfo->blockAllocationTable,
    00405                              mp->diskLabel->partitions[mp->partition].pOffset,
    00406                              mp->diskLabel->partitions[mp->partition].pBatSize);
    00407
    00408     /* Set up root directory cache */
    00409     fsInfo->dirCache = ubixfs_cacheNew("/");
    00410     assert(fsInfo->dirCache);
    00411     fsInfo->dirCache->info = (struct directoryEntry *)kmalloc(0x4000);  /* allocate root dir */
    00412     fsInfo->dirCache->present = 1;
    00413     fsInfo->dirCache->size = kmalloc(sizeof(fsInfo->dirCache->size));
    00414     fsInfo->dirCache->startCluster = kmalloc(sizeof(fsInfo->dirCache->startCluster));
    00415     fsInfo->dirCache->attributes = kmalloc(sizeof(fsInfo->dirCache->attributes));
    00416     fsInfo->dirCache->permissions = kmalloc(sizeof(fsInfo->dirCache->permissions));
    00417
    00418     *fsInfo->dirCache->size = 0x4000;
    00419     *fsInfo->dirCache->startCluster = fsInfo->rootDir;
    00420
    00421     assert(fsInfo->dirCache->info);
    00422     /* Read root dir in from disk it is always 0x4000 bytes long */
    00423     mp->device->devInfo->read(mp->device->devInfo->info,
    00424                               fsInfo->dirCache->info,
    00425                               (mp->diskLabel->partitions[mp->partition].pOffset+fsInfo->blockAllocationTable[fsInfo->rootDir].realSector),
    00426                               0x4000 / 512);
    00427
    00428     /* Start our ubixfs_thread to manage the mount point */
    00429     /*
    00430     UBU disable for now
    00431     execThread(ubixfs_Thread,(uInt32)(kmalloc(0x2000)+0x2000),0x0);
    00432     */
    00433     kprintf("  Offset: [%i], Partition: [%i]\n",
    00434     mp->diskLabel->partitions[mp->partition].pOffset,mp->partition);
    00435     kprintf("UbixFS Initialized\n");
    00436     return(0x1);
    00437     }
    00438
    00439   kprintf("Not a valid UbixFS disk.\n");
    00440   /* Return */
    00441   return(0x0);
    00442   }
    00443
    00444 /*****************************************************************************************
    00445
    00446 Function: int ubixfs_init()
    00447
    00448 Description: This is the master initialization for the Ubix File System it will make the
    00449              OS UbixFS aware.
    00450              It does not in any way shape or form connect a mount point an medium that is
    00451              upto the ubixfs_initialize() function
    00452
    00453 Notes:
    00454
    00455 *****************************************************************************************/
    00456 int ubixfs_init() {
    00457   /* Set up our file system structure */
    00458   struct fileSystem ubixFileSystem =
    00459    {NULL,                         /* prev        */
    00460     NULL,                         /* next        */
    00461     (void *)ubixfs_initialize,    /* vfsInitFS   */
    00462     (void *)readUbixFS,           /* vfsRead     */
    00463     (void *)writeUbixFS,          /* vfsWrite    */
    00464     (void *)openFileUbixFS,       /* vfsOpenFile */
    00465     (void *)ubixFSUnlink,         /* vfsUnlink   */
    00466     (void *)ubixFSmkDir,          /* vfsMakeDir  */
    00467     NULL,                         /* vfsRemDir   */
    00468     NULL,                         /* vfsSync     */
    00469     0                             /* vfsType     */
    00470    }; /* ubixFileSystem */
    00471
    00472   /* Add UbixFS */
    00473   if (vfsRegisterFS(ubixFileSystem) != 0x0) {
    00474     kpanic("Unable To Enable UbixFS");
    00475     return(0x1);
    00476     }
    00477
    00478   /* Return */
    00479   return(0x0);
    00480   }
    00481
    00482 /***
    00483  $Log: ubixfs_8c-source.html,v $
    00483  Revision 1.7  2006/12/15 17:47:08  reddawg
    00483  Updates
    00483
    00484  Revision 1.2  2006/12/05 14:10:21  reddawg
    00485  Workign Distro
    00486
    00487  Revision 1.1.1.1  2006/06/01 12:46:17  reddawg
    00488  ubix2
    00489
    00490  Revision 1.2  2005/10/12 00:13:37  reddawg
    00491  Removed
    00492
    00493  Revision 1.1.1.1  2005/09/26 17:24:42  reddawg
    00494  no message
    00495
    00496  Revision 1.44  2004/08/26 22:51:19  reddawg
    00497  TCA touched me :( i think he likes men....
    00498
    00499
    00500  sched.h:        kTask_t added parentPid
    00501  endtask.c:     fixed term back to parentPid
    00502  exec.c:          cleaned warnings
    00503  fork.c:            fixed term to childPid
    00504  sched.c:         clean up for dead tasks
    00505  systemtask.c: clean up dead tasks
    00506  kmalloc.c:       cleaned up warnings
    00507  udp.c:            cleaned up warnings
    00508  bot.c:             cleaned up warnings
    00509  shell.c:           cleaned up warnings
    00510  tcpdump.c:     took a dump
    00511  hd.c:             cleaned up warnings
    00512  ubixfs.c:        stopped prning debug info
    00513
    00514  Revision 1.43  2004/08/14 11:23:02  reddawg
    00515  Changes
    00516
    00517  Revision 1.42  2004/08/09 12:58:05  reddawg
    00518  let me know when you got the surce
    00519
    00520  Revision 1.41  2004/08/01 17:58:39  flameshadow
    00521  chg: fixed string allocation bug in ubixfs_cacheNew()
    00522
    00523  Revision 1.40  2004/07/28 17:07:29  flameshadow
    00524  chg: re-added moving cached nodes to the front of the list when found
    00525  add: added an assert() in ubixfs.c
    00526
    00527  Revision 1.39  2004/07/27 19:24:31  flameshadow
    00528  chg: reduced the number of debugging statements in the kernel.
    00529
    00530  Revision 1.38  2004/07/27 12:02:01  reddawg
    00531  chg: fixed marks bug readFile did a lookup which is why it looked like it was loopping so much
    00532
    00533  Revision 1.37  2004/07/27 09:05:43  flameshadow
    00534  chg: fixed file not found bug. Still can't find looping issue
    00535
    00536  Revision 1.36  2004/07/27 04:05:20  flameshadow
    00537  chg: kinda fixed it. Added bunches of debug info
    00538
    00539  Revision 1.35  2004/07/26 19:15:49  reddawg
    00540  test code, fixes and the like
    00541
    00542  Revision 1.34  2004/07/24 23:04:44  reddawg
    00543  Changes... mark let me know if you fault at pid 185 when you type stress
    00544
    00545  Revision 1.33  2004/07/23 09:10:06  reddawg
    00546  ubixfs: cleaned up some functions played with the caching a bit
    00547  vfs:    renamed a bunch of functions
    00548  cleaned up a few misc bugs
    00549
    00550  Revision 1.32  2004/07/22 23:01:51  reddawg
    00551  Ok checking in before I sleep
    00552
    00553  Revision 1.31  2004/07/22 22:37:03  reddawg
    00554  Caching is working now the FS is extremely fast but needs to be optimized to do 32bit copies over 8bit
    00555
    00556  Revision 1.30  2004/07/22 19:01:59  flameshadow
    00557  chg: more directory and file caching
    00558
    00559  Revision 1.29  2004/07/22 16:34:32  flameshadow
    00560  add: file and dir caching kinda work
    00561
    00562  Revision 1.28  2004/07/21 22:07:18  flameshadow
    00563  chg: renamed caching functions (again)
    00564
    00565  Revision 1.27  2004/07/21 21:08:05  flameshadow
    00566  add: added provisions for file caching
    00567
    00568  Revision 1.26  2004/07/20 23:21:31  flameshadow
    00569  syncing
    00570
    00571  Revision 1.25  2004/07/20 21:39:53  reddawg
    00572  ubixfs: does propper caching now problem was you did not seek realSector however the os starts but I am getting a segfault could be from anything haven't looked into it right quick
    00573
    00574  Revision 1.24  2004/07/20 21:38:08  flameshadow
    00575  try now
    00576
    00577
    00578  Revision 1.23  2004/07/20 21:35:09  reddawg
    00579  Let me commit before we start to overlap
    00580
    00581  Revision 1.22  2004/07/20 21:28:16  flameshadow
    00582  oops
    00583
    00584  Revision 1.20  2004/07/20 19:36:49  reddawg
    00585  UBU Tags
    00586
    00587  Revision 1.19  2004/07/20 18:09:37  flameshadow
    00588  add: directory caching related stuff
    00589
    00590  Revision 1.18  2004/07/17 03:21:34  flameshadow
    00591  chg: cleaned up code; added assert() statements
    00592
    00593  Revision 1.15  2004/07/14 12:21:49  reddawg
    00594  ubixfs: enableUbixFs to ubixfs_init
    00595  Changed Startup Routines
    00596
    00597  Revision 1.14  2004/06/28 23:12:58  reddawg
    00598  file format now container:/path/to/file
    00599
    00600  Revision 1.13  2004/06/28 18:12:44  reddawg
    00601  We need these files
    00602
    00603  Revision 1.12  2004/06/28 11:57:58  reddawg
    00604  Fixing Up Filesystem
    00605
    00606  Revision 1.10  2004/06/04 13:20:22  reddawg
    00607  ubixFSmkDir(): played with it a bit to see if it still worked
    00608
    00609  Revision 1.9  2004/06/04 10:19:42  reddawg
    00610  notes: we compile again, thank g-d anyways i was about to cry
    00611
    00612  Revision 1.8  2004/06/01 00:04:53  reddawg
    00613  Try now mark
    00614
    00615  Revision 1.7  2004/05/19 15:20:06  reddawg
    00616  Fixed reference problems due to changes in drive subsystem
    00617
    00618  Revision 1.6  2004/05/19 04:07:43  reddawg
    00619  kmalloc(size,pid) no more it is no kmalloc(size); the way it should of been
    00620
    00621  Revision 1.5  2004/04/29 15:45:19  reddawg
    00622  Fixed some bugs so now the automade images will work correctly
    00623
    00624  Revision 1.4  2004/04/28 21:10:40  reddawg
    00625  Lots Of changes to make it work with existing os
    00626
    00627  Revision 1.3  2004/04/28 13:33:09  reddawg
    00628  Overhaul to ubixfs and boot loader and MBR to work well with our schema
    00629  now BAT and dir and file entries are all offset 64Sectors from the start of the partition
    00630
    00631  Revision 1.2  2004/04/28 02:22:55  reddawg
    00632  This is a fiarly large commit but we are starting to use new driver model
    00633  all around
    00634
    00635  Revision 1.1.1.1  2004/04/15 12:07:08  reddawg
    00636  UbixOS v1.0
    00637
    00638  Revision 1.31  2004/04/13 16:36:34  reddawg
    00639  Changed our copyright, it is all now under a BSD-Style license
    00640
    00641  END
    00642  ***/
    00643