modules/usb/usbhdfsd/fs_driver.c

   1 //---------------------------------------------------------------------------
   2 //File name:    fs_driver.c
   3 //---------------------------------------------------------------------------
   4 /*
   5  * fat_driver.c - USB Mass storage driver for PS2
   6  *
   7  * (C) 2004, Marek Olejnik (ole00@post.cz)
   8  * (C) 2004  Hermes (support for sector sizes from 512 to 4096 bytes)
   9  * (C) 2004  raipsu (fs_dopen, fs_dclose, fs_dread, fs_getstat implementation)
  10  *
  11  * FAT filesystem layer
  12  *
  13  * See the file LICENSE included with this distribution for licensing terms.
  14  */
  15 //---------------------------------------------------------------------------
  16 #include <stdio.h>
  17 #include <errno.h>
  18 #include <sys/stat.h>
  19 #include <io_common.h>
  20 #include <ioman.h>
  21
  22 #ifdef WIN32
  23 #include <malloc.h>
  24 #include <memory.h>
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #else
  28 #include <sysclib.h>
  29 #include <thsemap.h>
  30 #include <thbase.h>
  31 #include <sysmem.h>
  32 #define malloc(a)       AllocSysMemory(0,(a), NULL)
  33 #define free(a)         FreeSysMemory((a))
  34 #endif
  35
  36 #include "usbhd_common.h"
  37 #include "fat_driver.h"
  38 #include "fat_write.h"
  39 #include "fat.h"
  40
  41 //#define DEBUG  //comment out this line when not debugging
  42
  43 #include "mass_debug.h"
  44 #include "mass_stor.h"
  45
  46 #define IOCTL_CKFREE 0xBABEC0DE  //dlanor: Ioctl request code => Check free space
  47 #define IOCTL_RENAME 0xFEEDC0DE  //dlanor: Ioctl request code => Rename
  48 #define IOCTL_GETCLUSTER 0xBEEFC0DE        //jimmikaelkael: Ioctl request code => get file start cluster
  49 #define IOCTL_GETDEVSECTORSIZE 0xDEADC0DE  //jimmikaelkael: Ioctl request code => get mass storage device sector size
  50 #define IOCTL_CHECKCHAIN 0xCAFEC0DE  //polo: Ioctl request code => Check cluster chain
  51
  52 #define FLUSH_SECTORS           fat_flushSectors
  53
  54 typedef struct _fs_rec {
  55         int           file_flag;
  56   //This flag is always 1 for a file, and always 0 for a folder (different typedef)
  57   //Routines that handle both must test it, and then typecast the privdata pointer
  58   //to the type that is appropriate for the given case. (see also fs_dir typedef)
  59         unsigned int  filePos;
  60         int           mode;     //file open mode
  61         unsigned int  sfnSector; //short filename sector  - write support
  62         int           sfnOffset; //short filename offset  - write support
  63         int           sizeChange; //flag
  64         fat_dir fatdir;
  65 } fs_rec;
  66
  67 typedef struct _fs_dir {
  68         int           file_flag;
  69         //This flag is always 1 for a file, and always 0 for a folder (different typedef)
  70         //Routines that handle both must test it, and then typecast the privdata pointer
  71         //to the type that is appropriate for the given case. (see also fs_rec typedef)
  72         int status;
  73         fat_dir fatdir;
  74         fat_dir_list fatdlist;
  75 } fs_dir;
  76
  77 #define MAX_FILES 16
  78 fs_rec  fsRec[MAX_FILES]; //file info record
  79
  80 #ifndef WIN32
  81 static iop_device_t fs_driver;
  82 static iop_device_ops_t fs_functarray;
  83 #endif
  84
  85 void fillStat(fio_stat_t *stat, fat_dir *fatdir)
  86 {
  87         stat->mode = FIO_SO_IROTH | FIO_SO_IXOTH;
  88         if (fatdir->attr & FAT_ATTR_DIRECTORY) {
  89                 stat->mode |= FIO_SO_IFDIR;
  90         } else {
  91                 stat->mode |= FIO_SO_IFREG;
  92         }
  93         if (!(fatdir->attr & FAT_ATTR_READONLY)) {
  94                 stat->mode |= FIO_SO_IWOTH;
  95         }
  96
  97         stat->size = fatdir->size;
  98
  99         //set created Date: Day, Month, Year
 100         stat->ctime[4] = fatdir->cdate[0];
 101         stat->ctime[5] = fatdir->cdate[1];
 102         stat->ctime[6] = fatdir->cdate[2];
 103         stat->ctime[7] = fatdir->cdate[3];
 104
 105         //set created Time: Hours, Minutes, Seconds
 106         stat->ctime[3] = fatdir->ctime[0];
 107         stat->ctime[2] = fatdir->ctime[1];
 108         stat->ctime[1] = fatdir->ctime[2];
 109
 110         //set accessed Date: Day, Month, Year
 111         stat->atime[4] = fatdir->adate[0];
 112         stat->atime[5] = fatdir->adate[1];
 113         stat->atime[6] = fatdir->adate[2];
 114         stat->atime[7] = fatdir->adate[3];
 115
 116         //set modified Date: Day, Month, Year
 117         stat->mtime[4] = fatdir->mdate[0];
 118         stat->mtime[5] = fatdir->mdate[1];
 119         stat->mtime[6] = fatdir->mdate[2];
 120         stat->mtime[7] = fatdir->mdate[3];
 121
 122         //set modified Time: Hours, Minutes, Seconds
 123         stat->mtime[3] = fatdir->mtime[0];
 124         stat->mtime[2] = fatdir->mtime[1];
 125         stat->mtime[1] = fatdir->mtime[2];
 126 }
 127
 128 /*************************************************************************************/
 129 /*    File IO functions                                                              */
 130 /*************************************************************************************/
 131
 132
 133 int     nameSignature;
 134 int     removalTime;
 135 int     removalResult;
 136
 137 //---------------------------------------------------------------------------
 138 fs_rec* fs_findFreeFileSlot(void) {
 139         int i;
 140         for (i = 0; i < MAX_FILES; i++) {
 141                 if (fsRec[i].file_flag == -1) {
 142                         return &fsRec[i];
 143                         break;
 144                 }
 145         }
 146         return NULL;
 147 }
 148
 149 //---------------------------------------------------------------------------
 150 fs_rec* fs_findFileSlotByName(const char* name) {
 151         int i;
 152         for (i = 0; i < MAX_FILES; i++) {
 153                 if (fsRec[i].file_flag >= 0 && strEqual(fsRec[i].fatdir.name, (unsigned char*) name) == 0) {
 154                         return &fsRec[i];
 155                 }
 156         }
 157         return NULL;
 158 }
 159
 160 //---------------------------------------------------------------------------
 161 static int _lock_sema_id = 0;
 162
 163 //---------------------------------------------------------------------------
 164 int _fs_init_lock(void)
 165 {
 166 #ifndef WIN32
 167         iop_sema_t sp;
 168
 169         sp.initial = 1;
 170         sp.max = 1;
 171         sp.option = 0;
 172         sp.attr = 0;
 173         if((_lock_sema_id = CreateSema(&sp)) < 0) { return(-1); }
 174 #endif
 175
 176         return(0);
 177 }
 178
 179 //---------------------------------------------------------------------------
 180 int _fs_lock(void)
 181 {
 182 #ifndef WIN32
 183     if(WaitSema(_lock_sema_id) != _lock_sema_id) { return(-1); }
 184 #endif
 185     return(0);
 186 }
 187
 188 //---------------------------------------------------------------------------
 189 int _fs_unlock(void)
 190 {
 191 #ifndef WIN32
 192     SignalSema(_lock_sema_id);
 193 #endif
 194     return(0);
 195 }
 196
 197 //---------------------------------------------------------------------------
 198 void fs_reset(void)
 199 {
 200         int i;
 201         for (i = 0; i < MAX_FILES; i++) { fsRec[i].file_flag = -1; }
 202 #ifndef WIN32
 203         if(_lock_sema_id >= 0) { DeleteSema(_lock_sema_id); }
 204 #endif
 205         _fs_init_lock();
 206 }
 207
 208 //---------------------------------------------------------------------------
 209 int fs_inited = 0;
 210
 211 //---------------------------------------------------------------------------
 212 int fs_dummy(void)
 213 {
 214         return -5;
 215 }
 216
 217 //---------------------------------------------------------------------------
 218 int fs_init(iop_device_t *driver)
 219 {
 220     if(fs_inited) { return(1); }
 221
 222         fs_reset();
 223
 224     fs_inited = 1;
 225         return 1;
 226 }
 227
 228 //---------------------------------------------------------------------------
 229 int fs_open(iop_file_t* fd, const char *name, int mode) {
 230         fat_driver* fatd;
 231         fs_rec* rec = NULL;
 232         int ret;
 233         unsigned int cluster;
 234
 235         _fs_lock();
 236
 237         XPRINTF("USBHDFSD: fs_open called: %s mode=%X \n", name, mode) ;
 238
 239         fatd = fat_getData(fd->unit);
 240         if (fatd == NULL) { _fs_unlock(); return -ENODEV; }
 241
 242 #ifndef WRITE_SUPPORT
 243         //read only support
 244         if (mode != 0 && mode != O_RDONLY) { //correct O_RDONLY  number?
 245                 XPRINTF("USBHDFSD: mode (%d) != O_RDONLY (%d) \n", mode, O_RDONLY);
 246                 return -EROFS;
 247         }
 248 #endif
 249
 250 #ifdef WRITE_SUPPORT
 251         fs_rec* rec2 = NULL;
 252         char escapeNotExist;
 253
 254         //check if the file is already open
 255         rec2 = fs_findFileSlotByName(name);
 256         if (rec2 != NULL) {
 257                 if ((mode & O_WRONLY) || //current file is opened for write
 258                         (rec2->mode & O_WRONLY) ) {//other file is opened for write
 259                         _fs_unlock();
 260                         return  -EACCES;
 261                 }
 262         }
 263 #endif
 264
 265         //check if the slot is free
 266         rec = fs_findFreeFileSlot();
 267         if (rec == NULL) { _fs_unlock(); return -EMFILE; }
 268
 269 #ifdef WRITE_SUPPORT
 270         if((mode & O_WRONLY))  { //dlanor: corrected bad test condition
 271                 cluster = 0; //start from root
 272
 273                 escapeNotExist = 1;
 274                 if (mode & O_CREAT) {
 275                         XPRINTF("USBHDFSD: FAT I: O_CREAT detected!\n");
 276                         escapeNotExist = 0;
 277                 }
 278
 279                 rec->sfnSector = 0;
 280                 rec->sfnOffset = 0;
 281                 ret = fat_createFile(fatd, name, 0, escapeNotExist, &cluster, &rec->sfnSector, &rec->sfnOffset);
 282                 if (ret < 0) {
 283                     _fs_unlock();
 284                         return ret;
 285                 }
 286                 //the file already exist but mode is set to truncate
 287                 if (ret == 2 && (mode & O_TRUNC)) {
 288                         XPRINTF("USBHDFSD: FAT I: O_TRUNC detected!\n");
 289                         fat_truncateFile(fatd, cluster, rec->sfnSector, rec->sfnOffset);
 290                 }
 291         }
 292 #endif
 293
 294         //find the file
 295         cluster = 0; //allways start from root
 296         XPRINTF("USBHDFSD: Calling fat_getFileStartCluster from fs_open\n");
 297         ret = fat_getFileStartCluster(fatd, name, &cluster, &rec->fatdir);
 298         if (ret < 0) {
 299             _fs_unlock();
 300                 return ret;
 301         }
 302         if ((rec->fatdir.attr & FAT_ATTR_DIRECTORY) == FAT_ATTR_DIRECTORY) {
 303                 // Can't open a directory with fioOpen
 304                 _fs_unlock();
 305                 return -EISDIR;
 306         }
 307
 308         rec->file_flag = 1;
 309         rec->mode = mode;
 310         rec->filePos = 0;
 311         rec->sizeChange  = 0;
 312
 313 #ifdef WRITE_SUPPORT
 314         if ((mode & O_APPEND) && (mode & O_WRONLY)) {
 315                 XPRINTF("USBHDFSD: FAT I: O_APPEND detected!\n");
 316                 rec->filePos = rec->fatdir.size;
 317         }
 318 #endif
 319
 320         //store the slot to user parameters
 321         fd->privdata = rec;
 322
 323         _fs_unlock();
 324         return 1;
 325 }
 326
 327 //---------------------------------------------------------------------------
 328 int fs_close(iop_file_t* fd) {
 329         fat_driver* fatd;
 330         fs_rec* rec = (fs_rec*)fd->privdata;
 331     fd->privdata = 0;
 332
 333     if (rec == 0)
 334         return -EBADF;
 335
 336     _fs_lock();
 337
 338         rec->file_flag = -1;
 339
 340         fatd = fat_getData(fd->unit);
 341         if (fatd == NULL) { _fs_unlock(); return -ENODEV; }
 342
 343 #ifdef WRITE_SUPPORT
 344         if ((rec->mode & O_WRONLY)) {
 345                 //update direntry size and time
 346                 if (rec->sizeChange) {
 347                         fat_updateSfn(fatd, rec->fatdir.size, rec->sfnSector, rec->sfnOffset);
 348                 }
 349
 350                 FLUSH_SECTORS(fatd);
 351         }
 352 #endif
 353
 354     _fs_unlock();
 355         return 0;
 356 }
 357
 358 //---------------------------------------------------------------------------
 359 int fs_lseek(iop_file_t* fd, unsigned long offset, int whence) {
 360         fat_driver* fatd;
 361         fs_rec* rec = (fs_rec*)fd->privdata;
 362
 363     if (rec == 0)
 364         return -EBADF;
 365
 366     _fs_lock();
 367
 368         fatd = fat_getData(fd->unit);
 369         if (fatd == NULL) { _fs_unlock(); return -ENODEV; }
 370
 371         switch(whence) {
 372                 case SEEK_SET:
 373                         rec->filePos = offset;
 374                         break;
 375                 case SEEK_CUR:
 376                         rec->filePos += offset;
 377                         break;
 378                 case SEEK_END:
 379                         rec->filePos = rec->fatdir.size + offset;
 380                         break;
 381                 default:
 382                     _fs_unlock();
 383                         return -1;
 384         }
 385         if (rec->filePos < 0) {
 386                 rec->filePos = 0;
 387         }
 388         if (rec->filePos > rec->fatdir.size) {
 389                 rec->filePos = rec->fatdir.size;
 390         }
 391
 392         _fs_unlock();
 393         return rec->filePos;
 394 }
 395
 396 //---------------------------------------------------------------------------
 397 int fs_write(iop_file_t* fd, void * buffer, int size )
 398 {
 399 #ifdef WRITE_SUPPORT
 400         fat_driver* fatd;
 401         fs_rec* rec = (fs_rec*)fd->privdata;
 402         int result;
 403         int updateClusterIndices = 0;
 404
 405     if (rec == 0)
 406         return -EBADF;
 407
 408     _fs_lock();
 409
 410         fatd = fat_getData(fd->unit);
 411         if (fatd == NULL) { _fs_unlock(); return -ENODEV; }
 412
 413         if (rec->file_flag != 1) {
 414                 _fs_unlock();
 415                 return -EACCES;
 416         }
 417
 418         if (!(rec->mode & O_WRONLY)) {
 419                 _fs_unlock();
 420                 return -EACCES;
 421         }
 422
 423         if (size <= 0) { _fs_unlock(); return 0; }
 424
 425         result = fat_writeFile(fatd, &rec->fatdir, &updateClusterIndices, rec->filePos, (unsigned char*) buffer, size);
 426         if (result > 0) { //write succesful
 427                 rec->filePos += result;
 428                 if (rec->filePos > rec->fatdir.size) {
 429                         rec->fatdir.size = rec->filePos;
 430                         rec->sizeChange = 1;
 431                         //if new clusters allocated - then update file cluster indices
 432                         if (updateClusterIndices) {
 433                                 fat_setFatDirChain(fatd, &rec->fatdir);
 434                         }
 435                 }
 436         }
 437
 438         _fs_unlock();
 439         return result;
 440 #else
 441         return -EROFS;
 442 #endif
 443 }
 444
 445 //---------------------------------------------------------------------------
 446 int fs_read(iop_file_t* fd, void * buffer, int size ) {
 447         fat_driver* fatd;
 448         fs_rec* rec = (fs_rec*)fd->privdata;
 449         int result;
 450
 451     if (rec == 0)
 452         return -EBADF;
 453
 454     _fs_lock();
 455
 456         fatd = fat_getData(fd->unit);
 457         if (fatd == NULL) { _fs_unlock(); return -ENODEV; }
 458
 459         if (rec->file_flag != 1) {
 460                 _fs_unlock();
 461                 return -EACCES;
 462         }
 463
 464         if (!(rec->mode & O_RDONLY)) {
 465                 _fs_unlock();
 466                 return -EACCES;
 467         }
 468
 469         if (size<=0) {
 470                 _fs_unlock();
 471                 return 0;
 472         }
 473
 474         if ((rec->filePos+size) > rec->fatdir.size) {
 475                 size = rec->fatdir.size - rec->filePos;
 476         }
 477
 478         result = fat_readFile(fatd, &rec->fatdir, rec->filePos, (unsigned char*) buffer, size);
 479         if (result > 0) { //read succesful
 480                 rec->filePos += result;
 481         }
 482
 483         _fs_unlock();
 484         return result;
 485 }
 486
 487
 488 //---------------------------------------------------------------------------
 489 int getNameSignature(const char *name) {
 490         int ret;
 491         int i;
 492         ret = 0;
 493
 494         for (i=0; name[i] != 0 ; i++) ret += (name[i]*i/2 + name[i]);
 495         return ret;
 496 }
 497
 498 //---------------------------------------------------------------------------
 499 int getMillis()
 500 {
 501 #ifdef WIN32
 502     return 0;
 503 #else
 504         iop_sys_clock_t clock;
 505         u32 sec, usec;
 506
 507         GetSystemTime(&clock);
 508         SysClock2USec(&clock, &sec, &usec);
 509         return   (sec*1000) + (usec/1000);
 510 #endif
 511 }
 512
 513 //---------------------------------------------------------------------------
 514 int fs_remove (iop_file_t *fd, const char *name) {
 515 #ifdef WRITE_SUPPORT
 516         fat_driver* fatd;
 517         fs_rec* rec;
 518         int result;
 519
 520     _fs_lock();
 521
 522         fatd = fat_getData(fd->unit);
 523         if (fatd == NULL)
 524     {
 525                 result = -ENODEV;
 526                 removalResult = result;
 527         _fs_unlock();
 528                 return result;
 529         }
 530
 531         rec = fs_findFileSlotByName(name);
 532         //store filename signature and time of removal
 533         nameSignature = getNameSignature(name);
 534         removalTime = getMillis();
 535
 536         //file is opened - can't delete the file
 537         if (rec != NULL) {
 538                 result = -EINVAL;
 539                 removalResult = result;
 540         _fs_unlock();
 541                 return result;
 542         }
 543
 544         result = fat_deleteFile(fatd, name, 0);
 545         FLUSH_SECTORS(fatd);
 546         removalTime = getMillis(); //update removal time
 547         removalResult = result;
 548
 549     _fs_unlock();
 550         return result;
 551 #else
 552         return fs_dummy();
 553 #endif
 554 }
 555
 556 //---------------------------------------------------------------------------
 557 int fs_mkdir  (iop_file_t *fd, const char *name) {
 558 #ifdef WRITE_SUPPORT
 559         fat_driver* fatd;
 560         int ret;
 561         int sfnOffset;
 562         unsigned int sfnSector;
 563         unsigned int cluster;
 564         int sig, millis;
 565
 566     _fs_lock();
 567
 568         fatd = fat_getData(fd->unit);
 569         if (fatd == NULL) { _fs_unlock(); return -ENODEV; }
 570
 571         XPRINTF("USBHDFSD: fs_mkdir: name=%s \n",name);
 572         //workaround for bug that invokes fioMkdir right after fioRemove
 573         sig = getNameSignature(name);
 574         millis = getMillis();
 575         if (sig == nameSignature && (millis - removalTime) < 1000) {
 576         _fs_unlock();
 577                 return removalResult; //return the original return code from fs_remove
 578         }
 579
 580         ret = fat_createFile(fatd, name, 1, 0, &cluster,  &sfnSector, &sfnOffset);
 581
 582         //directory of the same name already exist
 583         if (ret == 2) {
 584                 ret = -EEXIST;
 585         }
 586         FLUSH_SECTORS(fatd);
 587
 588     _fs_unlock();
 589         return ret;
 590 #else
 591         return fs_dummy();
 592 #endif
 593 }
 594
 595 //---------------------------------------------------------------------------
 596 // NOTE! you MUST call fioRmdir with device number in the name
 597 // or else this fs_rmdir function is never called.
 598 // example: fioRmdir("mass:/dir1");  //    <-- doesn't work (bug?)
 599 //          fioRmdir("mass0:/dir1"); //    <-- works fine
 600 int fs_rmdir  (iop_file_t *fd, const char *name) {
 601 #ifdef WRITE_SUPPORT
 602         fat_driver* fatd;
 603         int ret;
 604
 605     _fs_lock();
 606
 607         fatd = fat_getData(fd->unit);
 608         if (fatd == NULL) { _fs_unlock(); return -ENODEV; }
 609
 610         ret = fat_deleteFile(fatd, name, 1);
 611         FLUSH_SECTORS(fatd);
 612     _fs_unlock();
 613         return ret;
 614 #else
 615         return fs_dummy();
 616 #endif
 617 }
 618
 619 //---------------------------------------------------------------------------
 620 int fs_dopen  (iop_file_t *fd, const char *name)
 621 {
 622         fat_driver* fatd;
 623         int is_root = 0;
 624         fs_dir* rec;
 625
 626         _fs_lock();
 627
 628     XPRINTF("USBHDFSD: fs_dopen called: unit %d name %s\n", fd->unit, name);
 629
 630         fatd = fat_getData(fd->unit);
 631         if (fatd == NULL) { _fs_unlock(); return -ENODEV; }
 632
 633         if( ((name[0] == '/') && (name[1] == '\0'))
 634                 ||((name[0] == '/') && (name[1] == '.') && (name[2] == '\0')))
 635         {
 636                 name = "/";
 637                 is_root = 1;
 638         }
 639
 640         fd->privdata = (void*)malloc(sizeof(fs_dir));
 641         memset(fd->privdata, 0, sizeof(fs_dir)); //NB: also implies "file_flag = 0;"
 642         rec = (fs_dir *) fd->privdata;
 643
 644         rec->status = fat_getFirstDirentry(fatd, (char*)name, &rec->fatdlist, &rec->fatdir);
 645
 646         // root directory may have no entries, nothing else may.
 647         if(rec->status == 0 && !is_root)
 648                 rec->status = -EFAULT;
 649
 650         if (rec->status < 0)
 651                 free(fd->privdata);
 652
 653         _fs_unlock();
 654         return rec->status;
 655 }
 656
 657 //---------------------------------------------------------------------------
 658 int fs_dclose (iop_file_t *fd)
 659 {
 660     if (fd->privdata == 0)
 661         return -EBADF;
 662
 663         _fs_lock();
 664     XPRINTF("USBHDFSD: fs_dclose called: unit %d\n", fd->unit);
 665         free(fd->privdata);
 666     fd->privdata = 0;
 667         _fs_unlock();
 668         return 0;
 669 }
 670
 671 //---------------------------------------------------------------------------
 672 int fs_dread  (iop_file_t *fd, fio_dirent_t *buffer)
 673 {
 674         fat_driver* fatd;
 675         int ret;
 676         fs_dir* rec = (fs_dir *) fd->privdata;
 677
 678     if (rec == 0)
 679         return -EBADF;
 680
 681         _fs_lock();
 682
 683     XPRINTF("USBHDFSD: fs_dread called: unit %d\n", fd->unit);
 684
 685         fatd = fat_getData(fd->unit);
 686         if (fatd == NULL) { _fs_unlock(); return -ENODEV; }
 687
 688     while (rec->status > 0
 689         && (rec->fatdir.attr & FAT_ATTR_VOLUME_LABEL
 690             || ((rec->fatdir.attr & (FAT_ATTR_HIDDEN | FAT_ATTR_SYSTEM)) == (FAT_ATTR_HIDDEN | FAT_ATTR_SYSTEM))))
 691         rec->status = fat_getNextDirentry(fatd, &rec->fatdlist, &rec->fatdir);
 692
 693     ret = rec->status;
 694         if (rec->status >= 0)
 695     {
 696                 memset(buffer, 0, sizeof(fio_dirent_t));
 697                 fillStat(&buffer->stat, &rec->fatdir);
 698                 strcpy(buffer->name, (const char*) rec->fatdir.name);
 699     }
 700
 701         if (rec->status > 0)
 702                 rec->status = fat_getNextDirentry(fatd, &rec->fatdlist, &rec->fatdir);
 703
 704     _fs_unlock();
 705     return ret;
 706 }
 707
 708 //---------------------------------------------------------------------------
 709 int fs_getstat(iop_file_t *fd, const char *name, fio_stat_t *stat)
 710 {
 711         fat_driver* fatd;
 712         int ret;
 713         unsigned int cluster = 0;
 714         fat_dir fatdir;
 715
 716         _fs_lock();
 717
 718     XPRINTF("USBHDFSD: fs_getstat called: unit %d name %s\n", fd->unit, name);
 719
 720         fatd = fat_getData(fd->unit);
 721         if (fatd == NULL) { _fs_unlock(); return -ENODEV; }
 722
 723         XPRINTF("USBHDFSD: Calling fat_getFileStartCluster from fs_getstat\n");
 724         ret = fat_getFileStartCluster(fatd, name, &cluster, &fatdir);
 725         if (ret < 0) {
 726                 _fs_unlock();
 727                 return ret;
 728         }
 729
 730         memset(stat, 0, sizeof(fio_stat_t));
 731         fillStat(stat, &fatdir);
 732
 733         _fs_unlock();
 734         return 0;
 735 }
 736
 737 //---------------------------------------------------------------------------
 738 int fs_chstat (iop_file_t *fd, const char *name, fio_stat_t *stat, unsigned int a)
 739 {
 740         return fs_dummy();
 741 }
 742
 743 //---------------------------------------------------------------------------
 744 int fs_deinit (iop_device_t *fd)
 745 {
 746         return fs_dummy();
 747 }
 748
 749 //---------------------------------------------------------------------------
 750 int fs_format (iop_file_t *fd)
 751 {
 752         return fs_dummy();
 753 }
 754
 755 //---------------------------------------------------------------------------
 756 unsigned int fs_getFileSector(iop_file_t *fd, char *name)
 757 {
 758         fat_driver* fatd;
 759         int ret;
 760         unsigned int cluster = 0;
 761         fat_dir fatDir;
 762
 763         fatd = fat_getData(fd->unit);
 764         if (fatd == NULL)
 765                 return 0;
 766
 767         ret = fat_getFileStartCluster(fatd, name, &cluster, &fatDir);
 768         if (ret < 0)
 769                 return 0;
 770
 771         return fat_cluster2sector(&fatd->partBpb, cluster);
 772 }
 773
 774 //---------------------------------------------------------------------------
 775 int fs_checkClusterChain(iop_file_t *fd, char *name)
 776 {
 777         int chain_end = 0;
 778         fat_driver* fatd;
 779         fs_rec* rec = NULL;
 780         int ret, chain_size;
 781         unsigned int cluster = 0;
 782
 783         fatd = fat_getData(fd->unit);
 784         if (fatd == NULL)
 785                 return 0;
 786
 787         rec = fs_findFreeFileSlot();
 788         if (rec == NULL)
 789                 return 0;
 790
 791         ret = fat_getFileStartCluster(fatd, name, &cluster, &rec->fatdir);
 792         if (ret < 0) {
 793                 rec->file_flag = -1;
 794                 return 0;
 795         }
 796
 797         rec->file_flag = -1;
 798
 799         // Check cluster chain (write operation can cause dammage if file is fragmented)
 800         while (chain_end == 0) {
 801                 chain_size = fat_getClusterChain(fatd, cluster, fatd->cbuf, MAX_DIR_CLUSTER, 1);
 802
 803                 if(fatd->cbuf[0] != fatd->cbuf[chain_size-1] - (chain_size-1))
 804                         return 0;
 805
 806                 if (chain_size == MAX_DIR_CLUSTER) {
 807                         cluster = fatd->cbuf[chain_size - 1];
 808                 } else {
 809                         chain_end = 1;
 810                 }
 811         }
 812
 813         return 1;
 814 }
 815
 816 //---------------------------------------------------------------------------
 817 int fs_ioctl(iop_file_t *fd, unsigned long request, void *data)
 818 {
 819         fat_driver* fatd;
 820         fs_dir* rec = (fs_dir *) fd->privdata;
 821     int ret;
 822
 823     if (rec == 0)
 824         return -EBADF;
 825
 826         _fs_lock();
 827
 828         fatd = fat_getData(fd->unit);
 829         if (fatd == NULL) { _fs_unlock(); return -ENODEV; }
 830
 831         switch (request) {
 832                 case IOCTL_CKFREE:  //Request to calculate free space (ignore file/folder selected)
 833                         ret = fs_dummy();
 834                         break;
 835                 case IOCTL_RENAME:  //Request to rename opened file/folder
 836                         ret = fs_dummy();
 837                         break;
 838                 case IOCTL_GETCLUSTER:
 839                         ret = fs_getFileSector(fd, (char *)data);
 840                         break;
 841                 case IOCTL_GETDEVSECTORSIZE:
 842                         ret = mass_stor_sectorsize(fatd->dev);
 843                         break;
 844                 case IOCTL_CHECKCHAIN:
 845                         ret = fs_checkClusterChain(fd, (char *)data);
 846                         break;
 847                 default:
 848                         ret = fs_dummy();
 849         }
 850
 851         _fs_unlock();
 852         return ret;
 853 }
 854
 855 #ifndef WIN32
 856 /* init file system driver */
 857 int InitFS()
 858 {
 859         fs_driver.name = "mass";
 860         fs_driver.type = IOP_DT_FS;
 861         fs_driver.version = 2;
 862         fs_driver.desc = "Usb mass storage driver";
 863         fs_driver.ops = &fs_functarray;
 864
 865         fs_functarray.init    = fs_init;
 866         fs_functarray.deinit  = fs_deinit;
 867         fs_functarray.format  = fs_format;
 868         fs_functarray.open    = fs_open;
 869         fs_functarray.close   = fs_close;
 870         fs_functarray.read    = fs_read;
 871         fs_functarray.write   = fs_write;
 872         fs_functarray.lseek   = fs_lseek;
 873         fs_functarray.ioctl   = fs_ioctl;
 874         fs_functarray.remove  = fs_remove;
 875         fs_functarray.mkdir   = fs_mkdir;
 876         fs_functarray.rmdir   = fs_rmdir;
 877         fs_functarray.dopen   = fs_dopen;
 878         fs_functarray.dclose  = fs_dclose;
 879         fs_functarray.dread   = fs_dread;
 880         fs_functarray.getstat = fs_getstat;
 881         fs_functarray.chstat  = fs_chstat;
 882
 883         DelDrv("mass");
 884         AddDrv(&fs_driver);
 885
 886         // should return an error code if AddDrv fails...
 887         return(0);
 888 }
 889 #endif
 890
 891 //---------------------------------------------------------------------------
 892 //End of file:  fs_driver.c
 893 //---------------------------------------------------------------------------