Also fix Debug->View partitions when SECTOR_SIZE!=512
[kugel-rb.git] / uisimulator / common / io.c
blobd87e331970a5fcd7d866accf72212a1eccf68532
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
10 * Copyright (C) 2002 Daniel Stenberg
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.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
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 #ifdef __FreeBSD__
29 #include <sys/param.h>
30 #include <sys/mount.h>
31 #elif defined(__APPLE__)
32 #include <sys/param.h>
33 #include <sys/mount.h>
34 #elif !defined(WIN32)
35 #include <sys/vfs.h>
36 #endif
38 #ifdef WIN32
39 #include <windows.h>
40 #endif
42 #ifndef _MSC_VER
43 #include <dirent.h>
44 #include <unistd.h>
45 #else
46 #include "dir-win32.h"
47 #endif
49 #define MAX_PATH 260
50 #define MAX_OPEN_FILES 11
52 #include <fcntl.h>
53 #include <SDL.h>
54 #include <SDL_thread.h>
55 #include "thread.h"
56 #include "kernel.h"
57 #include "debug.h"
58 #include "config.h"
59 #include "ata.h" /* for IF_MV2 et al. */
60 #include "thread-sdl.h"
63 /* Windows (and potentially other OSes) distinguish binary and text files.
64 * Define a dummy for the others. */
65 #ifndef O_BINARY
66 #define O_BINARY 0
67 #endif
69 /* Unicode compatibility for win32 */
70 #if defined __MINGW32__
71 /* Rockbox unicode functions */
72 extern const unsigned char* utf8decode(const unsigned char *utf8,
73 unsigned short *ucs);
74 extern unsigned char* utf8encode(unsigned long ucs, unsigned char *utf8);
76 /* Static buffers for the conversion results. This isn't thread safe,
77 * but it's sufficient for rockbox. */
78 static unsigned char convbuf1[3*MAX_PATH];
79 static unsigned char convbuf2[3*MAX_PATH];
81 static wchar_t* utf8_to_ucs2(const unsigned char *utf8, void *buffer)
83 wchar_t *ucs = buffer;
85 while (*utf8)
86 utf8 = utf8decode(utf8, ucs++);
88 *ucs = 0;
89 return buffer;
91 static unsigned char *ucs2_to_utf8(const wchar_t *ucs, unsigned char *buffer)
93 unsigned char *utf8 = buffer;
95 while (*ucs)
96 utf8 = utf8encode(*ucs++, utf8);
98 *utf8 = 0;
99 return buffer;
102 #define UTF8_TO_OS(a) utf8_to_ucs2(a,convbuf1)
103 #define OS_TO_UTF8(a) ucs2_to_utf8(a,convbuf1)
104 #define DIR_T _WDIR
105 #define DIRENT_T struct _wdirent
106 #define STAT_T struct _stat
107 extern int _wmkdir(const wchar_t*);
108 extern int _wrmdir(const wchar_t*);
109 #define MKDIR(a,b) (_wmkdir)(UTF8_TO_OS(a))
110 #define RMDIR(a) (_wrmdir)(UTF8_TO_OS(a))
111 #define OPENDIR(a) (_wopendir)(UTF8_TO_OS(a))
112 #define READDIR(a) (_wreaddir)(a)
113 #define CLOSEDIR(a) (_wclosedir)(a)
114 #define STAT(a,b) (_wstat)(UTF8_TO_OS(a),b)
115 #define OPEN(a,b,c) (_wopen)(UTF8_TO_OS(a),b,c)
116 #define CLOSE(a) (close)(a)
117 #define REMOVE(a) (_wremove)(UTF8_TO_OS(a))
118 #define RENAME(a,b) (_wrename)(UTF8_TO_OS(a),utf8_to_ucs2(b,convbuf2))
120 #else /* !__MINGW32__ */
122 #define UTF8_TO_OS(a) (a)
123 #define OS_TO_UTF8(a) (a)
124 #define DIR_T DIR
125 #define DIRENT_T struct dirent
126 #define STAT_T struct stat
127 #define MKDIR(a,b) (mkdir)(a,b)
128 #define RMDIR(a) (rmdir)(a)
129 #define OPENDIR(a) (opendir)(a)
130 #define READDIR(a) (readdir)(a)
131 #define CLOSEDIR(a) (closedir)(a)
132 #define STAT(a,b) (stat)(a,b)
133 #define OPEN(a,b,c) (open)(a,b,c)
134 #define CLOSE(x) (close)(x)
135 #define REMOVE(a) (remove)(a)
136 #define RENAME(a,b) (rename)(a,b)
138 #endif /* !__MINGW32__ */
141 #ifdef HAVE_DIRCACHE
142 void dircache_remove(const char *name);
143 void dircache_rename(const char *oldname, const char *newname);
144 #endif
147 #define SIMULATOR_DEFAULT_ROOT "simdisk"
148 extern const char *sim_root_dir;
150 static int num_openfiles = 0;
152 struct sim_dirent {
153 unsigned char d_name[MAX_PATH];
154 int attribute;
155 long size;
156 long startcluster;
157 unsigned short wrtdate; /* Last write date */
158 unsigned short wrttime; /* Last write time */
161 struct dirstruct {
162 void *dir; /* actually a DIR* dir */
163 char *name;
164 } SIM_DIR;
166 struct mydir {
167 DIR_T *dir;
168 char *name;
171 typedef struct mydir MYDIR;
173 #if 1 /* maybe this needs disabling for MSVC... */
174 static unsigned int rockbox2sim(int opt)
176 int newopt = O_BINARY;
178 if(opt & 1)
179 newopt |= O_WRONLY;
180 if(opt & 2)
181 newopt |= O_RDWR;
182 if(opt & 4)
183 newopt |= O_CREAT;
184 if(opt & 8)
185 newopt |= O_APPEND;
186 if(opt & 0x10)
187 newopt |= O_TRUNC;
189 return newopt;
191 #endif
193 /** Simulator I/O engine routines **/
194 #define IO_YIELD_THRESHOLD 512
196 enum
198 IO_READ,
199 IO_WRITE,
202 struct sim_io
204 struct mutex sim_mutex; /* Rockbox mutex */
205 int cmd; /* The command to perform */
206 int ready; /* I/O ready flag - 1= ready */
207 int fd; /* The file to read/write */
208 void *buf; /* The buffer to read/write */
209 size_t count; /* Number of bytes to read/write */
210 size_t accum; /* Acculated bytes transferred */
213 static struct sim_io io;
215 int ata_init(void)
217 /* Initialize the rockbox kernel objects on a rockbox thread */
218 mutex_init(&io.sim_mutex);
219 io.accum = 0;
220 return 1;
223 int ata_spinup_time(void)
225 return HZ;
228 static ssize_t io_trigger_and_wait(int cmd)
230 void *mythread = NULL;
231 ssize_t result;
233 if (io.count > IO_YIELD_THRESHOLD ||
234 (io.accum += io.count) >= IO_YIELD_THRESHOLD)
236 /* Allow other rockbox threads to run */
237 io.accum = 0;
238 mythread = thread_sdl_thread_unlock();
241 switch (cmd)
243 case IO_READ:
244 result = read(io.fd, io.buf, io.count);
245 break;
246 case IO_WRITE:
247 result = write(io.fd, io.buf, io.count);
248 break;
251 /* Regain our status as current */
252 if (mythread != NULL)
254 thread_sdl_thread_lock(mythread);
257 return result;
260 #ifndef __PCTOOL__
261 static const char *get_sim_pathname(const char *name)
263 static char buffer[MAX_PATH]; /* sufficiently big */
265 if(name[0] == '/')
267 snprintf(buffer, sizeof(buffer), "%s%s",
268 sim_root_dir != NULL ? sim_root_dir : SIMULATOR_DEFAULT_ROOT, name);
269 return buffer;
271 fprintf(stderr, "WARNING, bad file name lacks slash: %s\n", name);
272 return name;
274 #else
275 #define get_sim_pathname(name) name
276 #endif
278 MYDIR *sim_opendir(const char *name)
280 DIR_T *dir;
282 dir = (DIR_T *) OPENDIR(get_sim_pathname(name));
284 if (dir)
286 MYDIR *my = (MYDIR *)malloc(sizeof(MYDIR));
287 my->dir = dir;
288 my->name = (char *)malloc(strlen(name)+1);
289 strcpy(my->name, name);
291 return my;
293 /* failed open, return NULL */
294 return (MYDIR *)0;
297 struct sim_dirent *sim_readdir(MYDIR *dir)
299 char buffer[MAX_PATH]; /* sufficiently big */
300 static struct sim_dirent secret;
301 STAT_T s;
302 DIRENT_T *x11 = READDIR(dir->dir);
303 struct tm* tm;
305 if(!x11)
306 return (struct sim_dirent *)0;
308 strcpy((char *)secret.d_name, OS_TO_UTF8(x11->d_name));
310 /* build file name */
311 snprintf(buffer, sizeof(buffer), "%s/%s",
312 get_sim_pathname(dir->name), secret.d_name);
313 STAT(buffer, &s); /* get info */
315 #define ATTR_DIRECTORY 0x10
317 secret.attribute = S_ISDIR(s.st_mode)?ATTR_DIRECTORY:0;
318 secret.size = s.st_size;
320 tm = localtime(&(s.st_mtime));
321 secret.wrtdate = ((tm->tm_year - 80) << 9) |
322 ((tm->tm_mon + 1) << 5) |
323 tm->tm_mday;
324 secret.wrttime = (tm->tm_hour << 11) |
325 (tm->tm_min << 5) |
326 (tm->tm_sec >> 1);
327 return &secret;
330 void sim_closedir(MYDIR *dir)
332 free(dir->name);
333 CLOSEDIR(dir->dir);
335 free(dir);
338 int sim_open(const char *name, int o)
340 int opts = rockbox2sim(o);
341 int ret;
343 if (num_openfiles >= MAX_OPEN_FILES)
344 return -2;
346 ret = OPEN(get_sim_pathname(name), opts, 0666);
347 if (ret >= 0)
348 num_openfiles++;
349 return ret;
352 int sim_close(int fd)
354 int ret;
355 ret = CLOSE(fd);
356 if (ret == 0)
357 num_openfiles--;
358 return ret;
361 int sim_creat(const char *name)
363 return OPEN(get_sim_pathname(name), O_BINARY | O_WRONLY | O_CREAT | O_TRUNC, 0666);
366 ssize_t sim_read(int fd, void *buf, size_t count)
368 ssize_t result;
370 mutex_lock(&io.sim_mutex);
372 /* Setup parameters */
373 io.fd = fd;
374 io.buf = buf;
375 io.count = count;
377 result = io_trigger_and_wait(IO_READ);
379 mutex_unlock(&io.sim_mutex);
381 return result;
384 ssize_t sim_write(int fd, const void *buf, size_t count)
386 ssize_t result;
388 mutex_lock(&io.sim_mutex);
390 io.fd = fd;
391 io.buf = (void*)buf;
392 io.count = count;
394 result = io_trigger_and_wait(IO_WRITE);
396 mutex_unlock(&io.sim_mutex);
398 return result;
401 int sim_mkdir(const char *name)
403 return MKDIR(get_sim_pathname(name), 0777);
406 int sim_rmdir(const char *name)
408 return RMDIR(get_sim_pathname(name));
411 int sim_remove(const char *name)
413 #ifdef HAVE_DIRCACHE
414 dircache_remove(name);
415 #endif
416 return REMOVE(get_sim_pathname(name));
419 int sim_rename(const char *oldname, const char *newname)
421 #ifdef HAVE_DIRCACHE
422 dircache_rename(oldname, newname);
423 #endif
424 return RENAME(get_sim_pathname(oldname), get_sim_pathname(newname));
427 /* rockbox off_t may be different from system off_t */
428 long sim_lseek(int fildes, long offset, int whence)
430 return lseek(fildes, offset, whence);
433 long sim_filesize(int fd)
435 #ifdef WIN32
436 return _filelength(fd);
437 #else
438 struct stat buf;
440 if (!fstat(fd, &buf))
441 return buf.st_size;
442 else
443 return -1;
444 #endif
447 void fat_size(IF_MV2(int volume,) unsigned long* size, unsigned long* free)
449 #ifdef HAVE_MULTIVOLUME
450 if (volume != 0) {
451 /* debugf("io.c: fat_size(volume=%d); simulator only supports volume 0\n",volume); */
453 if (size) *size = 0;
454 if (free) *free = 0;
455 return;
457 #endif
459 #ifdef WIN32
460 long secperclus, bytespersec, free_clusters, num_clusters;
462 if (GetDiskFreeSpace(NULL, &secperclus, &bytespersec, &free_clusters,
463 &num_clusters)) {
464 if (size)
465 *size = num_clusters * secperclus / 2 * (bytespersec / 512);
466 if (free)
467 *free = free_clusters * secperclus / 2 * (bytespersec / 512);
469 #else
470 struct statfs fs;
472 if (!statfs(".", &fs)) {
473 DEBUGF("statfs: bsize=%d blocks=%ld free=%ld\n",
474 (int)fs.f_bsize, fs.f_blocks, fs.f_bfree);
475 if (size)
476 *size = fs.f_blocks * (fs.f_bsize / 1024);
477 if (free)
478 *free = fs.f_bfree * (fs.f_bsize / 1024);
480 #endif
481 else {
482 if (size)
483 *size = 0;
484 if (free)
485 *free = 0;
489 int sim_fsync(int fd)
491 #ifdef WIN32
492 return _commit(fd);
493 #else
494 return fsync(fd);
495 #endif
498 #ifdef WIN32
499 /* sim-win32 */
500 #define dlopen(_x_, _y_) LoadLibraryW(UTF8_TO_OS(_x_))
501 #define dlsym(_x_, _y_) (void *)GetProcAddress(_x_, _y_)
502 #define dlclose(_x_) FreeLibrary(_x_)
503 #else
504 /* sim-x11 */
505 #include <dlfcn.h>
506 #endif
508 void *sim_codec_load_ram(char* codecptr, int size, void **pd)
510 void *hdr;
511 char name[MAX_PATH];
512 char path[MAX_PATH];
513 int fd;
514 int codec_count;
515 #ifdef WIN32
516 char buf[MAX_PATH];
517 #endif
519 *pd = NULL;
521 /* We have to create the dynamic link library file from ram so we
522 can simulate the codec loading. With voice and crossfade,
523 multiple codecs may be loaded at the same time, so we need
524 to find an unused filename */
525 for (codec_count = 0; codec_count < 10; codec_count++)
527 snprintf(name, sizeof(name), "/_temp_codec%d.dll", codec_count);
528 snprintf(path, sizeof(path), "%s", get_sim_pathname(name));
529 fd = OPEN(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRWXU);
530 if (fd >= 0)
531 break; /* Created a file ok */
533 if (fd < 0)
535 DEBUGF("failed to open for write: %s\n", path);
536 return NULL;
539 if (write(fd, codecptr, size) != size)
541 DEBUGF("write failed");
542 return NULL;
544 close(fd);
546 /* Now load the library. */
547 *pd = dlopen(path, RTLD_NOW);
548 if (*pd == NULL)
550 DEBUGF("failed to load %s\n", path);
551 #ifdef WIN32
552 FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0,
553 buf, sizeof buf, NULL);
554 DEBUGF("dlopen(%s): %s\n", path, buf);
555 #else
556 DEBUGF("dlopen(%s): %s\n", path, dlerror());
557 #endif
558 return NULL;
561 hdr = dlsym(*pd, "__header");
562 if (!hdr)
563 hdr = dlsym(*pd, "___header");
565 return hdr; /* maybe NULL if symbol not present */
568 void sim_codec_close(void *pd)
570 dlclose(pd);
573 void *sim_plugin_load(char *plugin, void **pd)
575 void *hdr;
576 char path[MAX_PATH];
577 #ifdef WIN32
578 char buf[MAX_PATH];
579 #endif
581 snprintf(path, sizeof(path), "%s", get_sim_pathname(plugin));
583 *pd = NULL;
585 *pd = dlopen(path, RTLD_NOW);
586 if (*pd == NULL) {
587 DEBUGF("failed to load %s\n", plugin);
588 #ifdef WIN32
589 FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0,
590 buf, sizeof(buf), NULL);
591 DEBUGF("dlopen(%s): %s\n", path, buf);
592 #else
593 DEBUGF("dlopen(%s): %s\n", path, dlerror());
594 #endif
595 return NULL;
598 hdr = dlsym(*pd, "__header");
599 if (!hdr)
600 hdr = dlsym(*pd, "___header");
602 return hdr; /* maybe NULL if symbol not present */
605 void sim_plugin_close(void *pd)
607 dlclose(pd);
610 #ifdef WIN32
611 static unsigned old_cp;
613 void debug_exit(void)
615 /* Reset console output codepage */
616 SetConsoleOutputCP(old_cp);
619 void debug_init(void)
621 old_cp = GetConsoleOutputCP();
622 /* Set console output codepage to UTF8. Only works
623 * correctly when the console uses a truetype font. */
624 SetConsoleOutputCP(65001);
625 atexit(debug_exit);
627 #else
628 void debug_init(void)
630 /* nothing to be done */
632 #endif
634 void debugf(const char *fmt, ...)
636 va_list ap;
637 va_start( ap, fmt );
638 vfprintf( stderr, fmt, ap );
639 va_end( ap );
642 void ldebugf(const char* file, int line, const char *fmt, ...)
644 va_list ap;
645 va_start( ap, fmt );
646 fprintf( stderr, "%s:%d ", file, line );
647 vfprintf( stderr, fmt, ap );
648 va_end( ap );
651 /* rockbox off_t may be different from system off_t */
652 int sim_ftruncate(int fd, long length)
654 #ifdef WIN32
655 return _chsize(fd, length);
656 #else
657 return ftruncate(fd, length);
658 #endif