static osd_shared_mem *osd_sharedmem_alloc(const char *path, int create, size_t size)
{
int fd;
osd_shared_mem *os_shmem = (osd_shared_mem *) osd_malloc(sizeof(osd_shared_mem));
if (create)
{
char *buf = (char *) osd_malloc_array(size);
memset(buf,0, size);
fd = open(path, O_RDWR | O_CREAT, S_IRWXU);
write(fd, buf, size);
os_shmem->creator = 1;
}
else
{
fd = open(path, O_RDWR);
if (fd == -1)
{
osd_free(os_shmem);
return NULL;
}
os_shmem->creator = 0;
}
os_shmem->fn = (char *) osd_malloc_array(strlen(path)+1);
strcpy(os_shmem->fn, path);
assert(fd != -1);
os_shmem->ptr = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
os_shmem->size = size;
close(fd);
return os_shmem;
}
text_buffer *text_buffer_alloc(UINT32 bytes, UINT32 lines)
{
text_buffer *text;
/* allocate memory for the text buffer object */
text = (text_buffer *)osd_malloc(sizeof(*text));
if (!text)
return NULL;
/* allocate memory for the buffer itself */
text->buffer = (char *)osd_malloc_array(bytes);
if (!text->buffer)
{
osd_free(text);
return NULL;
}
/* allocate memory for the lines array */
text->lineoffs = (INT32 *)osd_malloc_array(lines * sizeof(text->lineoffs[0]));
if (!text->lineoffs)
{
osd_free(text->buffer);
osd_free(text);
return NULL;
}
/* initialize the buffer description */
text->bufsize = bytes;
text->linesize = lines;
text_buffer_clear(text);
return text;
}
file_error osd_get_full_path(char **dst, const char *path)
{
file_error err;
char path_buffer[512];
err = FILERR_NONE;
if (getcwd(path_buffer, 511) == NULL)
{
printf("osd_get_full_path: failed!\n");
err = FILERR_FAILURE;
}
else
{
*dst = (char *)osd_malloc_array(strlen(path_buffer)+strlen(path)+3);
// if it's already a full path, just pass it through
if (path[0] == '/')
{
strcpy(*dst, path);
}
else
{
sprintf(*dst, "%s%s%s", path_buffer, PATH_SEPARATOR, path);
}
}
return err;
}
void *malloc_array_file_line(size_t size, const char *file, int line)
{
// allocate the memory and fail if we can't
void *ret = osd_malloc_array(size);
memset(ret, 0, size);
return ret;
}
void *malloc_file_line(size_t size, const char *file, int line, bool array, bool throw_on_fail, bool clear)
{
// allocate the memory and fail if we can't
void *result = array ? osd_malloc_array(size) : osd_malloc(size);
if (result == nullptr)
{
fprintf(stderr, "Failed to allocate %d bytes (%s:%d)\n", UINT32(size), file, line);
osd_break_into_debugger("Failed to allocate RAM");
if (throw_on_fail)
throw std::bad_alloc();
return nullptr;
}
// zap the memory if requested
if (clear)
memset(result, 0, size);
else
{
#if !__has_feature(memory_sanitizer) && defined(INITIALIZE_ALLOCATED_MEMORY) && !defined(MAME_DEBUG_FAST)
memset(result, 0xdd, size);
#endif
}
// add a new entry
memory_entry::allocate(size, result, file, line, array);
return result;
}
osd_directory_entry *osd_stat(const char *path)
{
int err;
osd_directory_entry *result = NULL;
#if defined(SDLMAME_NO64BITIO) || defined(SDLMAME_BSD) || defined(SDLMAME_DARWIN) || defined(SDLMAME_OS2)
struct stat st;
#else
struct stat64 st;
#endif
#if defined(SDLMAME_NO64BITIO) || defined(SDLMAME_BSD) || defined(SDLMAME_DARWIN) || defined(SDLMAME_OS2)
err = stat(path, &st);
#else
err = stat64(path, &st);
#endif
if( err == -1) return NULL;
// create an osd_directory_entry; be sure to make sure that the caller can
// free all resources by just freeing the resulting osd_directory_entry
result = (osd_directory_entry *) osd_malloc_array(sizeof(*result) + strlen(path) + 1);
strcpy(((char *) result) + sizeof(*result), path);
result->name = ((char *) result) + sizeof(*result);
result->type = S_ISDIR(st.st_mode) ? ENTTYPE_DIR : ENTTYPE_FILE;
result->size = (UINT64)st.st_size;
return result;
}
file_error osd_get_full_path(char **dst, const char *path)
{
*dst = (char *)osd_malloc_array(CCHMAXPATH + 1);
if (*dst == NULL)
return FILERR_OUT_OF_MEMORY;
_abspath(*dst, path, CCHMAXPATH + 1);
return FILERR_NONE;
}
static osd_shared_mem *osd_sharedmem_alloc(const char *path, int create, size_t size)
{
osd_shared_mem *os_shmem = (osd_shared_mem *) osd_malloc(sizeof(osd_shared_mem));
os_shmem->creator = 0;
os_shmem->ptr = (void *) osd_malloc_array(size);
os_shmem->size = size;
return os_shmem;
}
char *core_strdup(const char *str)
{
char *cpy = NULL;
if (str != NULL)
{
cpy = (char *)osd_malloc_array(strlen(str) + 1);
if (cpy != NULL)
strcpy(cpy, str);
}
return cpy;
}
static char *build_full_path(const char *path, const char *file)
{
char *ret = (char *) osd_malloc_array(strlen(path)+strlen(file)+2);
char *p = ret;
strcpy(p, path);
p += strlen(path);
*p++ = PATHSEPCH;
strcpy(p, file);
return ret;
}
WCHAR *wstring_from_utf8(const char *utf8string)
{
int char_count;
WCHAR *result;
// convert MAME string (UTF-8) to UTF-16
char_count = MultiByteToWideChar(CP_UTF8, 0, utf8string, -1, NULL, 0);
result = (WCHAR *)osd_malloc_array(char_count * sizeof(*result));
if (result != NULL)
MultiByteToWideChar(CP_UTF8, 0, utf8string, -1, result, char_count);
return result;
}
char *osd_get_clipboard_text(void)
{
char *result = NULL;
if (SDL_HasClipboardText())
{
char *temp = SDL_GetClipboardText();
result = (char *) osd_malloc_array(strlen(temp) + 1);
strcpy(result, temp);
SDL_free(temp);
}
return result;
}
char *utf8_from_wstring(const WCHAR *wstring)
{
int char_count;
char *result;
// convert UTF-16 to MAME string (UTF-8)
char_count = WideCharToMultiByte(CP_UTF8, 0, wstring, -1, NULL, 0, NULL, NULL);
result = (char *)osd_malloc_array(char_count * sizeof(*result));
if (result != NULL)
WideCharToMultiByte(CP_UTF8, 0, wstring, -1, result, char_count, NULL, NULL);
return result;
}
file_error osd_get_full_path(char **dst, const char *path)
{
// derive the full path of the file in an allocated string
// for now just fake it since we don't presume any underlying file system
*dst = NULL;
if (path != NULL)
{
*dst = (char *)osd_malloc_array(strlen(path) + 1);
if (*dst != NULL)
strcpy(*dst, path);
}
return FILERR_NONE;
}
memory_entry *memory_entry::allocate(size_t size, void *base, const char *file, int line, bool array)
{
acquire_lock();
// if we're out of free entries, allocate a new chunk
if (s_freehead == nullptr)
{
// create a new chunk, and fail if we can't
memory_entry *entry = reinterpret_cast<memory_entry *>(osd_malloc_array(memory_block_alloc_chunk * sizeof(memory_entry)));
if (entry == nullptr)
{
release_lock();
return nullptr;
}
// add all the entries to the list
for (int entrynum = 0; entrynum < memory_block_alloc_chunk; entrynum++)
{
entry->m_next = s_freehead;
s_freehead = entry++;
}
}
// grab a free entry
memory_entry *entry = s_freehead;
s_freehead = entry->m_next;
// populate it
entry->m_size = size;
entry->m_base = base;
entry->m_file = s_tracking ? file : nullptr;
entry->m_line = s_tracking ? line : 0;
entry->m_id = s_curid++;
entry->m_array = array;
if (LOG_ALLOCS)
fprintf(stderr, "#%06d, alloc %d bytes (%s:%d)\n", (UINT32)entry->m_id, static_cast<UINT32>(entry->m_size), entry->m_file, (int)entry->m_line);
// add it to the alloc list
int hashval = reinterpret_cast<FPTR>(base) % k_hash_prime;
entry->m_next = s_hash[hashval];
if (entry->m_next != nullptr)
entry->m_next->m_prev = entry;
entry->m_prev = nullptr;
s_hash[hashval] = entry;
release_lock();
return entry;
}
void *malloc_array_file_line(size_t size, const char *file, int line)
{
// allocate the memory and fail if we can't
void *result = osd_malloc_array(size);
if (result == NULL)
return NULL;
// add a new entry
memory_entry::allocate(size, result, file, line);
#if !__has_feature(memory_sanitizer) && defined(MAME_DEBUG)
memset(result, 0xdd, size);
#endif
return result;
}
void *malloc_array_file_line(size_t size, const char *file, int line)
{
// allocate the memory and fail if we can't
void *result = osd_malloc_array(size);
if (result == NULL)
return NULL;
// add a new entry
memory_entry::allocate(size, result, file, line);
#ifdef MAME_DEBUG
// randomize the memory
rand_memory(result, size);
#endif
return result;
}
CHAR *astring_from_utf8(const char *utf8string)
{
WCHAR *wstring;
int char_count;
CHAR *result;
// convert MAME string (UTF-8) to UTF-16
char_count = MultiByteToWideChar(CP_UTF8, 0, utf8string, -1, NULL, 0);
wstring = (WCHAR *)alloca(char_count * sizeof(*wstring));
MultiByteToWideChar(CP_UTF8, 0, utf8string, -1, wstring, char_count);
// convert UTF-16 to "ANSI code page" string
char_count = WideCharToMultiByte(CP_ACP, 0, wstring, -1, NULL, 0, NULL, NULL);
result = (CHAR *)osd_malloc_array(char_count * sizeof(*result));
if (result != NULL)
WideCharToMultiByte(CP_ACP, 0, wstring, -1, result, char_count, NULL, NULL);
return result;
}
int osd_setenv(const char *name, const char *value, int overwrite)
{
char *buf;
int result;
if (!overwrite)
{
if (osd_getenv(name) != NULL)
return 0;
}
buf = (char *) osd_malloc_array(strlen(name)+strlen(value)+2);
sprintf(buf, "%s=%s", name, value);
result = putenv(buf);
/* will be referenced by environment
* Therefore it is not freed here
*/
return result;
}
osd_directory_entry *osd_stat(const char *path)
{
int err;
osd_directory_entry *result = NULL;
struct stat st;
err = stat(path, &st);
if( err == -1) return NULL;
// create an osd_directory_entry; be sure to make sure that the caller can
// free all resources by just freeing the resulting osd_directory_entry
result = (osd_directory_entry *) osd_malloc_array(sizeof(*result) + strlen(path) + 1);
strcpy(((char *) result) + sizeof(*result), path);
result->name = ((char *) result) + sizeof(*result);
result->type = S_ISDIR(st.st_mode) ? ENTTYPE_DIR : ENTTYPE_FILE;
result->size = (UINT64)st.st_size;
return result;
}
char *utf8_from_astring(const CHAR *astring)
{
UINT acp = get_osdcore_acp();
WCHAR *wstring;
int char_count;
CHAR *result;
// convert "ANSI code page" string to UTF-16
char_count = MultiByteToWideChar(acp, 0, astring, -1, NULL, 0);
wstring = (WCHAR *)alloca(char_count * sizeof(*wstring));
MultiByteToWideChar(acp, 0, astring, -1, wstring, char_count);
// convert UTF-16 to MAME string (UTF-8)
char_count = WideCharToMultiByte(CP_UTF8, 0, wstring, -1, NULL, 0, NULL, NULL);
result = (CHAR *)osd_malloc_array(char_count * sizeof(*result));
if (result != NULL)
WideCharToMultiByte(CP_UTF8, 0, wstring, -1, result, char_count, NULL, NULL);
return result;
}
osd_directory_entry *osd_stat(const std::string &path)
{
#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__DragonFly__) || defined(__HAIKU__) || defined(WIN32) || defined(SDLMAME_NO64BITIO) || defined(__ANDROID__)
struct stat st;
int const err = ::stat(path.c_str(), &st);
#else
struct stat64 st;
int const err = ::stat64(path.c_str(), &st);
#endif
if (err < 0) return nullptr;
// create an osd_directory_entry; be sure to make sure that the caller can
// free all resources by just freeing the resulting osd_directory_entry
osd_directory_entry *const result = reinterpret_cast<osd_directory_entry *>(osd_malloc_array(sizeof(osd_directory_entry) + path.length() + 1));
std::strcpy(reinterpret_cast<char *>(result) + sizeof(*result), path.c_str());
result->name = reinterpret_cast<char *>(result) + sizeof(*result);
result->type = S_ISDIR(st.st_mode) ? ENTTYPE_DIR : ENTTYPE_FILE;
result->size = std::uint64_t(std::make_unsigned_t<decltype(st.st_size)>(st.st_size));
return result;
}
osd_directory_entry *osd_stat(const std::string &path)
{
osd_directory_entry *result = nullptr;
// create an osd_directory_entry; be sure to make sure that the caller can
// free all resources by just freeing the resulting osd_directory_entry
result = (osd_directory_entry *)osd_malloc_array(sizeof(*result) + path.length() + 1);
strcpy((char *)(result + 1), path.c_str());
result->name = (char *)(result + 1);
result->type = ENTTYPE_NONE;
result->size = 0;
FILE *f = std::fopen(path.c_str(), "rb");
if (f != nullptr)
{
std::fseek(f, 0, SEEK_END);
result->type = ENTTYPE_FILE;
result->size = std::ftell(f);
std::fclose(f);
}
return result;
}
osd_directory_entry *osd_stat(const char *path)
{
osd_directory_entry *result = NULL;
// create an osd_directory_entry; be sure to make sure that the caller can
// free all resources by just freeing the resulting osd_directory_entry
result = (osd_directory_entry *)osd_malloc_array(sizeof(*result) + strlen(path) + 1);
strcpy((char *)(result + 1), path);
result->name = (char *)(result + 1);
result->type = ENTTYPE_NONE;
result->size = 0;
FILE *f = fopen(path, "rb");
if (f != NULL)
{
fseek(f, 0, SEEK_END);
result->type = ENTTYPE_FILE;
result->size = ftell(f);
fclose(f);
}
return result;
}
osd_directory_entry *osd_stat(const std::string &path)
{
// convert the path to TCHARs
std::unique_ptr<TCHAR, void (*)(void *)> const t_path(tstring_from_utf8(path.c_str()), &osd_free);
if (!t_path)
return nullptr;
// is this path a root directory (e.g. - C:)?
WIN32_FIND_DATA find_data;
std::memset(&find_data, 0, sizeof(find_data));
if (isalpha(path[0]) && (path[1] == ':') && (path[2] == '\0'))
{
// need to do special logic for root directories
if (!GetFileAttributesEx(t_path.get(), GetFileExInfoStandard, &find_data.dwFileAttributes))
find_data.dwFileAttributes = INVALID_FILE_ATTRIBUTES;
}
else
{
// attempt to find the first file
HANDLE find = FindFirstFileEx(t_path.get(), FindExInfoStandard, &find_data, FindExSearchNameMatch, nullptr, 0);
if (find == INVALID_HANDLE_VALUE)
return nullptr;
FindClose(find);
}
// create an osd_directory_entry; be sure to make sure that the caller can
// free all resources by just freeing the resulting osd_directory_entry
osd_directory_entry *const result = (osd_directory_entry *)osd_malloc_array(sizeof(*result) + path.length() + 1);
if (!result)
return nullptr;
strcpy(((char *) result) + sizeof(*result), path.c_str());
result->name = ((char *) result) + sizeof(*result);
result->type = win_attributes_to_entry_type(find_data.dwFileAttributes);
result->size = find_data.nFileSizeLow | ((UINT64) find_data.nFileSizeHigh << 32);
return result;
}
file_error osd_open(const char *path, UINT32 openflags, osd_file **file, UINT64 *filesize)
{
UINT32 access;
const char *src;
char *dst;
#if defined(SDLMAME_DARWIN) || defined(SDLMAME_WIN32) || defined(SDLMAME_NO64BITIO) || defined(SDLMAME_BSD) || defined(SDLMAME_OS2) || defined(SDLMAME_HAIKU)
struct stat st;
#else
struct stat64 st;
#endif
char *tmpstr, *envstr;
int i, j;
file_error filerr = FILERR_NONE;
tmpstr = NULL;
// allocate a file object, plus space for the converted filename
*file = (osd_file *) osd_malloc_array(sizeof(**file) + sizeof(char) * strlen(path));
if (*file == NULL)
{
filerr = FILERR_OUT_OF_MEMORY;
goto error;
}
if (sdl_check_socket_path(path))
{
(*file)->type = SDLFILE_SOCKET;
filerr = sdl_open_socket(path, openflags, file, filesize);
goto error;
}
if (strlen(sdlfile_ptty_identifier) > 0 && strncmp(path, sdlfile_ptty_identifier, strlen(sdlfile_ptty_identifier)) == 0)
{
(*file)->type = SDLFILE_PTTY;
filerr = sdl_open_ptty(path, openflags, file, filesize);
goto error;
}
(*file)->type = SDLFILE_FILE;
// convert the path into something compatible
dst = (*file)->filename;
for (src = path; *src != 0; src++)
*dst++ = (*src == INVPATHSEPCH) ? PATHSEPCH : *src;
*dst++ = 0;
// select the file open modes
if (openflags & OPEN_FLAG_WRITE)
{
access = (openflags & OPEN_FLAG_READ) ? O_RDWR : O_WRONLY;
access |= (openflags & OPEN_FLAG_CREATE) ? (O_CREAT | O_TRUNC) : 0;
}
else if (openflags & OPEN_FLAG_READ)
{
access = O_RDONLY;
}
else
{
filerr = FILERR_INVALID_ACCESS;
goto error;
}
tmpstr = (char *) osd_malloc_array(strlen((*file)->filename)+1);
strcpy(tmpstr, (*file)->filename);
// does path start with an environment variable?
if (tmpstr[0] == '$')
{
envstr = (char *) osd_malloc_array(strlen(tmpstr)+1);
strcpy(envstr, tmpstr);
i = 0;
while (envstr[i] != PATHSEPCH && envstr[i] != 0 && envstr[i] != '.')
{
i++;
}
envstr[i] = '\0';
const char *envval = osd_getenv(&envstr[1]);
if (envval != NULL)
{
j = strlen(envval) + strlen(tmpstr) + 1;
osd_free(tmpstr);
tmpstr = (char *) osd_malloc_array(j);
// start with the value of $HOME
strcpy(tmpstr, envval);
// replace the null with a path separator again
envstr[i] = PATHSEPCH;
// append it
strcat(tmpstr, &envstr[i]);
}
else
fprintf(stderr, "Warning: osd_open environment variable %s not found.\n", envstr);
osd_free(envstr);
}
#if defined(SDLMAME_WIN32) || defined(SDLMAME_OS2)
access |= O_BINARY;
#endif
// attempt to open the file
#if defined(SDLMAME_DARWIN) || defined(SDLMAME_WIN32) || defined(SDLMAME_NO64BITIO) || defined(SDLMAME_BSD) || defined(SDLMAME_OS2) || defined(SDLMAME_HAIKU)
(*file)->handle = open(tmpstr, access, 0666);
#else
(*file)->handle = open64(tmpstr, access, 0666);
#endif
if ((*file)->handle == -1)
{
// create the path if necessary
if ((openflags & OPEN_FLAG_CREATE) && (openflags & OPEN_FLAG_CREATE_PATHS))
{
char *pathsep = strrchr(tmpstr, PATHSEPCH);
if (pathsep != NULL)
{
int error;
// create the path up to the file
*pathsep = 0;
error = create_path_recursive(tmpstr);
*pathsep = PATHSEPCH;
// attempt to reopen the file
if (error == NO_ERROR)
{
#if defined(SDLMAME_DARWIN) || defined(SDLMAME_WIN32) || defined(SDLMAME_NO64BITIO) || defined(SDLMAME_BSD) || defined(SDLMAME_OS2) || defined(SDLMAME_HAIKU)
(*file)->handle = open(tmpstr, access, 0666);
#else
(*file)->handle = open64(tmpstr, access, 0666);
#endif
}
}
}
// if we still failed, clean up and osd_free
if ((*file)->handle == -1)
{
osd_free(*file);
*file = NULL;
osd_free(tmpstr);
return error_to_file_error(errno);
}
}
// get the file size
#if defined(SDLMAME_DARWIN) || defined(SDLMAME_WIN32) || defined(SDLMAME_NO64BITIO) || defined(SDLMAME_BSD) || defined(SDLMAME_OS2) || defined(SDLMAME_HAIKU)
fstat((*file)->handle, &st);
#else
fstat64((*file)->handle, &st);
#endif
*filesize = (UINT64)st.st_size;
error:
// cleanup
if (filerr != FILERR_NONE && *file != NULL)
{
osd_free(*file);
*file = NULL;
}
if (tmpstr)
osd_free(tmpstr);
return filerr;
}
char *osd_get_clipboard_text(void)
{
SDL_SysWMinfo info;
Display* display;
Window our_win;
Window selection_win;
Atom data_type;
int data_format;
unsigned long nitems;
unsigned long bytes_remaining;
unsigned char* prop;
char* result;
XEvent event;
Uint32 t0, t1;
Atom types[2];
int i;
/* get & validate SDL sys-wm info */
SDL_VERSION(&info.version);
if ( ! SDL_GetWMInfo( &info ) )
return NULL;
if ( info.subsystem != SDL_SYSWM_X11 )
return NULL;
if ( (display = info.info.x11.display) == NULL )
return NULL;
if ( (our_win = info.info.x11.window) == None )
return NULL;
/* request data to owner */
selection_win = XGetSelectionOwner( display, XA_PRIMARY );
if ( selection_win == None )
return NULL;
/* first, try UTF-8, then latin-1 */
types[0] = XInternAtom( display, "UTF8_STRING", False );
types[1] = XA_STRING; /* latin-1 */
for ( i = 0; i < ARRAY_LENGTH(types); i++ )
{
XConvertSelection( display, XA_PRIMARY, types[i], types[i], our_win, CurrentTime );
/* wait for SelectionNotify, but no more than 100 ms */
t0 = t1 = SDL_GetTicks();
while ( 1 )
{
if ( XCheckTypedWindowEvent( display, our_win, SelectionNotify, &event ) ) break;
SDL_Delay( 1 );
t1 = SDL_GetTicks();
if ( t1 - t0 > 100 )
return NULL;
}
if ( event.xselection.property == None )
continue;
/* get property & check its type */
if ( XGetWindowProperty( display, our_win, types[i], 0, 65536, False, types[i],
&data_type, &data_format, &nitems, &bytes_remaining, &prop )
!= Success )
continue;
if ( ! prop )
continue;
if ( (data_format != 8) || (data_type != types[i]) )
{
XFree( prop );
continue;
}
/* return a copy & free original */
if (prop != NULL)
{
result = (char *) osd_malloc_array(strlen((char *)prop)+1);
strcpy(result, (char *)prop);
}
else
result = NULL;
XFree( prop );
return result;
}
return NULL;
}
osd_work_queue *osd_work_queue_alloc(int flags)
{
int threadnum;
int numprocs = effective_num_processors();
osd_work_queue *queue;
int osdthreadnum = 0;
int allocthreadnum;
char *osdworkqueuemaxthreads = osd_getenv(ENV_WORKQUEUEMAXTHREADS);
// allocate a new queue
queue = (osd_work_queue *)osd_malloc(sizeof(*queue));
if (queue == NULL)
goto error;
memset(queue, 0, sizeof(*queue));
// initialize basic queue members
queue->tailptr = (osd_work_item **)&queue->list;
queue->flags = flags;
// allocate events for the queue
queue->doneevent = osd_event_alloc(TRUE, TRUE); // manual reset, signalled
if (queue->doneevent == NULL)
goto error;
// initialize the critical section
queue->lock = osd_scalable_lock_alloc();
if (queue->lock == NULL)
goto error;
// determine how many threads to create...
// on a single-CPU system, create 1 thread for I/O queues, and 0 threads for everything else
if (numprocs == 1)
threadnum = (flags & WORK_QUEUE_FLAG_IO) ? 1 : 0;
// on an n-CPU system, create n-1 threads for multi queues, and 1 thread for everything else
else
threadnum = (flags & WORK_QUEUE_FLAG_MULTI) ? (numprocs - 1) : 1;
if (osdworkqueuemaxthreads != NULL && sscanf(osdworkqueuemaxthreads, "%d", &osdthreadnum) == 1 && threadnum > osdthreadnum)
threadnum = osdthreadnum;
// clamp to the maximum
queue->threads = MIN(threadnum, WORK_MAX_THREADS);
// allocate memory for thread array (+1 to count the calling thread if WORK_QUEUE_FLAG_MULTI)
if (flags & WORK_QUEUE_FLAG_MULTI)
allocthreadnum = queue->threads + 1;
else
allocthreadnum = queue->threads;
#if KEEP_STATISTICS
printf("osdprocs: %d effecprocs: %d threads: %d allocthreads: %d osdthreads: %d maxthreads: %d queuethreads: %d\n", osd_num_processors, numprocs, threadnum, allocthreadnum, osdthreadnum, WORK_MAX_THREADS, queue->threads);
#endif
queue->thread = (work_thread_info *)osd_malloc_array(allocthreadnum * sizeof(queue->thread[0]));
if (queue->thread == NULL)
goto error;
memset(queue->thread, 0, allocthreadnum * sizeof(queue->thread[0]));
// iterate over threads
for (threadnum = 0; threadnum < queue->threads; threadnum++)
{
work_thread_info *thread = &queue->thread[threadnum];
// set a pointer back to the queue
thread->queue = queue;
// create the per-thread wake event
thread->wakeevent = osd_event_alloc(FALSE, FALSE); // auto-reset, not signalled
if (thread->wakeevent == NULL)
goto error;
// create the thread
thread->handle = osd_thread_create(worker_thread_entry, thread);
if (thread->handle == NULL)
goto error;
// set its priority: I/O threads get high priority because they are assumed to be
// blocked most of the time; other threads just match the creator's priority
if (flags & WORK_QUEUE_FLAG_IO)
osd_thread_adjust_priority(thread->handle, 1);
else
osd_thread_adjust_priority(thread->handle, 0);
}
// start a timer going for "waittime" on the main thread
if (flags & WORK_QUEUE_FLAG_MULTI)
{
begin_timing(queue->thread[queue->threads].waittime);
}
return queue;
error:
osd_work_queue_free(queue);
return NULL;
}
osd_work_queue *osd_work_queue_alloc(int flags)
{
int numprocs = effective_num_processors();
osd_work_queue *queue;
int threadnum;
// allocate a new queue
queue = (osd_work_queue *)osd_malloc(sizeof(*queue));
if (queue == NULL)
goto error;
memset(queue, 0, sizeof(*queue));
// initialize basic queue members
queue->tailptr = (osd_work_item **)&queue->list;
queue->flags = flags;
// allocate events for the queue
queue->doneevent = osd_event_alloc(TRUE, TRUE); // manual reset, signalled
if (queue->doneevent == NULL)
goto error;
// initialize the critical section
queue->lock = osd_scalable_lock_alloc();
if (queue->lock == NULL)
goto error;
// determine how many threads to create...
// on a single-CPU system, create 1 thread for I/O queues, and 0 threads for everything else
if (numprocs == 1)
queue->threads = (flags & WORK_QUEUE_FLAG_IO) ? 1 : 0;
// on an n-CPU system, create (n-1) threads for multi queues, and 1 thread for everything else
else
queue->threads = (flags & WORK_QUEUE_FLAG_MULTI) ? (numprocs - 1) : 1;
// clamp to the maximum
queue->threads = MIN(queue->threads, WORK_MAX_THREADS);
// allocate memory for thread array (+1 to count the calling thread)
queue->thread = (work_thread_info *)osd_malloc_array((queue->threads + 1) * sizeof(queue->thread[0]));
if (queue->thread == NULL)
goto error;
memset(queue->thread, 0, (queue->threads + 1) * sizeof(queue->thread[0]));
// iterate over threads
for (threadnum = 0; threadnum < queue->threads; threadnum++)
{
work_thread_info *thread = &queue->thread[threadnum];
// set a pointer back to the queue
thread->queue = queue;
// create the per-thread wake event
thread->wakeevent = osd_event_alloc(FALSE, FALSE); // auto-reset, not signalled
if (thread->wakeevent == NULL)
goto error;
// create the thread
thread->handle = osd_thread_create(worker_thread_entry, thread);
if (thread->handle == NULL)
goto error;
// set its priority: I/O threads get high priority because they are assumed to be
// blocked most of the time; other threads just match the creator's priority
if (flags & WORK_QUEUE_FLAG_IO)
osd_thread_adjust_priority(thread->handle, 1);
else
osd_thread_adjust_priority(thread->handle, 0);
// Bind main thread to cpu 0
osd_thread_cpu_affinity(NULL, effective_cpu_mask(0));
if (flags & WORK_QUEUE_FLAG_IO)
osd_thread_cpu_affinity(thread->handle, effective_cpu_mask(1));
else
osd_thread_cpu_affinity(thread->handle, effective_cpu_mask(2+threadnum) );
}
// start a timer going for "waittime" on the main thread
begin_timing(queue->thread[queue->threads].waittime);
return queue;
error:
osd_work_queue_free(queue);
return NULL;
}
file_error osd_open(const char *path, UINT32 openflags, osd_file **file, UINT64 *filesize)
{
file_error filerr = FILERR_NONE;
// convert path to TCHAR
TCHAR *t_path = tstring_from_utf8(path);
if (t_path == NULL)
{
filerr = FILERR_OUT_OF_MEMORY;
goto error;
}
// allocate a file object, plus space for the converted filename
*file = (osd_file *)osd_malloc_array(sizeof(**file) + sizeof(TCHAR) * _tcslen(t_path));
if (*file == NULL)
{
filerr = FILERR_OUT_OF_MEMORY;
goto error;
}
memset(*file, 0x00, sizeof(**file) + sizeof(TCHAR) * _tcslen(t_path));
if (win_check_socket_path(path))
{
(*file)->type = WINFILE_SOCKET;
filerr = win_open_socket(path, openflags, file, filesize);
goto error;
}
if (strncmp(path, winfile_ptty_identifier, strlen(winfile_ptty_identifier)) == 0)
{
(*file)->type = WINFILE_PTTY;
filerr = win_open_ptty(path, openflags, file, filesize);
goto error;
}
(*file)->type = WINFILE_FILE;
// convert the path into something Windows compatible
{
TCHAR *dst = (*file)->filename;
for (TCHAR const *src = t_path; *src != 0; src++)
*dst++ = *src;//(*src == '/') ? '\\' : *src;
*dst++ = 0;
}
// select the file open modes
DWORD disposition, access, sharemode;
if (openflags & OPEN_FLAG_WRITE)
{
disposition = (!is_path_to_physical_drive(path) && (openflags & OPEN_FLAG_CREATE)) ? CREATE_ALWAYS : OPEN_EXISTING;
access = (openflags & OPEN_FLAG_READ) ? (GENERIC_READ | GENERIC_WRITE) : GENERIC_WRITE;
sharemode = FILE_SHARE_READ;
}
else if (openflags & OPEN_FLAG_READ)
{
disposition = OPEN_EXISTING;
access = GENERIC_READ;
sharemode = FILE_SHARE_READ;
}
else
{
filerr = FILERR_INVALID_ACCESS;
goto error;
}
// attempt to open the file
(*file)->handle = CreateFile((*file)->filename, access, sharemode, NULL, disposition, 0, NULL);
if ((*file)->handle == INVALID_HANDLE_VALUE)
{
DWORD error = GetLastError();
// create the path if necessary
if (error == ERROR_PATH_NOT_FOUND && (openflags & OPEN_FLAG_CREATE) && (openflags & OPEN_FLAG_CREATE_PATHS))
{
TCHAR *pathsep = _tcsrchr((*file)->filename, '\\');
if (pathsep != NULL)
{
// create the path up to the file
*pathsep = 0;
error = create_path_recursive((*file)->filename);
*pathsep = '\\';
// attempt to reopen the file
if (error == NO_ERROR)
(*file)->handle = CreateFile((*file)->filename, access, sharemode, NULL, disposition, 0, NULL);
}
}
// if we still failed, clean up and free
if ((*file)->handle == INVALID_HANDLE_VALUE)
{
filerr = win_error_to_file_error(error);
goto error;
}
}
// get the file size
DWORD upper;
*filesize = GetFileSize((*file)->handle, &upper);
*filesize |= (UINT64)upper << 32;
error:
// cleanup
if (filerr != FILERR_NONE && *file != NULL)
{
osd_free(*file);
*file = NULL;
}
osd_free(t_path);
return filerr;
}