firmware/test/fat/main.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <stdarg.h>
   5 #include <time.h>
   6 #include "fat.h"
   7 #include "debug.h"
   8 #include "disk.h"
   9 #include "dir.h"
  10 #include "file.h"
  11
  12 void dbg_dump_sector(int sec);
  13 void dbg_dump_buffer(unsigned char *buf, int len, int offset);
  14 void dbg_console(void);
  15
  16 void mutex_init(void* l) {}
  17 void mutex_lock(void* l) {}
  18 void mutex_unlock(void* l) {}
  19
  20 void panicf( char *fmt, ...)
  21 {
  22     va_list ap;
  23     va_start( ap, fmt );
  24     fprintf(stderr,"***PANIC*** ");
  25     vfprintf(stderr, fmt, ap );
  26     va_end( ap );
  27     exit(1);
  28 }
  29
  30 void debugf(const char *fmt, ...)
  31 {
  32     va_list ap;
  33     va_start( ap, fmt );
  34     fprintf(stderr,"DEBUGF: ");
  35     vfprintf( stderr, fmt, ap );
  36     va_end( ap );
  37 }
  38
  39 void ldebugf(const char* file, int line, const char *fmt, ...)
  40 {
  41     va_list ap;
  42     va_start( ap, fmt );
  43     fprintf( stderr, "%s:%d ", file, line );
  44     vfprintf( stderr, fmt, ap );
  45     va_end( ap );
  46 }
  47
  48 void dbg_dump_sector(int sec)
  49 {
  50     unsigned char buf[512];
  51
  52     ata_read_sectors(sec,1,buf);
  53     DEBUGF("---< Sector %d >-----------------------------------------\n", sec);
  54     dbg_dump_buffer(buf, 512, 0);
  55 }
  56
  57 void dbg_dump_buffer(unsigned char *buf, int len, int offset)
  58 {
  59     int i, j;
  60     unsigned char c;
  61     unsigned char ascii[33];
  62
  63     for(i = 0;i < len/16;i++)
  64     {
  65         DEBUGF("%03x: ", i*16 + offset);
  66         for(j = 0;j < 16;j++)
  67         {
  68             c = buf[i*16+j];
  69
  70             DEBUGF("%02x ", c);
  71             if(c < 32 || c > 127)
  72             {
  73                 ascii[j] = '.';
  74             }
  75             else
  76             {
  77                 ascii[j] = c;
  78             }
  79         }
  80
  81         ascii[j] = 0;
  82         DEBUGF("%s\n", ascii);
  83     }
  84 }
  85
  86 void dbg_dir(char* currdir)
  87 {
  88     DIR* dir;
  89     struct dirent* entry;
  90
  91     dir = opendir(currdir);
  92     if (dir)
  93     {
  94         while ( (entry = readdir(dir)) ) {
  95             DEBUGF("%15s (%d bytes) %x\n",
  96                    entry->d_name, entry->size, entry->startcluster);
  97         }
  98         closedir(dir);
  99     }
 100     else
 101     {
 102         DEBUGF( "Could not open dir %s\n", currdir);
 103     }
 104 }
 105
 106 #define CHUNKSIZE 8
 107 #define BUFSIZE 8192
 108
 109 int dbg_mkfile(char* name, int num)
 110 {
 111     char text[BUFSIZE+1];
 112     int i;
 113     int fd;
 114     int x=0;
 115     bool stop = false;
 116
 117     fd = creat(name,O_WRONLY);
 118     if (fd<0) {
 119         DEBUGF("Failed creating file\n");
 120         return -1;
 121     }
 122     num *= 1024;
 123     while ( num ) {
 124         int rc;
 125         int len = num > BUFSIZE ? BUFSIZE : num;
 126
 127         for (i=0; i<len/CHUNKSIZE; i++ )
 128             sprintf(text+i*CHUNKSIZE,"%c%06x,",name[1],x++);
 129
 130         rc = write(fd, text, len);
 131         if ( rc < 0 ) {
 132             DEBUGF("Failed writing data\n");
 133             return -1;
 134         }
 135         else
 136             if ( rc == 0 ) {
 137                 DEBUGF("No space left\n");
 138                 return -2;
 139             }
 140             else
 141                 DEBUGF("wrote %d bytes\n",rc);
 142
 143         num -= len;
 144
 145         if ( !num ) {
 146             if ( stop )
 147                 break;
 148
 149             /* add a random number of chunks to test byte-copy code */
 150             num = ((int) rand() % SECTOR_SIZE) & ~7;
 151             LDEBUGF("Adding random size %d\n",num);
 152             stop = true;
 153         }
 154     }
 155
 156     return close(fd);
 157 }
 158
 159
 160 int dbg_chkfile(char* name, int size)
 161 {
 162     char text[81920];
 163     int i;
 164     int x=0;
 165     int pos = 0;
 166     int block=0;
 167     int fd = open(name,O_RDONLY);
 168     if (fd<0) {
 169         DEBUGF("Failed opening file\n");
 170         return -1;
 171     }
 172
 173     size = lseek(fd, 0, SEEK_END);
 174     DEBUGF("File is %d bytes\n", size);
 175     /* random start position */
 176     if ( size )
 177         pos = ((int)rand() % size) & ~7;
 178     lseek(fd, pos, SEEK_SET);
 179     x = pos / CHUNKSIZE;
 180
 181     LDEBUGF("Check base is %x (%d)\n",x,pos);
 182
 183     while (1) {
 184         int rc = read(fd, text, sizeof text);
 185         DEBUGF("read %d bytes\n",rc);
 186         if (rc < 0) {
 187             panicf("Failed reading data\n");
 188         }
 189         else {
 190             char tmp[CHUNKSIZE+1];
 191             if (!rc)
 192                 break;
 193             for (i=0; i<rc/CHUNKSIZE; i++ ) {
 194                 sprintf(tmp,"%c%06x,",name[1],x++);
 195                 if (strncmp(text+i*CHUNKSIZE,tmp,CHUNKSIZE)) {
 196                     int idx = pos + block*sizeof(text) + i*CHUNKSIZE;
 197                     DEBUGF("Mismatch in byte 0x%x (byte 0x%x of sector 0x%x)."
 198                            "\nExpected %.8s found %.8s\n",
 199                            idx, idx % SECTOR_SIZE, idx / SECTOR_SIZE,
 200                            tmp,
 201                            text+i*CHUNKSIZE);
 202                     DEBUGF("i=%x, idx=%x\n",i,idx);
 203                     dbg_dump_buffer(text+i*CHUNKSIZE - 0x20, 0x40, idx - 0x20);
 204                     return -1;
 205                 }
 206             }
 207         }
 208         block++;
 209     }
 210
 211     return close(fd);
 212 }
 213
 214 int dbg_wrtest(char* name)
 215 {
 216     char text[81920];
 217     int i;
 218     int x=0;
 219     int pos = 0;
 220     int block=0;
 221     int size, fd, rc;
 222     char tmp[CHUNKSIZE+1];
 223
 224     fd = open(name,O_RDWR);
 225     if (fd<0) {
 226         DEBUGF("Failed opening file\n");
 227         return -1;
 228     }
 229
 230     size = lseek(fd, 0, SEEK_END);
 231     DEBUGF("File is %d bytes\n", size);
 232     /* random start position */
 233     if ( size )
 234         pos = ((int)rand() % size) & ~7;
 235     rc = lseek(fd, pos, SEEK_SET);
 236     if ( rc < 0 )
 237         panicf("Failed seeking\n");
 238     x = pos / CHUNKSIZE;
 239     LDEBUGF("Check base is %x (%d)\n",x,pos);
 240
 241     sprintf(tmp,"%c%06x,",name[1],x++);
 242     rc = write(fd, tmp, 8);
 243     if ( rc < 0 )
 244         panicf("Failed writing data\n");
 245
 246     if ( size )
 247         pos = ((int)rand() % size) & ~7;
 248     rc = lseek(fd, pos, SEEK_SET);
 249     if ( rc < 0 )
 250         panicf("Failed seeking\n");
 251     x = pos / CHUNKSIZE;
 252     LDEBUGF("Check base 2 is %x (%d)\n",x,pos);
 253
 254     while (1) {
 255         rc = read(fd, text, sizeof text);
 256         DEBUGF("read %d bytes\n",rc);
 257         if (rc < 0) {
 258             panicf("Failed reading data\n");
 259         }
 260         else {
 261             if (!rc)
 262                 break;
 263             for (i=0; i<rc/CHUNKSIZE; i++ ) {
 264                 sprintf(tmp,"%c%06x,",name[1],x++);
 265                 if (strncmp(text+i*CHUNKSIZE,tmp,CHUNKSIZE)) {
 266                     int idx = pos + block*sizeof(text) + i*CHUNKSIZE;
 267                     DEBUGF("Mismatch in byte 0x%x (byte 0x%x of sector 0x%x)."
 268                            "\nExpected %.8s found %.8s\n",
 269                            idx, idx % SECTOR_SIZE, idx / SECTOR_SIZE,
 270                            tmp,
 271                            text+i*CHUNKSIZE);
 272                     DEBUGF("i=%x, idx=%x\n",i,idx);
 273                     dbg_dump_buffer(text+i*CHUNKSIZE - 0x20, 0x40, idx - 0x20);
 274                     return -1;
 275                 }
 276             }
 277         }
 278         block++;
 279     }
 280
 281     return close(fd);
 282 }
 283
 284 void dbg_type(char* name)
 285 {
 286     const int size = SECTOR_SIZE*5;
 287     unsigned char buf[SECTOR_SIZE*5+1];
 288     int fd,rc;
 289
 290     fd = open(name,O_RDONLY);
 291     if (fd<0)
 292         return;
 293     DEBUGF("Got file descriptor %d\n",fd);
 294
 295     while ( 1 ) {
 296         rc = read(fd, buf, size);
 297         if( rc > 0 )
 298         {
 299             buf[size] = 0;
 300             printf("%d: %.*s\n", rc, rc, buf);
 301         }
 302         else if ( rc == 0 ) {
 303             DEBUGF("EOF\n");
 304             break;
 305         }
 306         else
 307         {
 308             DEBUGF("Failed reading file: %d\n",rc);
 309             break;
 310         }
 311     }
 312     close(fd);
 313 }
 314
 315 int dbg_append(char* name)
 316 {
 317     int x=0;
 318     int size, fd, rc;
 319     char tmp[CHUNKSIZE+1];
 320
 321     fd = open(name,O_RDONLY);
 322     if (fd<0) {
 323         DEBUGF("Failed opening file\n");
 324         return -1;
 325     }
 326
 327     size = lseek(fd, 0, SEEK_END);
 328     DEBUGF("File is %d bytes\n", size);
 329     x = size / CHUNKSIZE;
 330     LDEBUGF("Check base is %x (%d)\n",x,size);
 331
 332     if (close(fd) < 0)
 333         return -1;
 334
 335     fd = open(name,O_RDWR|O_APPEND);
 336     if (fd<0) {
 337         DEBUGF("Failed opening file\n");
 338         return -1;
 339     }
 340
 341     sprintf(tmp,"%c%06x,",name[1],x++);
 342     rc = write(fd, tmp, 8);
 343     if ( rc < 0 )
 344         panicf("Failed writing data\n");
 345
 346     return close(fd);
 347 }
 348
 349 int dbg_test(char* name)
 350 {
 351     int x=0;
 352     int j;
 353     int fd;
 354     char text[BUFSIZE+1];
 355
 356     for (j=0; j<5; j++) {
 357         int num = 40960;
 358
 359         fd = open(name,O_WRONLY|O_CREAT|O_APPEND);
 360         if (fd<0) {
 361             DEBUGF("Failed opening file\n");
 362             return -1;
 363         }
 364
 365         while ( num ) {
 366             int rc, i;
 367             int len = num > BUFSIZE ? BUFSIZE : num;
 368
 369             for (i=0; i<len/CHUNKSIZE; i++ )
 370                 sprintf(text+i*CHUNKSIZE,"%c%06x,",name[1],x++);
 371
 372             rc = write(fd, text, len);
 373             if ( rc < 0 ) {
 374                 DEBUGF("Failed writing data\n");
 375                 return -1;
 376             }
 377             else
 378                 if ( rc == 0 ) {
 379                     DEBUGF("No space left\n");
 380                     return -2;
 381                 }
 382                 else
 383                     DEBUGF("wrote %d bytes\n",rc);
 384
 385             num -= len;
 386         }
 387
 388         if (close(fd) < 0)
 389             return -1;
 390     }
 391
 392     return 0;
 393 }
 394
 395 int dbg_dump(char* name, int offset)
 396 {
 397     char buf[SECTOR_SIZE];
 398
 399     int rc;
 400     int fd = open(name,O_RDONLY);
 401     if (fd<0) {
 402         DEBUGF("Failed opening file\n");
 403         return -1;
 404     }
 405     lseek(fd, offset, SEEK_SET);
 406     rc = read(fd, buf, sizeof buf);
 407
 408     if ( rc < 0 )
 409         panicf("Error reading data\n");
 410
 411     if (close(fd) < 0)
 412         return -1;
 413
 414     dbg_dump_buffer(buf, rc, offset);
 415
 416     return 0;
 417 }
 418
 419 void dbg_tail(char* name)
 420 {
 421     unsigned char buf[SECTOR_SIZE*5];
 422     int fd,rc;
 423
 424     fd = open(name,O_RDONLY);
 425     if (fd<0)
 426         return;
 427     DEBUGF("Got file descriptor %d\n",fd);
 428
 429     rc = lseek(fd,-512,SEEK_END);
 430     if ( rc >= 0 ) {
 431         rc = read(fd, buf, SECTOR_SIZE);
 432         if( rc > 0 )
 433         {
 434             buf[rc]=0;
 435             printf("%d:\n%s\n", strlen(buf), buf);
 436         }
 437         else if ( rc == 0 ) {
 438             DEBUGF("EOF\n");
 439         }
 440         else
 441         {
 442             DEBUGF("Failed reading file: %d\n",rc);
 443         }
 444     }
 445     else {
 446         perror("lseek");
 447     }
 448
 449     close(fd);
 450 }
 451
 452 int dbg_head(char* name)
 453 {
 454     unsigned char buf[SECTOR_SIZE*5];
 455     int fd,rc;
 456
 457     fd = open(name,O_RDONLY);
 458     if (fd<0)
 459         return -1;
 460     DEBUGF("Got file descriptor %d\n",fd);
 461
 462     rc = read(fd, buf, SECTOR_SIZE*3);
 463     if( rc > 0 )
 464     {
 465         buf[rc]=0;
 466         printf("%d:\n%s\n", strlen(buf), buf);
 467     }
 468     else if ( rc == 0 ) {
 469         DEBUGF("EOF\n");
 470     }
 471     else
 472     {
 473         DEBUGF("Failed reading file: %d\n",rc);
 474     }
 475
 476     return close(fd);
 477 }
 478
 479 int dbg_trunc(char* name, int size)
 480 {
 481     int fd,rc;
 482
 483 #if 1
 484     fd = open(name,O_RDWR);
 485     if (fd<0)
 486         return -1;
 487
 488     rc = ftruncate(fd, size);
 489     if (rc<0) {
 490         DEBUGF("ftruncate(%d) failed\n", size);
 491         return -2;
 492     }
 493
 494 #else
 495     fd = open(name,O_RDWR|O_TRUNC);
 496     if (fd<0)
 497         return -1;
 498
 499     rc = lseek(fd, size, SEEK_SET);
 500     if (fd<0)
 501         return -2;
 502 #endif
 503
 504     return close(fd);
 505 }
 506
 507 int dbg_mkdir(char* name)
 508 {
 509     int fd;
 510
 511     fd = mkdir(name, 0);
 512     if (fd<0) {
 513         DEBUGF("Failed creating directory\n");
 514         return -1;
 515     }
 516     return 0;
 517 }
 518
 519 int dbg_cmd(int argc, char *argv[])
 520 {
 521     char* cmd = NULL;
 522     char* arg1 = NULL;
 523     char* arg2 = NULL;
 524
 525     if (argc > 1) {
 526         cmd = argv[1];
 527         if ( argc > 2 ) {
 528             arg1 = argv[2];
 529             if ( argc > 3 ) {
 530                 arg2 = argv[3];
 531             }
 532         }
 533     }
 534     else {
 535         DEBUGF("usage: fat command [options]\n"
 536                "commands:\n"
 537                " dir <dir>\n"
 538                " ds <sector> - display sector\n"
 539                " type <file>\n"
 540                " head <file>\n"
 541                " tail <file>\n"
 542                " mkfile <file> <size (KB)>\n"
 543                " chkfile <file>\n"
 544                " del <file>\n"
 545                " rmdir <dir>\n"
 546                " dump <file> <offset>\n"
 547                " mkdir <dir>\n"
 548                " trunc <file> <size>\n"
 549                " wrtest <file>\n"
 550                " append <file>\n"
 551                " test <file>\n"
 552                " ren <file> <newname>\n"
 553             );
 554         return -1;
 555     }
 556
 557     if (!strcasecmp(cmd, "dir"))
 558     {
 559         if ( arg1 )
 560             dbg_dir(arg1);
 561         else
 562             dbg_dir("/");
 563     }
 564
 565     if (!strcasecmp(cmd, "ds"))
 566     {
 567         if ( arg1 ) {
 568             DEBUGF("secnum: %d\n", strtol(arg1, NULL, 0));
 569             dbg_dump_sector(strtol(arg1, NULL, 0));
 570         }
 571     }
 572
 573     if (!strcasecmp(cmd, "type"))
 574     {
 575         if (arg1)
 576             dbg_type(arg1);
 577     }
 578
 579     if (!strcasecmp(cmd, "head"))
 580     {
 581         if (arg1)
 582             return dbg_head(arg1);
 583     }
 584
 585     if (!strcasecmp(cmd, "tail"))
 586     {
 587         if (arg1)
 588             dbg_tail(arg1);
 589     }
 590
 591     if (!strcasecmp(cmd, "mkfile"))
 592     {
 593         if (arg1) {
 594             if (arg2)
 595                 return dbg_mkfile(arg1,strtol(arg2, NULL, 0));
 596             else
 597                 return dbg_mkfile(arg1,1);
 598         }
 599     }
 600
 601     if (!strcasecmp(cmd, "chkfile"))
 602     {
 603         if (arg1) {
 604             if (arg2)
 605                 return dbg_chkfile(arg1, strtol(arg2, NULL, 0));
 606             else
 607                 return dbg_chkfile(arg1, 0);
 608         }
 609     }
 610
 611     if (!strcasecmp(cmd, "mkdir"))
 612     {
 613         if (arg1) {
 614             return dbg_mkdir(arg1);
 615         }
 616     }
 617
 618     if (!strcasecmp(cmd, "del"))
 619     {
 620         if (arg1)
 621             return remove(arg1);
 622     }
 623
 624     if (!strcasecmp(cmd, "rmdir"))
 625     {
 626         if (arg1)
 627             return rmdir(arg1);
 628     }
 629
 630     if (!strcasecmp(cmd, "dump"))
 631     {
 632         if (arg1) {
 633             if (arg2)
 634                 return dbg_dump(arg1, strtol(arg2, NULL, 0));
 635             else
 636                 return dbg_dump(arg1, 0);
 637         }
 638     }
 639
 640     if (!strcasecmp(cmd, "wrtest"))
 641     {
 642         if (arg1)
 643             return dbg_wrtest(arg1);
 644     }
 645
 646     if (!strcasecmp(cmd, "append"))
 647     {
 648         if (arg1)
 649             return dbg_append(arg1);
 650     }
 651
 652     if (!strcasecmp(cmd, "test"))
 653     {
 654         if (arg1)
 655             return dbg_test(arg1);
 656     }
 657
 658     if (!strcasecmp(cmd, "trunc"))
 659     {
 660         if (arg1 && arg2)
 661             return dbg_trunc(arg1, strtol(arg2, NULL, 0));
 662     }
 663
 664     if (!strcasecmp(cmd, "ren"))
 665     {
 666         if (arg1 && arg2)
 667             return rename(arg1, arg2);
 668     }
 669
 670     return 0;
 671 }
 672
 673 extern void ata_exit(void);
 674
 675 int main(int argc, char *argv[])
 676 {
 677     int rc,i;
 678     struct partinfo* pinfo;
 679
 680     srand(clock());
 681
 682     if(ata_init()) {
 683         DEBUGF("*** Warning! The disk is uninitialized\n");
 684         return -1;
 685     }
 686     pinfo = disk_init();
 687     if (!pinfo) {
 688         DEBUGF("*** Failed reading partitions\n");
 689         return -1;
 690     }
 691
 692     for ( i=0; i<4; i++ ) {
 693         if ( pinfo[i].type == PARTITION_TYPE_FAT32
 694 #ifdef HAVE_FAT16SUPPORT
 695           || pinfo[i].type == PARTITION_TYPE_FAT16
 696 #endif
 697         ) {
 698             DEBUGF("*** Mounting at block %ld\n",pinfo[i].start);
 699             rc = fat_mount(IF_MV2(0,) IF_MV2(0,) pinfo[i].start);
 700             if(rc) {
 701                 DEBUGF("mount: %d",rc);
 702                 return -1;
 703             }
 704             break;
 705         }
 706     }
 707     if ( i==4 ) {
 708         if(fat_mount(IF_MV2(0,) IF_MV2(0,) 0)) {
 709             DEBUGF("No FAT32 partition!");
 710             return -1;
 711         }
 712     }
 713
 714     rc = dbg_cmd(argc, argv);
 715
 716     ata_exit();
 717
 718     if (rc)
 719         DEBUGF("Return code: %d\n", rc);
 720
 721     return rc;
 722 }
 723