uisimulator/common/io.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 Daniel Stenberg
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <stdarg.h>
  26 #include <sys/stat.h>
  27 #include <time.h>
  28 #include "config.h"
  29
  30 #define HAVE_STATVFS (!defined(WIN32))
  31 #define HAVE_LSTAT   (!defined(WIN32))
  32
  33 #if HAVE_STATVFS
  34 #include <sys/statvfs.h>
  35 #endif
  36
  37 #ifdef WIN32
  38 #include <windows.h>
  39 #endif
  40
  41 #ifndef _MSC_VER
  42 #include <dirent.h>
  43 #include <unistd.h>
  44 #else
  45 #include "dir-win32.h"
  46 #endif
  47
  48 #include <fcntl.h>
  49 #include <SDL.h>
  50 #include <SDL_thread.h>
  51 #include "thread-sdl.h"
  52 #include "thread.h"
  53 #include "kernel.h"
  54 #include "debug.h"
  55 #include "ata.h" /* for IF_MV2 et al. */
  56 #include "rbpaths.h"
  57 #include "load_code.h"
  58
  59 /* keep this in sync with file.h! */
  60 #undef MAX_PATH /* this avoids problems when building simulator */
  61 #define MAX_PATH 260
  62 #define MAX_OPEN_FILES 11
  63
  64 /* Windows (and potentially other OSes) distinguish binary and text files.
  65  * Define a dummy for the others. */
  66 #ifndef O_BINARY
  67 #define O_BINARY 0
  68 #endif
  69
  70 /* Unicode compatibility for win32 */
  71 #if defined __MINGW32__
  72 /* Rockbox unicode functions */
  73 extern const unsigned char* utf8decode(const unsigned char *utf8,
  74                                        unsigned short *ucs);
  75 extern unsigned char* utf8encode(unsigned long ucs, unsigned char *utf8);
  76
  77 /* Static buffers for the conversion results. This isn't thread safe,
  78  * but it's sufficient for rockbox. */
  79 static unsigned char convbuf1[3*MAX_PATH];
  80 static unsigned char convbuf2[3*MAX_PATH];
  81
  82 static wchar_t* utf8_to_ucs2(const unsigned char *utf8, void *buffer)
  83 {
  84     wchar_t *ucs = buffer;
  85
  86     while (*utf8)
  87         utf8 = utf8decode(utf8, ucs++);
  88
  89     *ucs = 0;
  90     return buffer;
  91 }
  92 static unsigned char *ucs2_to_utf8(const wchar_t *ucs, unsigned char *buffer)
  93 {
  94     unsigned char *utf8 = buffer;
  95
  96     while (*ucs)
  97         utf8 = utf8encode(*ucs++, utf8);
  98
  99     *utf8 = 0;
 100     return buffer;
 101 }
 102
 103 #define UTF8_TO_OS(a)  utf8_to_ucs2(a,convbuf1)
 104 #define OS_TO_UTF8(a)  ucs2_to_utf8(a,convbuf1)
 105 #define DIR_T       _WDIR
 106 #define DIRENT_T    struct _wdirent
 107 #define STAT_T      struct _stat
 108 extern int _wmkdir(const wchar_t*);
 109 extern int _wrmdir(const wchar_t*);
 110 #define MKDIR(a,b)  (_wmkdir)(UTF8_TO_OS(a))
 111 #define RMDIR(a)    (_wrmdir)(UTF8_TO_OS(a))
 112 #define OPENDIR(a)  (_wopendir)(UTF8_TO_OS(a))
 113 #define READDIR(a)  (_wreaddir)(a)
 114 #define CLOSEDIR(a) (_wclosedir)(a)
 115 #define STAT(a,b)   (_wstat)(UTF8_TO_OS(a),b)
 116 /* empty variable parameter list doesn't work for variadic macros,
 117  * so pretend the second parameter is variable too */
 118 #define OPEN(a,...) (_wopen)(UTF8_TO_OS(a), __VA_ARGS__)
 119 #define CLOSE(a)    (close)(a)
 120 #define REMOVE(a)   (_wremove)(UTF8_TO_OS(a))
 121 #define RENAME(a,b) (_wrename)(UTF8_TO_OS(a),utf8_to_ucs2(b,convbuf2))
 122
 123 #else  /* !__MINGW32__ */
 124
 125 #define UTF8_TO_OS(a) (a)
 126 #define OS_TO_UTF8(a) (a)
 127 #define DIR_T       DIR
 128 #define DIRENT_T    struct dirent
 129 #define STAT_T      struct stat
 130 #define MKDIR(a,b)  (mkdir)(a,b)
 131 #define RMDIR(a)    (rmdir)(a)
 132 #define OPENDIR(a)  (opendir)(a)
 133 #define READDIR(a)  (readdir)(a)
 134 #define CLOSEDIR(a) (closedir)(a)
 135 #define STAT(a,b)   (stat)(a,b)
 136 /* empty variable parameter list doesn't work for variadic macros,
 137  * so pretend the second parameter is variable too */
 138 #define OPEN(a, ...) (open)(a, __VA_ARGS__)
 139 #define CLOSE(x)    (close)(x)
 140 #define REMOVE(a)   (remove)(a)
 141 #define RENAME(a,b) (rename)(a,b)
 142
 143 #endif /* !__MINGW32__ */
 144
 145
 146 #ifdef HAVE_DIRCACHE
 147 void dircache_remove(const char *name);
 148 void dircache_rename(const char *oldname, const char *newname);
 149 #endif
 150
 151
 152 #define SIMULATOR_DEFAULT_ROOT "simdisk"
 153 extern const char *sim_root_dir;
 154
 155 static int num_openfiles = 0;
 156
 157 /* from dir.h */
 158 struct dirinfo {
 159     int attribute;
 160     long size;
 161     unsigned short wrtdate;
 162     unsigned short wrttime;
 163 };
 164
 165 struct sim_dirent {
 166     unsigned char d_name[MAX_PATH];
 167     struct dirinfo info;
 168     long startcluster;
 169 };
 170
 171 struct dirstruct {
 172     void *dir; /* actually a DIR* dir */
 173     char *name;
 174 } SIM_DIR;
 175
 176 struct mydir {
 177     DIR_T *dir;
 178     char *name;
 179 };
 180
 181 typedef struct mydir MYDIR;
 182
 183 static unsigned int rockbox2sim(int opt)
 184 {
 185 #if 0
 186 /* this shouldn't be needed since we use the host's versions */
 187     int newopt = O_BINARY;
 188
 189     if(opt & 1)
 190         newopt |= O_WRONLY;
 191     if(opt & 2)
 192         newopt |= O_RDWR;
 193     if(opt & 4)
 194         newopt |= O_CREAT;
 195     if(opt & 8)
 196         newopt |= O_APPEND;
 197     if(opt & 0x10)
 198         newopt |= O_TRUNC;
 199
 200     return newopt;
 201 #else
 202     return opt|O_BINARY;
 203 #endif
 204 }
 205
 206 /** Simulator I/O engine routines **/
 207 #define IO_YIELD_THRESHOLD 512
 208
 209 enum io_dir
 210 {
 211     IO_READ,
 212     IO_WRITE,
 213 };
 214
 215 struct sim_io
 216 {
 217     struct mutex sim_mutex; /* Rockbox mutex */
 218     int cmd; /* The command to perform */
 219     int ready; /* I/O ready flag - 1= ready */
 220     int fd; /* The file to read/write */
 221     void *buf; /* The buffer to read/write */
 222     size_t count; /* Number of bytes to read/write */
 223     size_t accum; /* Acculated bytes transferred */
 224 };
 225
 226 static struct sim_io io;
 227
 228 int ata_init(void)
 229 {
 230     /* Initialize the rockbox kernel objects on a rockbox thread */
 231     mutex_init(&io.sim_mutex);
 232     io.accum = 0;
 233     return 1;
 234 }
 235
 236 int ata_spinup_time(void)
 237 {
 238     return HZ;
 239 }
 240
 241 static ssize_t io_trigger_and_wait(enum io_dir cmd)
 242 {
 243     void *mythread = NULL;
 244     ssize_t result;
 245
 246     if (io.count > IO_YIELD_THRESHOLD ||
 247         (io.accum += io.count) >= IO_YIELD_THRESHOLD)
 248     {
 249         /* Allow other rockbox threads to run */
 250         io.accum = 0;
 251         mythread = sim_thread_unlock();
 252     }
 253
 254     switch (cmd)
 255     {
 256     case IO_READ:
 257         result = read(io.fd, io.buf, io.count);
 258         break;
 259     case IO_WRITE:
 260         result = write(io.fd, io.buf, io.count);
 261         break;
 262         /* shut up gcc */
 263     default:
 264         result = -1;
 265     }
 266
 267     /* Regain our status as current */
 268     if (mythread != NULL)
 269     {
 270         sim_thread_lock(mythread);
 271     }
 272
 273     return result;
 274 }
 275
 276 #if !defined(__PCTOOL__) && !defined(APPLICATION)
 277 static const char *get_sim_pathname(const char *name)
 278 {
 279     static char buffer[MAX_PATH]; /* sufficiently big */
 280
 281     if(name[0] == '/')
 282     {
 283         snprintf(buffer, sizeof(buffer), "%s%s",
 284             sim_root_dir != NULL ? sim_root_dir : SIMULATOR_DEFAULT_ROOT, name);
 285         return buffer;
 286     }
 287     fprintf(stderr, "WARNING, bad file name lacks slash: %s\n", name);
 288     return name;
 289 }
 290 #else
 291 #define get_sim_pathname(name) name
 292 #endif
 293
 294 MYDIR *sim_opendir(const char *name)
 295 {
 296     DIR_T *dir;
 297     dir = (DIR_T *) OPENDIR(get_sim_pathname(name));
 298
 299     if (dir)
 300     {
 301         MYDIR *my = (MYDIR *)malloc(sizeof(MYDIR));
 302         my->dir = dir;
 303         my->name = (char *)malloc(strlen(name)+1);
 304         strcpy(my->name, name);
 305
 306         return my;
 307     }
 308     /* failed open, return NULL */
 309     return (MYDIR *)0;
 310 }
 311
 312 #if defined(WIN32)
 313 static inline struct tm* localtime_r (const time_t *clock, struct tm *result) {
 314        if (!clock || !result) return NULL;
 315        memcpy(result,localtime(clock),sizeof(*result));
 316        return result;
 317 }
 318 #endif
 319
 320 struct sim_dirent *sim_readdir(MYDIR *dir)
 321 {
 322     char buffer[MAX_PATH]; /* sufficiently big */
 323     static struct sim_dirent secret;
 324     STAT_T s;
 325     DIRENT_T *x11 = READDIR(dir->dir);
 326     struct tm tm;
 327
 328     if(!x11)
 329         return (struct sim_dirent *)0;
 330
 331     strcpy((char *)secret.d_name, OS_TO_UTF8(x11->d_name));
 332
 333     /* build file name */
 334     snprintf(buffer, sizeof(buffer), "%s/%s",
 335         get_sim_pathname(dir->name), secret.d_name);
 336     if (STAT(buffer, &s)) /* get info */
 337         return NULL;
 338
 339 #define ATTR_DIRECTORY 0x10
 340
 341     secret.info.attribute = 0;
 342
 343     if (S_ISDIR(s.st_mode))
 344         secret.info.attribute = ATTR_DIRECTORY;
 345
 346     secret.info.size = s.st_size;
 347
 348     if (localtime_r(&(s.st_mtime), &tm) == NULL)
 349         return NULL;
 350     secret.info.wrtdate = ((tm.tm_year - 80) << 9) |
 351                         ((tm.tm_mon + 1) << 5) |
 352                         tm.tm_mday;
 353     secret.info.wrttime = (tm.tm_hour << 11) |
 354                         (tm.tm_min << 5) |
 355                         (tm.tm_sec >> 1);
 356
 357 #if HAVE_LSTAT
 358 #define ATTR_LINK      0x80
 359     if (!lstat(buffer, &s) && S_ISLNK(s.st_mode))
 360     {
 361         secret.info.attribute |= ATTR_LINK;
 362     }
 363 #endif
 364
 365     return &secret;
 366 }
 367
 368 void sim_closedir(MYDIR *dir)
 369 {
 370     free(dir->name);
 371     CLOSEDIR(dir->dir);
 372
 373     free(dir);
 374 }
 375
 376 int sim_open(const char *name, int o, ...)
 377 {
 378     int opts = rockbox2sim(o);
 379     int ret;
 380     if (num_openfiles >= MAX_OPEN_FILES)
 381         return -2;
 382
 383     if (opts & O_CREAT)
 384     {
 385         va_list ap;
 386         va_start(ap, o);
 387         mode_t mode = va_arg(ap, unsigned int);
 388         ret = OPEN(get_sim_pathname(name), opts, mode);
 389         va_end(ap);
 390     }
 391     else
 392         ret = OPEN(get_sim_pathname(name), opts);
 393
 394     if (ret >= 0)
 395         num_openfiles++;
 396     return ret;
 397 }
 398
 399 int sim_close(int fd)
 400 {
 401     int ret;
 402     ret = CLOSE(fd);
 403     if (ret == 0)
 404         num_openfiles--;
 405     return ret;
 406 }
 407
 408 int sim_creat(const char *name, mode_t mode)
 409 {
 410     return OPEN(get_sim_pathname(name), O_BINARY | O_WRONLY | O_CREAT | O_TRUNC, mode);
 411 }
 412
 413 ssize_t sim_read(int fd, void *buf, size_t count)
 414 {
 415     ssize_t result;
 416
 417     mutex_lock(&io.sim_mutex);
 418
 419     /* Setup parameters */
 420     io.fd = fd;
 421     io.buf = buf;
 422     io.count = count;
 423
 424     result = io_trigger_and_wait(IO_READ);
 425
 426     mutex_unlock(&io.sim_mutex);
 427
 428     return result;
 429 }
 430
 431 ssize_t sim_write(int fd, const void *buf, size_t count)
 432 {
 433     ssize_t result;
 434
 435     mutex_lock(&io.sim_mutex);
 436
 437     io.fd = fd;
 438     io.buf = (void*)buf;
 439     io.count = count;
 440
 441     result = io_trigger_and_wait(IO_WRITE);
 442
 443     mutex_unlock(&io.sim_mutex);
 444
 445     return result;
 446 }
 447
 448 int sim_mkdir(const char *name)
 449 {
 450     return MKDIR(get_sim_pathname(name), 0777);
 451 }
 452
 453 int sim_rmdir(const char *name)
 454 {
 455     return RMDIR(get_sim_pathname(name));
 456 }
 457
 458 int sim_remove(const char *name)
 459 {
 460 #ifdef HAVE_DIRCACHE
 461     dircache_remove(name);
 462 #endif
 463     return REMOVE(get_sim_pathname(name));
 464 }
 465
 466 int sim_rename(const char *oldname, const char *newname)
 467 {
 468     char sim_old[MAX_PATH];
 469     char sim_new[MAX_PATH];
 470 #ifdef HAVE_DIRCACHE
 471     dircache_rename(oldname, newname);
 472 #endif
 473     // This is needed as get_sim_pathname() has a static buffer
 474     strncpy(sim_old, get_sim_pathname(oldname), MAX_PATH);
 475     strncpy(sim_new, get_sim_pathname(newname), MAX_PATH);
 476     return RENAME(sim_old, sim_new);
 477 }
 478
 479 /* rockbox off_t may be different from system off_t */
 480 long sim_lseek(int fildes, long offset, int whence)
 481 {
 482     return lseek(fildes, offset, whence);
 483 }
 484
 485 long sim_filesize(int fd)
 486 {
 487 #ifdef WIN32
 488     return _filelength(fd);
 489 #else
 490     struct stat buf;
 491
 492     if (!fstat(fd, &buf))
 493         return buf.st_size;
 494     else
 495         return -1;
 496 #endif
 497 }
 498
 499 void fat_size(IF_MV2(int volume,) unsigned long* size, unsigned long* free)
 500 {
 501 #ifdef HAVE_MULTIVOLUME
 502     if (volume != 0) {
 503         /* debugf("io.c: fat_size(volume=%d); simulator only supports volume 0\n",volume); */
 504
 505         if (size) *size = 0;
 506         if (free) *free = 0;
 507         return;
 508     }
 509 #endif
 510
 511 #ifdef WIN32
 512     long secperclus, bytespersec, free_clusters, num_clusters;
 513
 514     if (GetDiskFreeSpace(NULL, &secperclus, &bytespersec, &free_clusters,
 515                      &num_clusters)) {
 516         if (size)
 517             *size = num_clusters * secperclus / 2 * (bytespersec / 512);
 518         if (free)
 519             *free = free_clusters * secperclus / 2 * (bytespersec / 512);
 520     }
 521 #elif HAVE_STATVFS
 522     struct statvfs vfs;
 523
 524     if (!statvfs(".", &vfs)) {
 525         DEBUGF("statvfs: frsize=%d blocks=%ld free=%ld\n",
 526                (int)vfs.f_frsize, (long)vfs.f_blocks, (long)vfs.f_bfree);
 527         if (size)
 528             *size = vfs.f_blocks / 2 * (vfs.f_frsize / 512);
 529         if (free)
 530             *free = vfs.f_bfree / 2 * (vfs.f_frsize / 512);
 531     } else
 532 #endif
 533     {
 534         if (size)
 535             *size = 0;
 536         if (free)
 537             *free = 0;
 538     }
 539 }
 540
 541 int sim_fsync(int fd)
 542 {
 543 #ifdef WIN32
 544     return _commit(fd);
 545 #else
 546     return fsync(fd);
 547 #endif
 548 }
 549
 550 #ifndef __PCTOOL__
 551
 552 void *lc_open(const char *filename, unsigned char *buf, size_t buf_size)
 553 {
 554     const char *sim_path = get_sim_pathname(filename);
 555     void *handle = _lc_open(UTF8_TO_OS(sim_path), buf, buf_size);
 556
 557     if (handle == NULL)
 558     {
 559         DEBUGF("failed to load %s\n", filename);
 560         DEBUGF("lc_open(%s): %s\n", filename, lc_last_error());
 561     }
 562     return handle;
 563 }
 564
 565 void *lc_get_header(void *handle)
 566 {
 567     return _lc_get_header(handle);
 568 }
 569
 570 void lc_close(void *handle)
 571 {
 572     _lc_close(handle);
 573 }
 574
 575 #endif /* __PCTOOL__ */
 576 #ifdef WIN32
 577 static unsigned old_cp;
 578
 579 void debug_exit(void)
 580 {
 581     /* Reset console output codepage */
 582     SetConsoleOutputCP(old_cp);
 583 }
 584
 585 void debug_init(void)
 586 {
 587     old_cp = GetConsoleOutputCP();
 588     /* Set console output codepage to UTF8. Only works
 589      * correctly when the console uses a truetype font. */
 590     SetConsoleOutputCP(65001);
 591     atexit(debug_exit);
 592 }
 593 #else
 594 void debug_init(void)
 595 {
 596     /* nothing to be done */
 597 }
 598 #endif
 599
 600 void debugf(const char *fmt, ...)
 601 {
 602     va_list ap;
 603     va_start( ap, fmt );
 604     vfprintf( stderr, fmt, ap );
 605     va_end( ap );
 606 }
 607
 608 void ldebugf(const char* file, int line, const char *fmt, ...)
 609 {
 610     va_list ap;
 611     va_start( ap, fmt );
 612     fprintf( stderr, "%s:%d ", file, line );
 613     vfprintf( stderr, fmt, ap );
 614     va_end( ap );
 615 }
 616
 617 /* rockbox off_t may be different from system off_t */
 618 int sim_ftruncate(int fd, long length)
 619 {
 620 #ifdef WIN32
 621     return _chsize(fd, length);
 622 #else
 623     return ftruncate(fd, length);
 624 #endif
 625 }