panaLiX: Plik źródłowy src/fat.cpp

00001 /***********************************************************
00002 *PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
00003 *adek336[at]o2.pl, panalix.prv.pl                          *
00004 *under GPLv3 license                                       *
00005 *                                                          *
00006 *panalix - small osdev project                             *
00007 ************************************************************
00008 *       fat.cpp, version 1.0                               *
00009 ************************************************************
00010 *                                                          *
00011 *fat fs driver                                             *
00012 *                                                          *
00013 *30'12'04- first revision (1.0)                            *
00014 *                                                          *
00015 ***********************************************************/
00016 
00017 #include "src/common/shared.hpp"
00018 #include "src/memory/memset.hpp"
00019 #include "src/memory/align.hpp"
00020 #include "src/memory/heap.hpp"
00021 #include "src/ata.hpp"
00022 #include "src/fat.hpp"
00023 const uint32 FA_DIR             = 0x0001;       /*directory*/
00024 const uint32 FA_RO              = 0x0002;       /*read only*/
00025 const uint32 FA_NON_DIR = 0x0000;       /*non-directory*/
00026 const uint32 FA_RW              = 0x0000;       /*read/write*/
00027 const int ESKIP         = -0x0003;      /*skip element*/
00028 const int ENOTIMPLEMENTED=-0x0004;      /*function not yet implemented*/
00029 const int EPROTECTED    = -0x0005;      /*when user level tries to access kernel */
00030 const int ENOTFOUND     = -0x0002;      /*not found*/
00031 const uint32 DEF_ERROR = EINVAL; const uint32 SEEK_SET=0;
00032 #define fs_lseek(ptr,l,i) do { source=l; } while (0)
00033 uint32 fs_read(uint32 *ptr,char *buf,int count)
00034 {       ATAReadSector(ATA_PRIMARY, buf, *ptr/0x200, 0, count);*ptr+=count;
00035 return ESUCCESS;
00036 }
00037 uint32 block_read(uint32*source, char*buf,uint32 offset, uint32 count)
00038  {
00039         *source=offset;
00040         return fs_read(source,buf,count);
00041  }
00042 //                      i = block_read(source, ch, sector * sector_size, count * sector_size);
00043 
00044 //  {
00045 //  void ATAReadSector(int nDriveIndex, void *buf, uint64 block, int byte_offset, int nbytes)
00046 //      ATAReadSector(ATA_PRIMARY, buf, source/0x200, 0, count);
00047         //c'est vrai!
00048 //  {
00049 void sub2()
00050  {
00051 class fat_t f;
00052         f.init("elo");
00053         for(;;);
00054  }
00055 
00056 // i= fs_read(source, (char*) &sect, 0x200);    /*one sector of default size*/
00057 inline char *kmalloc(uint32 size)
00058  {
00059         return (char*)Memory::Heap::heap0.malloc(size, NO_ALIGN, "elo", NULL);
00060  }
00061 
00062  inline void kfree(void *ptr)
00063   {
00064   }
00065 // file_operations fat_procs=
00066 //  {
00067 //      fat_lseek,              /*lseek*/
00068 //      fat_read,               /*read*/
00069 //      fat_write,              /*write*/
00070 //      fat_readdir,    /*readdir*/
00071 //      NULL,                   /*ioctl*/
00072 //      fat_open,               /*open*/
00073 //      fat_close               /*close*/
00074 //  }; /*file operations for this fs-mod*/
00075 
00076 // PMODULE_INFO("fat.o", "fat-fs", "fat", MT_DEVDRV | MT_FSDRV);
00077 
00078 /*init module*/
00079 uint32 fat_probe (uint32 arg)
00080  {
00081 // for(;;);
00082 fat_t fat;
00083 char *ch;
00084         ch = kmalloc(4096);
00085         fat.source=0;
00086 /*in future to be replaced by message passing*/
00087 //      while (fat.source == NULL)
00088 //       {
00089 //              fat.init("/SYSTEM/dev/fd0");
00090 //       }
00091 //      vfs.mount("/mnt/fd0", &fat_procs, &fat);
00092 /*some debugging*/
00093 /*      kprintf("opened fd0 for reading..\n");
00094         fat.source->position=131000;
00095         while (1)
00096          {
00097         fat.source->position+=512;
00098                 i=fs_read(fat.source, ch, 512);
00099                 if (i!= ESUCCESS)
00100                  {
00101                         kprintf("read error\n");
00102                         break;
00103                  }
00104                 v.xpos=0;
00105                 kprintf("%d bytes read from fd0", fat.source->position);
00106                 dump (ch, 512);
00107          }
00108         kfree(ch);
00109         sysfail("done.");*/
00110 // char *cc=kmalloc(8192);
00111 //      fat.source->position=19 * 0x200;
00112 //      fat.fat_rawrw (18/*fat.FirstRootDirSecNum*/,cc,1,FAT_READ);
00113 //      fs_read(fat.source, cc, 512);
00114 //      dump(cc, 512);
00115 //      for(;;);
00116 /*switch to console 2, just for because*/
00117 //      tty_switch(&tty2,"e");
00118 /*run psh.x*/
00119 // file_handle_t *file;
00120 // process_t *proc;
00121 //      logout ("open psh.. ");
00122 //      file= fs_open("/mnt/fd0/psh.x");
00123 //      if (file != NULL)
00124 //      {
00125 //              kprintf("psh.x loaded juhuuu! \n");
00126 //              proc= create_elf_process(file, "psh");
00127 //      } else
00128 //       {
00129 //              kprintf("doh! /mnt/fd0/psh.x not found\n");
00130 //       }
00131 // /*message*/
00132 //      kprintf("[FAT\t] fat module now in memory\n");
00133 //      for(;;);
00134 // /*leave module in kernel space*/
00135 //      return M_LEAVE;
00136         return 1;
00137  }
00138 
00139 /*=================================CLASS MANAGEMENT==================================*/
00140 
00141 /*init*/
00142 fat_t::fat_t()
00143  {
00144         init();
00145  }
00146 
00147 /*init*/
00148 void fat_t::init()
00149  {
00150         inval();
00151  }
00152 
00153 /*init*/
00154 fat_t::fat_t(char *ph)
00155  {
00156         init(ph);
00157  }
00158 
00159 /*init*/
00160 void fat_t::init(char *ph)
00161  {
00162 // string s;
00163         inval();
00164 // /*copy the path*/
00165 //      s.copy(ph);
00166 //      path = s.v();
00167 //      s.inval();
00168 /*open the file*/
00169 //      source = fs_open(path);
00170 //      if (source == NULL)
00171 //              {valid = -1;inval();}
00172 //      else
00173         valid = verify();
00174  }
00175 
00176 /*done*/
00177 fat_t::~fat_t()
00178  {
00179         done();
00180  }
00181 
00182 /*done*/
00183 void fat_t::done()
00184  {
00185 //      fs_close(source);
00186         kfree(path);
00187         inval();
00188  }
00189 
00190 /*discard memory*/
00191 void fat_t::inval()
00192  {
00193 //      source = NULL; 
00194         source=0;
00195         path=NULL; valid=-1; sector_size = cluster_size = 0;
00196         FirstDataSector=0;
00197         RootDirSectors=0;TotSec=0; DataSec=0;
00198         CountofClusters=0; SecPerClus = 0;
00199         FirstRootDirSecNum = 0; ResvdSecCnt=0;
00200         active_fat = 0;fat_type=0;
00201  }
00202 
00203 /*===================================FAT DRIVER======================================*/
00204 
00205 uint8 FAT_DIRENT_ILLEGAL[]=
00206  {0x01, 0x02, 0x03, 0x04, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
00207   0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
00208   0x22, 0x2a, 0x2b, 0x2c, 0x2e, 0x2f, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
00209   0x5b, 0x5c, 0x5d, 0x7c};      /*all illegal characters which may not be in a direntry's name*/
00210 
00211 
00212 /*verifies it is a fat volume*/
00213 int fat_t::verify()
00214  {
00215 union
00216  {
00217         char ch[0x200];
00218         bootsect_t bpb;
00219  } sect;
00220 int i;
00221 /*read bootsector*/
00222         fs_lseek(source, 0, SEEK_SET);
00223         i= fs_read(&source, (char*) &sect, 0x200);      /*one sector of default size*/
00224         if (i != ESUCCESS)
00225                 return EINVAL;
00226 
00227 /*check some things*/
00228         /*sector size*/
00229         sector_size=sect.bpb.BPB_BytsPerSec;
00230         switch (sector_size) {
00231                 case 512:       /*valid*/
00232                 case 1024:      /*valid*/
00233                 case 2048:      /*valid*/
00234                 case 4096:      /*valid*/
00235                         break;
00236                 default:        /*invalid*/
00237                         sector_size = 0;
00238                         return EINVAL;
00239                         break; }
00240 
00241         /*cluster size*/
00242         cluster_size=sector_size * sect.bpb.BPB_SecPerClus;
00243         switch (sect.bpb.BPB_SecPerClus){
00244         /*the following are valid:*/
00245         case 1: case 2:  case 4:  case 8:
00246         case 16:case 32: case 64: case 128:
00247                 break;
00248         /*active table*/
00249                 active_fat = 0;
00250         /*all others are invalid*/
00251         default:
00252                 cluster_size = 0;
00253                 return EINVAL;
00254                 break;}
00255         /*number sectors occupying the root directory*/
00256                 RootDirSectors = ((sect.bpb.BPB_RootEntCnt * sizeof(fatdirent_t)) + (sector_size - 1)) / sector_size;
00257         /*reserved sector count*/
00258                 ResvdSecCnt = sect.bpb.BPB_ResvdSecCnt;
00259         /*fat size*/
00260                 if (sect.bpb.BPB_FATSz16 != 0)
00261                         FATSz = sect.bpb.BPB_FATSz16;
00262                 else
00263                         FATSz = sect.bpb.ext.bpb32.BPB_FATSz32;
00264                 if (FATSz == 0)
00265                         return EINVAL;
00266         /*the second cluster's first sector*/
00267                 FirstDataSector = ResvdSecCnt + (sect.bpb.BPB_NumFATs * FATSz) + RootDirSectors;
00268         /*total sector count*/
00269                 if (sect.bpb.BPB_TotSec16 != 0)
00270                         TotSec = sect.bpb.BPB_TotSec16;
00271                 else
00272                         TotSec = sect.bpb.BPB_TotSec32;
00273                 if (TotSec == 0)
00274                         return EINVAL;
00275         /*data sector count*/
00276                 DataSec = TotSec - (ResvdSecCnt + (sect.bpb.BPB_NumFATs * FATSz) + RootDirSectors);
00277                 if (DataSec == 0)
00278                         return EINVAL;
00279         /*cluster count*/
00280                 CountofClusters = DataSec / sect.bpb.BPB_SecPerClus;
00281         /*check media type*/
00282                 if (CountofClusters < 4085)
00283                         fat_type = FAT_FAT12;
00284                 else if (CountofClusters < 65525)
00285                         fat_type = FAT_FAT16;
00286                 else
00287                         fat_type = FAT_FAT32;
00288         /*sectors per cluster*/
00289                 SecPerClus = sect.bpb.BPB_SecPerClus;
00290         /*first sector of the root dir*/
00291                 if (fat_type == FAT_FAT32)
00292                         FirstRootDirSecNum = clus2sect(sect.bpb.ext.bpb32.BPB_RootClus);
00293                 else
00294                         FirstRootDirSecNum = sect.bpb.BPB_ResvdSecCnt + (sect.bpb.BPB_NumFATs * sect.bpb.BPB_FATSz16);
00295 
00296 
00297         return ESUCCESS;
00298  }
00299 
00300 /*rw access*/
00301 int fat_t::fat_rawrw(uint32 sector, char *ch, uint32 count, uint32 read_write)
00302  {
00303 int i = 0;
00304         switch (read_write)
00305          {
00306                 case FAT_READ:
00307                         i = block_read(&source, ch, sector * sector_size, count * sector_size);
00308                         break;
00309                 case FAT_WRITE:
00310 //                      i = block_write(source, ch, sector * sector_size, count * sector_size);
00311                         break;
00312                 default:
00313                         return EINVAL;
00314                         break;
00315          }
00316 
00317         return i;
00318  }
00319 
00320 /*rw cluster*/
00321 int fat_t::cluster_rw(uint32 block, char *ch, uint32 count, uint32 read_write)
00322  {
00323         return fat_rawrw(
00324                 (block * SecPerClus) + FirstDataSector - (2 * SecPerClus),/*first sector of cluster*/
00325                 ch,                                             /*buffer*/
00326                 count * SecPerClus,             /*count*/
00327                 read_write);            /*read or write*/
00328  }
00329 
00330 /*rw rootdir*/
00331 int fat_t::rootdir_rw(char *ch, uint32 read_write)
00332  {
00333         return fat_rawrw(
00334                 FirstRootDirSecNum,             /*first sector*/
00335                 ch,             /*buffer*/
00336                 RootDirSectors, /*root sectors*/
00337                 read_write);    /*read or write*/
00338  }
00339 
00340 /*returns first sector of cluster*/
00341 uint32 fat_t::clus2sect(uint32 cluster)
00342  {
00343         return (cluster-2) * SecPerClus + FirstDataSector;
00344  }
00345 
00346 /*=====================================FAT OPERATIONS==================================*/
00347 
00348 /*check in the fat, what does this cluster point at*/
00349 uint32 fat_t::read_next_clust(uint32 table, uint32 cluster)
00350  {
00351 uint32 FATOffset;
00352 uint32 ThisFATSecNum, ThisFATEntOffset;
00353 char *SecBuff;
00354 uint32 i;
00355 union
00356  {
00357         uint32 entry32;
00358         uint16 entry16;
00359  } ee;
00360         ee.entry32=0;
00361 /*count the offset into the table*/
00362         if (fat_type == FAT_FAT16)
00363                 FATOffset=cluster * 2;
00364         if (fat_type == FAT_FAT32)
00365                 FATOffset=cluster * 4;
00366         if (fat_type == FAT_FAT12)
00367                 FATOffset = cluster + (cluster / 2);
00368 
00369 /*count the fat sector*/
00370         ThisFATSecNum = ResvdSecCnt + (FATOffset / sector_size) + table * FATSz;
00371         ThisFATEntOffset = FATOffset - ((FATOffset / sector_size) * sector_size);
00372 
00373 /*read the value FROM A NON-12 FATFS*/
00374         if (fat_type != FAT_FAT12)
00375          {
00376         /*allocate memory for the buffer*/
00377                 SecBuff = kmalloc(sector_size);
00378         /*try to load the appopriate fat sector*/
00379                 if (fat_rawrw(ThisFATSecNum, SecBuff, 1, FAT_READ) != 1)
00380                         return DEF_ERROR;
00381         /*get the VALUE*/
00382                 if (fat_type == FAT_FAT16)
00383                         ee.entry16= (*(uint16*) &SecBuff[ThisFATEntOffset]);
00384                 else
00385                         ee.entry32= (*(uint32*) &SecBuff[ThisFATEntOffset]) & 0x0FFFFFFF;
00386         /*free memory*/
00387                 kfree(SecBuff);
00388         /*return value*/
00389                 return ee.entry32;
00390          }
00391 
00392 /*READ VALUE FROM A FAT12 FATFS*/
00393 /*check for situation, when we're spanning a sector boundary*/
00394         if (ThisFATEntOffset == sector_size - 1)
00395                 i = 2;
00396         else
00397                 i = 1;
00398 
00399 /*allocate memory for the buffer*/
00400         SecBuff = kmalloc(sector_size * i);
00401 /*try to load the appopriate fat sector*/
00402         if (fat_rawrw(ThisFATSecNum, SecBuff, i, FAT_READ) != 1)        /*i sectors*/
00403                 return DEF_ERROR;
00404 
00405 /*get the value*/
00406         ee.entry16 = (*(uint16*) &SecBuff[ThisFATEntOffset]);
00407 /*count it*/
00408         if (cluster & 0x001)
00409                 ee.entry16 = ee.entry16 >> 4;           /*cluster number is ODD*/
00410         else
00411                 ee.entry16 = ee.entry16 & 0x0FFF;       /*cluster number is EVEN*/
00412 /*dispose mem*/
00413         kfree(SecBuff);
00414 /*return value*/
00415         return ee.entry32;
00416  }
00417 
00418 /*write to fat to make cluster hold the value _val*/
00419 int fat_t::write_next_clust(uint32 table, uint32 cluster, uint32 val)
00420  {
00421 uint32 FATOffset;
00422 uint32 ThisFATSecNum, ThisFATEntOffset;
00423 char *SecBuff;
00424 uint32 i;
00425 union
00426  {
00427         uint32 entry32;
00428         uint16 entry16;
00429  } ee;
00430         ee.entry32=0;
00431 /*count the offset into the table*/
00432         if (fat_type == FAT_FAT16)
00433                 FATOffset=cluster * 2;
00434         if (fat_type == FAT_FAT32)
00435                 FATOffset=cluster * 4;
00436         if (fat_type == FAT_FAT12)
00437                 FATOffset = cluster + (cluster / 2);
00438 
00439 /*count the fat sector*/
00440         ThisFATSecNum = ResvdSecCnt + (FATOffset / sector_size) + table * FATSz;
00441         ThisFATEntOffset = FATOffset - ((FATOffset / sector_size) * sector_size);
00442 
00443 /*WRITE A VALUE TO A NON-FAT12 FATFS*/
00444         if (fat_type != FAT_FAT12)
00445          {
00446         /*allocate memory for the buffer*/
00447                 SecBuff = kmalloc(sector_size);
00448         /*try to load the appopriate fat sector*/
00449                 if (fat_rawrw(ThisFATSecNum, SecBuff, 1, FAT_READ) != 1)
00450                         return DEF_ERROR;
00451         /*get the VALUE*/
00452                 if (fat_type == FAT_FAT16)
00453                         (*(uint16*) &SecBuff[ThisFATEntOffset]) = val;
00454                 else
00455                         (*(uint32*) &SecBuff[ThisFATEntOffset]) =
00456                                 (*(uint32*) &SecBuff[ThisFATEntOffset]& 0xF0000000) | val;
00457         /*try to write the appopriate fat sector*/
00458                 if (fat_rawrw(ThisFATSecNum, SecBuff, 1, FAT_WRITE) != 1)
00459                         return DEF_ERROR;
00460         /*free memory*/
00461                 kfree(SecBuff);
00462         /*return value*/
00463                 return ee.entry32;
00464          }
00465 
00466 /*WRITE A VALUE TO A FAT12 FATFS*/
00467 /*check for situation, when we're spanning a sector boundary*/
00468         if (ThisFATEntOffset == sector_size - 1)
00469                 i = 2;
00470         else
00471                 i = 1;
00472 
00473 /*allocate memory for the buffer*/
00474         SecBuff = kmalloc(sector_size * i);
00475 /*try to load the appopriate fat sector*/
00476         if (fat_rawrw(ThisFATSecNum, SecBuff, i, FAT_READ) != 1)        /*i sectors*/
00477                 return DEF_ERROR;
00478 
00479 /*count it*/
00480         if (cluster & 0x001)
00481          {
00482                 val = val << 4;
00483                 (*(uint16*) &SecBuff[ThisFATEntOffset]) &= 0x000F;
00484          }              /*cluster number is ODD*/
00485         else
00486          {
00487                 val = val & 0x0FFF;
00488                 (*(uint16*) &SecBuff[ThisFATEntOffset]) &= 0xFFF0;
00489          }              /*cluster number is EVEN*/
00490         (*(uint16*) &SecBuff[ThisFATEntOffset]) |= val;
00491         if (fat_rawrw(ThisFATSecNum, SecBuff, i, FAT_WRITE) != 1)       /*i sectors*/
00492                 return DEF_ERROR;
00493         
00494 /*dispose mem*/
00495         kfree(SecBuff);
00496 /*return value*/
00497         return ee.entry32;
00498  }
00499 
00500 /*reads n-th cluster from first*/
00501 uint32 fat_t::cluster_no (uint32 table, uint32 first, uint32 n)
00502  {
00503 uint32 i;
00504 uint32 clus = first;
00505         for (i=0;i<n;i++)
00506          {
00507                 clus = read_next_clust(table, clus);
00508                 if (isEOF(clus) == ESUCCESS)
00509                         break;
00510          }
00511 
00512         return clus;
00513  }
00514 
00515 /*checks if is EOF*/
00516 int fat_t::isEOF(uint32 val)
00517  {
00518 int isEOF = -1;
00519         if (fat_type == FAT_FAT12)
00520                 if (val >= 0xff8)
00521                         isEOF = 1;
00522         if (fat_type == FAT_FAT16)
00523                 if (val >= 0xFFF8)
00524                         isEOF = 1;
00525         if (fat_type == FAT_FAT32)
00526                 if (val >= 0x0FFFFFF8)
00527                         isEOF = 1;
00528 
00529         return isEOF;
00530  }
00531 
00532 /*returns the length of the chain*/
00533 uint32 fat_t::chain_length(uint32 first)
00534  {
00535 uint32 cluster = first;
00536 uint32 i=1;
00537 /*while a end-of-chain mark is not found*/
00538         /*1. checks what is the value of cluster in fat table _active_fat
00539           2. sets the vlue to cluster
00540           3. checks if it means an eof
00541           4. if not, increase counter*/
00542         while (isEOF(cluster=read_next_clust(active_fat, cluster)) != ESUCCESS)
00543                 i++;
00544 
00545 /*return to system*/
00546         return i;
00547  }
00548 
00549 /*reads a cluster chain*/
00550 int fat_t::read_chain(uint32 first, uint32 count, char *buff)
00551  {
00552 uint32 cluster = first;
00553 uint32 i = 0;
00554 int flag ;
00555 /*while a end-of-chain mark is not found*/
00556         while (ESUCCESS)
00557          {
00558                 if (i > count-1)
00559                         break;
00560 
00561                 flag = cluster_rw(cluster, buff, 1, FAT_READ);
00562 
00563                 if (!flag)
00564                         return EINVAL;
00565         /*next cluster*/
00566                 i++;
00567                 buff += cluster_size;
00568 
00569                 if (isEOF(cluster) == ESUCCESS)
00570                         return ESUCCESS;        /*read the whole chain*/
00571 
00572                 cluster = read_next_clust(active_fat, cluster);
00573          }
00574 
00575         return ESUCCESS;
00576  }
00577 
00578 /*============================DIRECTORY ENTRIES OPERATIONS==============================*/
00579 
00580 /*returns the first lfn/shn entry starting from entry in cluster*/
00581 int fat_t::lfn_parse_dir (char *cluster_buffer, uint32 clus, dirent *ent, uint32 *entry)
00582  {
00583 /*cluster_buffer- keeps the directory
00584 clus- how many clusters are in the buffer
00585 ent- we will write result here
00586 entry- ptr to the current entry parsed*/
00587 
00588 /*sanity check*/
00589         if (fat_type == 0)
00590                 return EINVAL;
00591 fatdirent_t *quux;
00592 int flag = EINVAL;
00593 int collect_lfn = EINVAL;               /*when we are collecting the lfn entries*/
00594 fatdirent_t *lfn_start;         /*where is the first lfn entry*/
00595 int i;
00596 
00597 /*get the entry*/
00598         quux = ((fatdirent_t*) cluster_buffer);
00599         quux += (*entry);
00600 /*for support of lfn, parse many entries*/
00601         while (ESUCCESS)
00602          {
00603         /*sanity check*/
00604                 if ((*entry) * sizeof(fatdirent_t) >= cluster_size * clus)
00605                         return ENOTFOUND;
00606                 if (cluster_buffer == NULL)
00607                         return EINVAL;
00608         /*if found a valid long file name*/
00609                 if (valid_lfn (quux) == ESUCCESS)
00610                  {
00611                         if (collect_lfn == EINVAL)
00612                                 {collect_lfn = 1;lfn_start=quux;}
00613                         else
00614                                 collect_lfn++;
00615                  } else
00616                  {
00617                         i = valid_sfn(quux);
00618                 /*if found a valid short file name*/
00619                         switch (i)
00620                          {
00621                         case ESUCCESS:
00622                         /*is there a lfn struct related to this entry?*/
00623                                 if (collect_lfn != EINVAL)      /*YES*/
00624                                         lfn2name(lfn_start, collect_lfn, ent->name);    /*convert names from raw format*/
00625                                 else                    /*NO*/
00626                                         sfn2name (quux->sfn.DIR_Name, ent->name);       /*convert names from raw format*/
00627                         /*save other values*/
00628                                 ent->resvd = NULL;
00629                                 ent->size = quux->sfn.DIR_FileSize;
00630                                 ent->parent = DEF_ERROR;        /*not yet known*/
00631                                 ent->block = (quux->sfn.DIR_FstClusLO) + ((quux->sfn.DIR_FstClusHI) << 16);
00632                                 ent->entry_in_dir = *entry;
00633                         /*like attributes*/
00634                                 ent->flags = 0;
00635                                 if (quux->sfn.DIR_Attr & FAT_ATTR_DIR)
00636                                  {ent->flags |= FA_DIR;
00637                                  ent->size = chain_length(ent->block) * cluster_size;}
00638                                 if (quux->sfn.DIR_Attr & FAT_ATTR_RO)
00639                                         ent->flags |= FA_RO;
00640                         /*save flag*/
00641                                 flag = ESUCCESS;
00642                                 break;
00643                         case ESKIP:     /*when the found file is a deleted file*/
00644                                 collect_lfn = EINVAL;   /*invalidate the lfn we gathered*/
00645                                 break;
00646                         case ENOTFOUND: /*this means no more entries are to be parsed*/
00647                                 return ENOTFOUND;
00648                         default:                /*neither a lfn or a sfn. if was present, break lfn catching*/
00649                                 collect_lfn = EINVAL;
00650                                 break;
00651                         }/*neither an shn or an lfn*/
00652                  }
00653                         
00654         /*next entry*/
00655                 (*entry)++;
00656                 quux++;
00657         /*return to sys*/
00658                 if (flag == ESUCCESS)
00659                         return ESUCCESS;
00660          }
00661 
00662 /*error*/
00663         return EINVAL;
00664  }
00665 
00666 /*check whether it is a lfn entry*/
00667 int fat_t::valid_lfn(fatdirent_t *ent)
00668  {
00669 /*basic sanity check*/
00670         if (ent == NULL)
00671                 return EINVAL;
00672 /*lfn attr*/
00673         if (ent->lfn.DIR_Attr != FAT_ATTR_LFN)
00674                 return -1;
00675 /*cluster pointer*/
00676         if (ent->lfn.DIR_First != 0)
00677                 return -1;
00678 
00679 /*after passing all those tests, it looks like a correct lfn entry*/
00680         return ESUCCESS;
00681  }
00682 
00683 /*check whether it is a shn entry*/
00684 int fat_t::valid_sfn(fatdirent_t *ent)
00685  {
00686 /*basic sanity check*/
00687         if (ent == NULL)
00688                 return EINVAL;
00689 /*attr*/
00690         if (ent->sfn.DIR_Attr & FAT_ATTR_VOLUME)
00691                 return -1;              /*treat files with volume attr set as invalid*/
00692 /*first char*/
00693         switch (ent->sfn.DIR_Name[0])
00694          {
00695         /*those are for free entries*/
00696                 case FAT_DIRENT_FREE:
00697                 case FAT_DIRENT_FREE2:
00698                         return ESKIP;
00699                 case FAT_DIRENT_ALL_FREE:
00700                         return ENOTFOUND;
00701         /*all other will be treated as valid*/
00702                 default:
00703                         break;
00704          };
00705 
00706 /*after passing all those tests, it looks like a correct shn entry*/
00707         return ESUCCESS;
00708  }
00709 
00710 /*changes name from a raw-sfn format to a standard file name format.*/
00711 int fat_t::sfn2name (char *raw, char *buff)
00712  {
00713 uint32 n,i;
00714 /*copy name from raw format*/
00715         n=0;
00716         while ( (raw[n] != FAT_DIRENT_PAD) && (n<8) )
00717                 {buff[n]=raw[n]; n++;}
00718 /*add a dot, if there is an extension*/
00719         if (raw[8] != FAT_DIRENT_PAD)
00720                 buff[n++] = '.';
00721 /*copy extension now*/
00722         i=8;
00723         while ( (raw[i] != FAT_DIRENT_PAD) && (i<11) )
00724                 buff[n++]=raw[i++];
00725 /*add null terminator*/
00726         buff[n]=0;
00727 /*return*/
00728         return ESUCCESS;
00729  }
00730 
00731 /*convert an lfn into a standard file name*/
00732 int fat_t::lfn2name (fatdirent_t *first, uint32 count, char *buff)
00733  {
00734 fatdirent_t *quux;
00735 uint32 i, n, z = 0;
00736 /*find the entry with the first chars*/
00737         quux = first + count - 1;
00738 /*repeat for each entry*/
00739         for (i=0;i<count;i++)
00740          {
00741         /*LName1*/
00742                 for (n=0; n < sizeof(quux->lfn.DIR_LName1) / 2; n++)
00743                         buff[z++] = quux->lfn.DIR_LName1[n * 2];        /*because the chars are in uint16 format*/
00744         /*LName2*/
00745                 for (n=0; n < sizeof(quux->lfn.DIR_LName2) / 2; n++)
00746                         buff[z++] = quux->lfn.DIR_LName2[n * 2];        /*because the chars are in uint16 format*/
00747         /*LName3*/
00748                 for (n=0; n < sizeof(quux->lfn.DIR_LName3) / 2; n++)
00749                         buff[z++] = quux->lfn.DIR_LName3[n * 2];        /*because the chars are in uint16 format*/
00750                 quux--;
00751          }
00752 /*null terminator*/
00753         buff[z] = 0;
00754 /*return*/
00755         return ESUCCESS;
00756  }
00757 
00758 /*find the entry*/
00759 /*ie. name="/boot/kernel.x", checks root for /boot, then checks /boot for kernel32.x etc.*/
00760 int fat_t::find_entry(char *name, dirent *ent)
00761  {
00762 /*sanity check*/
00763         if (fat_type == 0)
00764                 return EINVAL;
00765 /*are we opening root?*/
00766         if ((name[0] == '/') && (name[1] == 0))
00767          {
00768                 ent -> name[0] = '/';
00769                 ent -> name[1] = 0;
00770                 ent -> size = RootDirSectors * sector_size;
00771                 ent -> parent = 0;
00772                 ent -> block = 0;
00773                 ent -> flags = FA_DIR;
00774                 ent -> resvd = NULL;
00775                 ent -> entry_in_dir = 0;
00776                 return ESUCCESS;
00777          }
00778 
00779 /*find the entry*/
00780 // char *ch;
00781 // char *buff;
00782 // uint32 tok = 0;
00783 // uint32 count;
00784 // uint32 size;
00785 // string s;
00786 // uint32 cluster;
00787 // int i;
00788 // 4
00789 // Djibouti(Africa)
00790 // Indigo
00791 // Narcyz
00792 // /*init*/
00793 //      s.set(name);    /*the name to be looked for*/
00794 //      count = s.token_count(slash);   /*how deep in the dir tree the file is*/
00795 // /*each token*/
00796 //      while (ESUCCESS)
00797 //       {
00798 // //   /*get the next path token*/
00799 //              ch = s.token(tok, slash);
00800 //      /*read the directory structure*/
00801 //              if (tok==0)
00802 //               {
00803 // //                   buff = kmalloc(RootDirSectors * sector_size);
00804 //                      rootdir_rw(buff, FAT_READ);
00805 //                      size = RootDirSectors/SecPerClus;
00806 //               } else
00807 //                {
00808 //                      size = chain_length(cluster);
00809 //                      buff = kmalloc(size * cluster_size);
00810 //                      read_chain(cluster, size, buff);
00811 //                }
00812 //      /*try to find the appropriate entry*/
00813 // // //                i= get_file (ch, buff, size, ent);
00814 //              if (i != ESUCCESS) {
00815 //                      kfree(buff);return EINVAL;}
00816 //              kfree(ch);
00817 //      /*get next cluster*/
00818 //              cluster = ent->block;
00819 //      /*check which token*/
00820 //              if (tok >= count-1) {
00821 //                      kfree(buff);return ESUCCESS;}
00822 //              tok++;
00823 //      /*check if it is a directory*/
00824 //              if (!ent->flags & FA_DIR) {
00825 //                      kfree(buff); return EINVAL; }
00826 //       }
00827 // /*discard memory*/
00828 //      s.inval();
00829 return 1;
00830  }
00831 
00832 /*find a specific file in the directory*/
00833 int fat_t::get_file(char *name, char *buffer, uint32 clus, dirent *ent)
00834  {
00835 /*sanity check*/
00836         if (fat_type == 0)
00837                 return EINVAL;
00838 
00839 int flag;
00840 // int i;
00841 // uint32 entry = 0;
00842 // string s;
00843 //      s.set(name);
00844 // /*check each file for name*/
00845 //      while (ESUCCESS)
00846 //       {
00847 //      /*get next entry*/
00848 //              i=lfn_parse_dir(buffer, clus, ent, &entry);
00849 //              if (i!= ESUCCESS)
00850 //                      {flag = EINVAL;break;}
00851 // // //        /*check if names is equal*/
00852 //              if (s.strcmp(ent->name))
00853 //                      {flag = ESUCCESS;break;}
00854 //       }
00855 // 
00856 // /*discard memory*/
00857 //      s.inval();
00858 // /*return*/
00859         return flag;
00860  }
00861 
00862 /*===============================DEFAULT FILE OPERATIONS================================*/
00863 
00864 /*seek*/
00865 // int fat_t::lseek ( struct file_handle_t *file, sint64 count, int whence )
00866 //  {
00867 // uint64 tmp=0;
00868 //     switch ( whence )
00869 //     {
00870 //      case SEEK_SET:
00871 //          tmp = count;
00872 //          break;
00873 //      case SEEK_CUR:
00874 //          tmp = count + file -> position;
00875 //          break;
00876 //      case SEEK_END:
00877 //              tmp = file->owner->inode.size + count;
00878 //          break;
00879 //      default:
00880 //          return EINVAL;
00881 //     }
00882 
00883 // //   file->position=tmp;
00884 
00885 //      return ESUCCESS;
00886 //  }
00887 
00888 /*read from a file on the media*/
00889 // int fat_t::read ( struct file_handle_t *file, char *buff, int nbytes )
00890 //  {
00891 // uint64 pos;
00892 // uint32 count;
00893 // uint32 clus;
00894 // char *ch;
00895 // int i;
00896 
00897 /*sanity checks*/
00898 //      if (fat_type == 0) {
00899 //              TRACE9("fat-fs","fat module not initialized for reading");
00900 //              return EINVAL; }
00901 
00902 //      if (file == NULL)
00903 //              return EINVAL;
00904 /*check if belongs to this mountpoint*/
00905 //      if (file->owner->mount->p != this) {
00906 // //           TRACE9("fat-fs", "file->owner->mount->p != this");
00907 //              return EINVAL; }
00908 
00909 /*check if inbounds*/
00910 //      if (file->position + nbytes > file->owner->inode.size)
00911 //              return EINVAL;
00912 
00913 /*computate variables*/
00914 //      pos = file->position & DEF_64_page_mask;
00915 //      count = align_up(nbytes, cluster_size);
00916 /*find first cluster of the file*/
00917 //      clus = file->owner->inode.block;
00918 //      clus = cluster_no(active_fat, clus, pos / cluster_size );
00919 //      if (isEOF(clus) == ESUCCESS)
00920 //              return EINVAL;
00921 /*read data*/
00922 // //   ch = kmalloc(count);
00923 //      i=read_chain(clus, count / cluster_size, ch);
00924 //      if (i!=ESUCCESS)
00925 //              return i;
00926 
00927 /*copy to user buffer*/
00928 // //   movemem((uint32) ch + (file->position & 0xFFF), (uint32) buff, nbytes);
00929 //      kfree(ch);
00930 
00931 //      file->position += nbytes;
00932 //      return ESUCCESS;
00933 //  }
00934 
00935 /*write*/
00936 int fat_t::write ( struct file_handle_t *file, char *buff, int nbytes)
00937  {
00938         return -1;
00939  }
00940 
00941 /*readdir*/
00942 int fat_t::readdir ( struct file_handle_t *file, struct dirent *entry, int count )
00943  {
00944 char *buff;
00945 int i;
00946 /*check, if it's a directory*/
00947 //      if (!(file->owner->inode.flags & FA_DIR))
00948 //              return ENOTDIR;
00949 /*read the directory*/
00950 //      buff = kmalloc( align_up(file->owner->inode.size,cluster_size) );
00951 /*is it the root?*/
00952 //      if (file->owner->inode.block == 0)
00953                 i=rootdir_rw (buff, FAT_READ);
00954 //      else
00955 //       {
00956         /*omit dot and dotdot*/
00957 //              if (entry->entry_in_dir < 2)
00958 //                      entry->entry_in_dir = 2;
00959         /*read the directory*/
00960 // //           i=read_chain(file->owner->inode.block, align_up(file->owner->inode.size, cluster_size) / cluster_size, buff);
00961 //       }
00962         if (i!= ESUCCESS)
00963                 return i;
00964 //      i= lfn_parse_dir (buff, align_up(file->owner->inode.size,cluster_size)/cluster_size, entry, &entry->entry_in_dir);
00965         kfree(buff);
00966 
00967         return i;
00968  }
00969 
00970 /*open*/
00971 int fat_t::open  ( struct file_handle_t *file )
00972  {
00973 int i;
00974 dirent entry;
00975 char *ch;
00976 /*sanity check*/
00977         if (fat_type == 0)
00978                 return EINVAL;
00979 /*get the name*/
00980 //      ch = fs_path(file);
00981 /*get info on the file*/
00982         i= find_entry(ch, &entry);
00983         kfree(ch);
00984         if (i != ESUCCESS)
00985                 return EINVAL;
00986 
00987 /*copy the dirent*/
00988 // //   movemem((uint32) &entry, (uint32) &file->owner->inode, sizeof(dirent));
00989 
00990         return ESUCCESS;
00991  }
00992 
00993 /*close*/
00994 int fat_t::close ( struct file_handle_t *file )
00995  {
00996         return -1;
00997  }
00998 
00999 /*===================================VFS FUNCTIONS===================================*/
01000 
01001 /*seek*/
01002 int fat_lseek ( struct file_handle_t *file, sint64 count, int whence )
01003  {
01004 // fat_t *fs;
01005 uint32 ret;
01006 /*the "p" variable holds which devfs_t is supposed to be used*/
01007 //      fs = (fat_t*) file->owner->mount->p;
01008 
01009 //      ret= fs -> lseek (file, count, whence);
01010         return ret;
01011  }
01012 
01013 /*read*/
01014 int fat_read ( struct file_handle_t *file, char *buff, int nbytes)
01015  {
01016 // fat_t *fs;
01017 uint32 ret;
01018 /*the "p" variable holds which devfs_t is supposed to be used*/
01019 //      fs = (fat_t*) file->owner->mount->p;
01020 
01021 //      ret= fs -> read (file, buff, nbytes);
01022 
01023         return ret;
01024  }
01025 
01026 /*write*/
01027 int fat_write ( struct file_handle_t *file, char *buff, int nbytes)
01028  {
01029 // fat_t *fs;
01030 uint32 ret;
01031 /*the "p" variable holds which devfs_t is supposed to be used*/
01032 //      fs = (fat_t*) file->owner->mount->p;
01033 
01034 //      ret= fs -> write (file, buff, nbytes);
01035         return ret;
01036  }
01037 
01038 /*readdir*/
01039 int fat_readdir ( struct file_handle_t *file, struct dirent *entry, int n)
01040  {
01041 // fat_t *fs;
01042 uint32 ret;
01043 /*the "p" variable holds which devfs_t is supposed to be used*/
01044 //      fs = (fat_t*) file->owner->mount->p;
01045 
01046 //      ret= fs -> readdir (file, entry, n);
01047         return ret;
01048  }
01049 
01050 /*open*/
01051 int fat_open  ( struct file_handle_t *file )
01052  {
01053 // fat_t *fs;
01054 uint32 ret;
01055 /*the "p" variable holds which devfs_t is supposed to be used*/
01056 //      fs = (fat_t*) file->owner->mount->p;
01057 
01058 //      ret= fs -> open (file);
01059         return ret;
01060  }
01061 
01062 /*close*/
01063 int fat_close ( struct file_handle_t *file )
01064  {
01065 // fat_t *fs;
01066 uint32 ret;
01067 /*the "p" variable holds which devfs_t is supposed to be used*/
01068 //      fs = (fat_t*) file->owner->mount->p;
01069 
01070 //      ret= fs -> close (file);
01071         return ret;
01072  }
01073 
01074 
01075 /***********************************************************
01076 *                                                          *
01077 *panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
01078 *adek336[at]o2.pl, panalix.prv.pl                          *
01079 *                                                          *
01080 ***********************************************************/