/* -*- mode:c; c-file-style:"k&r"; c-basic-offset: 4; tab-width:4; indent-tabs-mode:nil; mode:auto-fill; fill-column:78; -*- */ /* vim: set ts=4 sw=4 et tw=78 fo=cqt wm=0: */ /* Copyright (C) 2014 Stony Brook University This file is part of Graphene Library OS. Graphene Library OS is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Graphene Library OS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program. If not, see . */ /* * shim_utils.h */ #ifndef _SHIM_UTILS_H_ #define _SHIM_UTILS_H_ #include #include #include #include struct shim_handle; void sysparser_printf (const char * fmt, ...); /* string object */ struct shim_str * get_str_obj (void); int free_str_obj (struct shim_str * str); int init_str_mgr (void); /* qstring object */ #define QSTR_INIT { .len = 0, .oflow = NULL } static inline const char * qstrgetstr (const struct shim_qstr * qstr) { return qstr->oflow ? qstr->oflow->str : qstr->name; } static inline void qstrfree (struct shim_qstr * qstr) { if (qstr->oflow) { free_str_obj(qstr->oflow); qstr->oflow = NULL; } qstr->name[0] = 0; qstr->len = 0; } static inline char * qstrsetstr (struct shim_qstr * qstr, const char * str, size_t size) { if (!str) { qstrfree(qstr); return NULL; } if (size >= STR_SIZE) return NULL; char * buf = qstr->name; if (size >= QSTR_SIZE) { if (!qstr->oflow) { qstr->oflow = get_str_obj(); if (!qstr->oflow) return NULL; } buf = qstr->oflow->str; } else { if (qstr->oflow) { free_str_obj(qstr->oflow); qstr->oflow = NULL; } } memcpy(buf, str, size); buf[size] = 0; qstr->len = size; return buf; } static inline char * qstrsetstrs (struct shim_qstr * qstr, int nstrs, const char ** strs, size_t * sizes) { size_t total_size = 0; for (int i = 0 ; i < nstrs ; i++) total_size += sizes[i]; if (total_size >= STR_SIZE) return NULL; char * buf = qstr->name; if (total_size >= QSTR_SIZE) { if (!qstr->oflow) { // TODO: alloc proper size. qstr->oflow = get_str_obj(); if (!qstr->oflow) return NULL; } buf = qstr->oflow->str; } char * ptr = buf; qstr->len = 0; for (int i = 0 ; i < nstrs ; i++) { int size = sizes[i]; memcpy(ptr, strs[i], size); ptr[size] = 0; qstr->len += size; ptr += size; } return buf; } static inline int qstrempty (const struct shim_qstr * qstr) { return qstr->len == 0; } static inline void qstrcopy (struct shim_qstr * to, const struct shim_qstr * from) { qstrsetstr(to, qstrgetstr(from), from->len); to->hash = from->hash; } static inline int qstrcmpstr (const struct shim_qstr * qstr, const char * str, size_t size) { if (qstr->len != size) return 1; return memcmp(qstrgetstr(qstr), str, size); } //#define SLAB_DEBUG_PRINT //#define SLAB_DEBUG_TRACE /* heap allocation functions */ int init_slab (void); #if defined(SLAB_DEBUG_PRINT) || defined(SLAB_DEBUG_TRACE) void * __malloc_debug (size_t size, const char * file, int line); #define malloc(size) __malloc_debug((size), __FILE__, __LINE__) void __free_debug (void * mem, const char * file, int line); #define free(mem) __free_debug((mem), __FILE__, __LINE__) void * __malloc_copy_debug (const void * mem, size_t size, const char * file, int line); #define malloc_copy(mem, size) __malloc_copy_debug((mem), (size), __FILE__, __LINE__) #else void * malloc (size_t size); void free (void * mem); void * malloc_copy (const void * mem, size_t size); #endif static_always_inline char * qstrtostr (struct shim_qstr * qstr, bool on_stack) { int len = qstr->len; char * buf = on_stack ? __alloca(len + 1) : malloc(len + 1); if (!buf) return NULL; memcpy(buf, qstrgetstr(qstr), len); buf[len] = 0; return buf; } /* typedef a 32 bit type */ # ifndef UINT4 # define UINT4 uint32_t # endif /* Data structure for MD5 (Message Digest) computation */ struct shim_md5_ctx { UINT4 i[2]; /* number of _bits_ handled mod 2^64 */ UINT4 buf[4]; /* scratch buffer */ unsigned char in[64]; /* input buffer */ unsigned char digest[16]; /* actual digest after MD5Final call */ }; void md5_init (struct shim_md5_ctx * mdContext); void md5_update (struct shim_md5_ctx * mdContext, const void * buf, size_t len); void md5_final (struct shim_md5_ctx * mdContext); /* prompt user for confirmation */ int message_confirm (const char * message, const char * options); /* ELF binary loading */ int check_elf_object (struct shim_handle * file); int load_elf_object (struct shim_handle * file, void * addr, size_t mapped); int load_elf_interp (struct shim_handle * exec); int free_elf_interp (void); int execute_elf_object (struct shim_handle * exec, int * argcp, const char ** argp, int nauxv, elf_auxv_t * auxp); int remove_loaded_libraries (void); /* gdb debugging support */ void remove_r_debug (void * addr); void append_r_debug (const char * uri, void * addr, void * dyn_addr); void clean_link_map_list (void); /* create unique files/pipes */ #define PIPE_URI_SIZE 40 int create_pipe (IDTYPE * pipeid, char * uri, size_t size, PAL_HANDLE * hdl, struct shim_qstr * qstr); int create_dir (const char * prefix, char * path, size_t size, struct shim_handle ** hdl); int create_file (const char * prefix, char * path, size_t size, struct shim_handle ** hdl); int create_handle (const char * prefix, char * path, size_t size, PAL_HANDLE * hdl, unsigned int * id); /* Asynchronous event support */ int init_async (void); int64_t install_async_event (PAL_HANDLE object, unsigned long time, void (*callback) (IDTYPE caller, void * arg), void * arg); int create_async_helper (void); struct shim_thread * terminate_async_helper (void); extern struct config_store * root_config; #endif /* _SHIM_UTILS_H */