Index: uspace/Makefile =================================================================== --- uspace/Makefile (revision c878693123930f0906703462cf2807430679517e) +++ uspace/Makefile (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -38,5 +38,4 @@ app/bithenge \ app/blkdump \ - app/bnchmark \ app/contacts \ app/corecfg \ @@ -51,4 +50,5 @@ app/getterm \ app/gunzip \ + app/hbench \ app/init \ app/inet \ @@ -58,4 +58,5 @@ app/loc \ app/logset \ + app/lprint \ app/mixerctl \ app/mkfat \ @@ -66,5 +67,5 @@ app/netecho \ app/nterm \ - app/perf \ + app/pci \ app/redir \ app/sbi \ @@ -151,4 +152,5 @@ drv/block/ddisk \ drv/block/usbmast \ + drv/block/virtio-blk \ drv/bus/adb/cuda_adb \ drv/bus/isa \ @@ -166,4 +168,6 @@ drv/char/msim-con \ drv/char/ns8250 \ + drv/char/pc-lpt \ + drv/char/pl011 \ drv/char/pl050 \ drv/char/ski-con \ @@ -178,4 +182,5 @@ drv/hid/xtkbd \ drv/intctl/apic \ + drv/intctl/gicv2 \ drv/intctl/i8259 \ drv/intctl/icp-ic \ @@ -188,4 +193,5 @@ drv/nic/virtio-net \ drv/platform/amdm37x \ + drv/platform/arm64virt \ drv/platform/icp \ drv/platform/mac \ @@ -274,4 +280,5 @@ export: $(BUILDS) + mkdir -p $(EXPORT_DIR) $(MAKE) -r -C lib/posix export EXPORT_DIR=$(EXPORT_DIR) Index: uspace/Makefile.common =================================================================== --- uspace/Makefile.common (revision c878693123930f0906703462cf2807430679517e) +++ uspace/Makefile.common (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -120,6 +120,14 @@ STATIC_BUILD = y else - ifeq ($(CONFIG_USE_SHARED_LIBS),y) - STATIC_BUILD = n + ifeq ($(CONFIG_BUILD_SHARED_LIBS),y) + ifeq ($(CONFIG_USE_SHARED_LIBS),y) + STATIC_BUILD = n + else + ifeq ($(LIBRARY),) + STATIC_BUILD = y + else + STATIC_BUILD = n + endif + endif else STATIC_BUILD = y @@ -300,4 +308,8 @@ LIBARGS := $(addprefix -L$(USPACE_PREFIX)/lib/, $(LIBS)) $(addprefix -l, $(LIBS)) +ifneq ($(LIBRARY),libc) + LIBTAGS := $(LIBC_PREFIX)/tag $(LIBTAGS) +endif + .PHONY: all all-test clean fasterclean depend @@ -369,5 +381,5 @@ $(AR) rc $@ $(LOBJECTS) -$(SLIBRARY): $(LIBRARY).la +$(SLIBRARY): $(LIBRARY).la $(LIBTAGS) $(CC) $(CFLAGS) $(LIB_LDFLAGS) $(EXTRA_LDFLAGS) -Wl,-Map,$@.map -o $@ -Wl,--whole-archive $(LIBRARY).la -Wl,--no-whole-archive $(LIBARGS) $(BASE_LIBS) Index: uspace/app/bdsh/Makefile =================================================================== --- uspace/app/bdsh/Makefile (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/bdsh/Makefile (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -34,4 +34,6 @@ SOURCES = \ + cmds/modules/module_aliases.c \ + cmds/modules/modules.c \ cmds/modules/help/help.c \ cmds/modules/mkdir/mkdir.c \ @@ -51,4 +53,6 @@ cmds/modules/kcon/kcon.c \ cmds/modules/cmp/cmp.c \ + cmds/builtins/builtin_aliases.c \ + cmds/builtins/builtins.c \ cmds/builtins/batch/batch.c \ cmds/builtins/exit/exit.c \ Index: uspace/app/bdsh/cmds/builtins/builtin_aliases.c =================================================================== --- uspace/app/bdsh/cmds/builtins/builtin_aliases.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/bdsh/cmds/builtins/builtin_aliases.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2008 Tim Post + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef BUILTIN_ALIASES_H +#define BUILTIN_ALIASES_H + +#include +#include "builtin_aliases.h" + +/* See modules/module_aliases.h for an explanation of this file */ + +char *builtin_aliases[] = { + NULL, NULL +}; + +#endif Index: uspace/app/bdsh/cmds/builtins/builtin_aliases.h =================================================================== --- uspace/app/bdsh/cmds/builtins/builtin_aliases.h (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/bdsh/cmds/builtins/builtin_aliases.h (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -1,10 +1,34 @@ +/* + * Copyright (c) 2008 Tim Post + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + #ifndef BUILTIN_ALIASES_H #define BUILTIN_ALIASES_H -/* See modules/module_aliases.h for an explanation of this file */ - -char *builtin_aliases[] = { - NULL, NULL -}; +extern char *builtin_aliases[]; #endif Index: uspace/app/bdsh/cmds/builtins/builtins.c =================================================================== --- uspace/app/bdsh/cmds/builtins/builtins.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/bdsh/cmds/builtins/builtins.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2008 Tim Post + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include "builtins.h" + +#include "batch/entry.h" +#include "cd/entry.h" +#include "exit/entry.h" + +builtin_t builtins[] = { +#include "batch/batch_def.inc" +#include "cd/cd_def.inc" +#include "exit/exit_def.inc" + { NULL, NULL, NULL, NULL, 0 } +}; Index: uspace/app/bdsh/cmds/builtins/builtins.h =================================================================== --- uspace/app/bdsh/cmds/builtins/builtins.h (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/bdsh/cmds/builtins/builtins.h (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -1,17 +1,36 @@ +/* + * Copyright (c) 2008 Tim Post + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + #ifndef BUILTINS_H #define BUILTINS_H -#include "config.h" +#include "../cmds.h" -#include "batch/entry.h" -#include "cd/entry.h" -#include "exit/entry.h" - -builtin_t builtins[] = { -#include "batch/batch_def.inc" -#include "cd/cd_def.inc" -#include "exit/exit_def.inc" - { NULL, NULL, NULL, NULL, 0 } -}; +extern builtin_t builtins[]; #endif Index: uspace/app/bdsh/cmds/mknewcmd =================================================================== --- uspace/app/bdsh/cmds/mknewcmd (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/bdsh/cmds/mknewcmd (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -213,5 +213,5 @@ printf " to include your new command.\n" [ -n "$CMDALIAS" ] && { - printf "\nYou should also modify %ss/%s_aliases.h and " \ + printf "\nYou should also modify %ss/%s_aliases.c and " \ "${CMDTYPE}" "${CMDTYPE}" printf "add %s as an alias for %s\n" \ Index: uspace/app/bdsh/cmds/modules/ls/ls.c =================================================================== --- uspace/app/bdsh/cmds/modules/ls/ls.c (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/bdsh/cmds/modules/ls/ls.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -267,5 +267,5 @@ /* Populate the directory list. */ - if (ls.recursive) { + if (ls.recursive && nbdirs > 0) { tmp = (struct dir_elem_t *) realloc(*dir_list_ptr, nbdirs * sizeof(struct dir_elem_t)); Index: uspace/app/bdsh/cmds/modules/module_aliases.c =================================================================== --- uspace/app/bdsh/cmds/modules/module_aliases.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/bdsh/cmds/modules/module_aliases.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2008 Tim Post + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include "module_aliases.h" + +/* + * Modules that declare multiple names for themselves but use the + * same entry functions are aliases. This array helps to determine if + * a module is an alias, as such it can be invoked differently. + * format is alias , real_name + */ + +/* + * So far, this is only used in the help display but could be used to + * handle a module differently even prior to reaching its entry code. + * For instance, 'exit' could behave differently than 'quit', prior to + * the entry point being reached. + */ + +const char *mod_aliases[] = { + "ren", "mv", + "umount", "unmount", + NULL, NULL +}; Index: uspace/app/bdsh/cmds/modules/module_aliases.h =================================================================== --- uspace/app/bdsh/cmds/modules/module_aliases.h (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/bdsh/cmds/modules/module_aliases.h (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -30,23 +30,5 @@ #define MODULE_ALIASES_H -/* - * Modules that declare multiple names for themselves but use the - * same entry functions are aliases. This array helps to determine if - * a module is an alias, as such it can be invoked differently. - * format is alias , real_name - */ - -/* - * So far, this is only used in the help display but could be used to - * handle a module differently even prior to reaching its entry code. - * For instance, 'exit' could behave differently than 'quit', prior to - * the entry point being reached. - */ - -const char *mod_aliases[] = { - "ren", "mv", - "umount", "unmount", - NULL, NULL -}; +extern const char *mod_aliases[]; #endif Index: uspace/app/bdsh/cmds/modules/modules.c =================================================================== --- uspace/app/bdsh/cmds/modules/modules.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/bdsh/cmds/modules/modules.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2008 Tim Post + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Each built in function has two files, one being an entry.h file which + * prototypes the run/help entry functions, the other being a .def file + * which fills the modules[] array according to the cmd_t structure + * defined in cmds.h. + * + * To add or remove a module, just make a new directory in cmds/modules + * for it and copy the 'show' example for basics, then include it here. + * (or reverse the process to remove one) + * + * NOTE: See module_ aliases.h as well, this is where aliases (commands that + * share an entry point with others) are indexed + */ + +#include "config.h" +#include "modules.h" + +/* Prototypes for each module's entry (help/exec) points */ + +#include "help/entry.h" +#include "mkdir/entry.h" +#include "mkfile/entry.h" +#include "rm/entry.h" +#include "cat/entry.h" +#include "touch/entry.h" +#include "ls/entry.h" +#include "pwd/entry.h" +#include "sleep/entry.h" +#include "cp/entry.h" +#include "mv/entry.h" +#include "mount/entry.h" +#include "unmount/entry.h" +#include "kcon/entry.h" +#include "printf/entry.h" +#include "echo/entry.h" +#include "cmp/entry.h" + +/* + * Each .def function fills the module_t struct with the individual name, entry + * point, help entry point, etc. You can use config.h to control what modules + * are loaded based on what libraries exist on the system. + */ + +module_t modules[] = { +#include "help/help_def.inc" +#include "mkdir/mkdir_def.inc" +#include "mkfile/mkfile_def.inc" +#include "rm/rm_def.inc" +#include "cat/cat_def.inc" +#include "touch/touch_def.inc" +#include "ls/ls_def.inc" +#include "pwd/pwd_def.inc" +#include "sleep/sleep_def.inc" +#include "cp/cp_def.inc" +#include "mv/mv_def.inc" +#include "mount/mount_def.inc" +#include "unmount/unmount_def.inc" +#include "kcon/kcon_def.inc" +#include "printf/printf_def.inc" +#include "echo/echo_def.inc" +#include "cmp/cmp_def.inc" + + { NULL, NULL, NULL, NULL } +}; Index: uspace/app/bdsh/cmds/modules/modules.h =================================================================== --- uspace/app/bdsh/cmds/modules/modules.h (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/bdsh/cmds/modules/modules.h (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -30,67 +30,8 @@ #define MODULES_H -/* - * Each built in function has two files, one being an entry.h file which - * prototypes the run/help entry functions, the other being a .def file - * which fills the modules[] array according to the cmd_t structure - * defined in cmds.h. - * - * To add or remove a module, just make a new directory in cmds/modules - * for it and copy the 'show' example for basics, then include it here. - * (or reverse the process to remove one) - * - * NOTE: See module_ aliases.h as well, this is where aliases (commands that - * share an entry point with others) are indexed - */ +#include "../cmds.h" +#include "modules.h" -#include "config.h" - -/* Prototypes for each module's entry (help/exec) points */ - -#include "help/entry.h" -#include "mkdir/entry.h" -#include "mkfile/entry.h" -#include "rm/entry.h" -#include "cat/entry.h" -#include "touch/entry.h" -#include "ls/entry.h" -#include "pwd/entry.h" -#include "sleep/entry.h" -#include "cp/entry.h" -#include "mv/entry.h" -#include "mount/entry.h" -#include "unmount/entry.h" -#include "kcon/entry.h" -#include "printf/entry.h" -#include "echo/entry.h" -#include "cmp/entry.h" - -/* - * Each .def function fills the module_t struct with the individual name, entry - * point, help entry point, etc. You can use config.h to control what modules - * are loaded based on what libraries exist on the system. - */ - -module_t modules[] = { -#include "help/help_def.inc" -#include "mkdir/mkdir_def.inc" -#include "mkfile/mkfile_def.inc" -#include "rm/rm_def.inc" -#include "cat/cat_def.inc" -#include "touch/touch_def.inc" -#include "ls/ls_def.inc" -#include "pwd/pwd_def.inc" -#include "sleep/sleep_def.inc" -#include "cp/cp_def.inc" -#include "mv/mv_def.inc" -#include "mount/mount_def.inc" -#include "unmount/unmount_def.inc" -#include "kcon/kcon_def.inc" -#include "printf/printf_def.inc" -#include "echo/echo_def.inc" -#include "cmp/cmp_def.inc" - - { NULL, NULL, NULL, NULL } -}; +extern module_t modules[]; #endif Index: uspace/app/bdsh/cmds/modules/sleep/sleep.c =================================================================== --- uspace/app/bdsh/cmds/modules/sleep/sleep.c (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/bdsh/cmds/modules/sleep/sleep.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -27,6 +27,6 @@ */ -#include #include +#include #include #include Index: uspace/app/bdsh/compl.c =================================================================== --- uspace/app/bdsh/compl.c (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/bdsh/compl.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -40,4 +40,5 @@ #include "exec.h" #include "tok.h" +#include "util.h" static errno_t compl_init(wchar_t *text, size_t pos, size_t *cstart, void **state); @@ -209,6 +210,4 @@ } *cstart += rpath_sep + 1 - prefix; - free(prefix); - prefix = NULL; cs->path_list = malloc(sizeof(char *) * 2); @@ -217,5 +216,22 @@ goto error; } - cs->path_list[0] = dirname; + + if (!is_path(prefix) && cs->is_command) { + cs->path_list[0] = malloc(sizeof(char) * PATH_MAX); + if (cs->path_list[0] == NULL) { + retval = ENOMEM; + goto error; + } + + int ret = snprintf(cs->path_list[0], PATH_MAX, "%s/%s", search_dir[0], dirname); + if (ret < 0 || ret >= PATH_MAX) { + retval = ENOMEM; + goto error; + } + } else { + cs->path_list[0] = dirname; + } + + free(prefix); cs->path_list[1] = NULL; /* Index: uspace/app/bdsh/exec.c =================================================================== --- uspace/app/bdsh/exec.c (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/bdsh/exec.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -47,8 +47,5 @@ #include "errors.h" -/* FIXME: Just have find_command() return an allocated string */ -static char *found; - -static char *find_command(char *); +static errno_t find_command(char *, char **); static int try_access(const char *); @@ -68,30 +65,48 @@ } -/** Returns the full path of "cmd" if cmd is found +/** Returns EOK if no internal failure or else ENOMEM * - * else just hand back cmd as it was presented + * When the parameter `cmd` can be found then the absolute path will be set in `found`. + * Or else `found` will be NULL. + * `found` will be newly allocated and must be freed by the caller */ -static char *find_command(char *cmd) +static errno_t find_command(char *cmd, char **found) { - size_t i; + /* The user has specified a full or relative path, just give it back. */ + if (is_path(cmd)) { + if (-1 != try_access(cmd)) { + *found = str_dup(cmd); + return EOK; + } - found = (char *)malloc(PATH_MAX); + *found = NULL; + return EOK; + } - /* The user has specified a full or relative path, just give it back. */ - if (-1 != try_access(cmd)) { - return (char *) cmd; + *found = (char *)malloc(PATH_MAX); + if (*found == NULL) { + return ENOMEM; } /* We now have n places to look for the command */ + size_t i; + size_t cmd_length = str_length(cmd); for (i = 0; search_dir[i] != NULL; i++) { - memset(found, 0, PATH_MAX); - snprintf(found, PATH_MAX, "%s/%s", search_dir[i], cmd); - if (-1 != try_access(found)) { - return (char *) found; + if (str_length(search_dir[i]) + cmd_length + 2 > PATH_MAX) { + free(*found); + return ENOMEM; + } + + memset(*found, 0, PATH_MAX); + snprintf(*found, PATH_MAX, "%s/%s", search_dir[i], cmd); + if (-1 != try_access(*found)) { + return EOK; } } + free(*found); + *found = NULL; - /* We didn't find it, just give it back as-is. */ - return (char *) cmd; + /* We didn't find it, return NULL */ + return EOK; } @@ -107,6 +122,14 @@ FILE *files[3]; - tmp = str_dup(find_command(cmd)); - free(found); + rc = find_command(cmd, &tmp); + if (rc != EOK) { + cli_error(CL_ENOMEM, "%s: failure executing find_command()", progname); + return 1; + } + + if (tmp == NULL) { + cli_error(CL_EEXEC, "%s: Command not found '%s'", progname, cmd); + return 1; + } files[0] = io->stdin; Index: uspace/app/bdsh/util.c =================================================================== --- uspace/app/bdsh/util.c (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/bdsh/util.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -74,2 +74,15 @@ return 0; } + +/* + * Returns true if the string is a relative or an absolute path + */ +bool is_path(const char *cmd) +{ + + bool ret = str_lcmp(cmd, "/", 1) == 0; + ret = ret || str_lcmp(cmd, "./", 2) == 0; + ret = ret || str_lcmp(cmd, "../", 3) == 0; + + return ret; +} Index: uspace/app/bdsh/util.h =================================================================== --- uspace/app/bdsh/util.h (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/bdsh/util.h (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -31,8 +31,10 @@ #include "scli.h" +#include /* Utility functions */ extern unsigned int cli_count_args(char **); extern unsigned int cli_set_prompt(cliuser_t *usr); +extern bool is_path(const char *cmd); #endif Index: uspace/app/bnchmark/Makefile =================================================================== --- uspace/app/bnchmark/Makefile (revision c878693123930f0906703462cf2807430679517e) +++ (revision ) @@ -1,35 +1,0 @@ -# -# Copyright (c) 2011 Martin Sucha -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions -# are met: -# -# - Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# - Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# - The name of the author may not be used to endorse or promote products -# derived from this software without specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR -# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES -# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. -# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, -# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT -# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF -# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# - -USPACE_PREFIX = ../.. -BINARY = bnchmark - -SOURCES = \ - bnchmark.c - -include $(USPACE_PREFIX)/Makefile.common Index: uspace/app/bnchmark/bnchmark.c =================================================================== --- uspace/app/bnchmark/bnchmark.c (revision c878693123930f0906703462cf2807430679517e) +++ (revision ) @@ -1,213 +1,0 @@ -/* - * Copyright (c) 2011 Martin Sucha - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup bnchmark - * @{ - */ - -/** - * @file bnchmark.c - * This program measures time for various actions and writes the results - * to a file. - * - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define NAME "bnchmark" -#define BUFSIZE 8096 -#define MBYTE (1024*1024) - -typedef errno_t (*measure_func_t)(void *); - -static void syntax_print(void); - -static errno_t measure(measure_func_t fn, void *data, msec_t *result) -{ - struct timespec start_time; - getuptime(&start_time); - - errno_t rc = fn(data); - if (rc != EOK) { - fprintf(stderr, "measured function failed\n"); - return rc; - } - - struct timespec final_time; - getuptime(&final_time); - - /* Calculate time difference in milliseconds */ - *result = NSEC2USEC(ts_sub_diff(&final_time, &start_time)); - return EOK; -} - -static errno_t sequential_read_file(void *data) -{ - char *path = (char *) data; - char *buf = malloc(BUFSIZE); - - if (buf == NULL) - return ENOMEM; - - FILE *file = fopen(path, "r"); - if (file == NULL) { - fprintf(stderr, "Failed opening file: %s\n", path); - free(buf); - return EIO; - } - - while (!feof(file)) { - fread(buf, 1, BUFSIZE, file); - if (ferror(file)) { - fprintf(stderr, "Failed reading file\n"); - fclose(file); - free(buf); - return EIO; - } - } - - fclose(file); - free(buf); - return EOK; -} - -static errno_t sequential_read_dir(void *data) -{ - char *path = (char *) data; - - DIR *dir = opendir(path); - if (dir == NULL) { - fprintf(stderr, "Failed opening directory: %s\n", path); - return EIO; - } - - struct dirent *dp; - - while ((dp = readdir(dir))) { - /* Do nothing */ - } - - closedir(dir); - return EOK; -} - -int main(int argc, char **argv) -{ - errno_t rc; - msec_t milliseconds_taken = 0; - char *path = NULL; - measure_func_t fn = NULL; - int iteration; - int iterations; - char *log_str = NULL; - char *test_type = NULL; - char *endptr; - - if (argc < 5) { - fprintf(stderr, NAME ": Error, argument missing.\n"); - syntax_print(); - return 1; - } - - if (argc > 5) { - fprintf(stderr, NAME ": Error, too many arguments.\n"); - syntax_print(); - return 1; - } - - // Skip program name - --argc; - ++argv; - - iterations = strtol(*argv, &endptr, 10); - if (*endptr != '\0') { - printf(NAME ": Error, invalid argument (iterations).\n"); - syntax_print(); - return 1; - } - - --argc; - ++argv; - test_type = *argv; - - --argc; - ++argv; - log_str = *argv; - - --argc; - ++argv; - path = *argv; - - if (str_cmp(test_type, "sequential-file-read") == 0) { - fn = sequential_read_file; - } else if (str_cmp(test_type, "sequential-dir-read") == 0) { - fn = sequential_read_dir; - } else { - fprintf(stderr, "Error, unknown test type\n"); - syntax_print(); - return 1; - } - - for (iteration = 0; iteration < iterations; iteration++) { - rc = measure(fn, path, &milliseconds_taken); - if (rc != EOK) { - fprintf(stderr, "Error: %s\n", str_error(rc)); - return 1; - } - - printf("%s;%s;%s;%lld;ms\n", test_type, path, log_str, milliseconds_taken); - } - - return 0; -} - -static void syntax_print(void) -{ - fprintf(stderr, "syntax: " NAME " \n"); - fprintf(stderr, " number of times to run a given test\n"); - fprintf(stderr, " one of:\n"); - fprintf(stderr, " sequential-file-read\n"); - fprintf(stderr, " sequential-dir-read\n"); - fprintf(stderr, " a string to attach to results\n"); - fprintf(stderr, " file/directory to use for testing\n"); -} - -/** - * @} - */ Index: uspace/app/bnchmark/doc/doxygroups.h =================================================================== --- uspace/app/bnchmark/doc/doxygroups.h (revision c878693123930f0906703462cf2807430679517e) +++ (revision ) @@ -1,4 +1,0 @@ -/** @addtogroup bnchmark bnchmark - * @brief Benchmarking application - * @ingroup apps - */ Index: uspace/app/contacts/contacts.c =================================================================== --- uspace/app/contacts/contacts.c (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/contacts/contacts.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -526,5 +526,5 @@ { errno_t rc; - contacts_t *contacts; + contacts_t *contacts = NULL; rc = contacts_open("contacts.sif", &contacts); Index: uspace/app/df/df.c =================================================================== --- uspace/app/df/df.c (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/df/df.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -70,5 +70,5 @@ /* Parse command-line options */ - while ((optres = getopt(argc, argv, ":ubh")) != -1) { + while ((optres = getopt(argc, argv, "ubh")) != -1) { switch (optres) { case 'h': @@ -78,10 +78,4 @@ case 'b': display_blocks = true; - break; - - case ':': - fprintf(stderr, "Option -%c requires an operand\n", - optopt); - errflg++; break; Index: uspace/app/dltest/dltest.c =================================================================== --- uspace/app/dltest/dltest.c (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/dltest/dltest.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -91,4 +91,30 @@ } +/** Test calling function that calls a function that returns a constant */ +static bool test_dlfcn_dl_get_constant_via_call(void) +{ + int (*p_dl_get_constant)(void); + int val; + + printf("Call dlsym/dl_get_constant_via_call...\n"); + + p_dl_get_constant = dlsym(handle, "dl_get_constant_via_call"); + if (p_dl_get_constant == NULL) { + printf("FAILED\n"); + return false; + } + + val = p_dl_get_constant(); + + printf("Got %d, expected %d... ", val, dl_constant); + if (val != dl_constant) { + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + /** Test calling a function that returns contents of a private initialized * variable. @@ -564,4 +590,23 @@ } +/** Test directly calling function that calls a function that returns a constant */ +static bool test_lnk_dl_get_constant_via_call(void) +{ + int val; + + printf("Call linked dl_get_constant_via_call...\n"); + + val = dl_get_constant_via_call(); + + printf("Got %d, expected %d... ", val, dl_constant); + if (val != dl_constant) { + printf("FAILED\n"); + return false; + } + + printf("Passed\n"); + return true; +} + /** Test dircetly calling a function that returns contents of a private * initialized variable. @@ -853,4 +898,7 @@ return 1; + if (!test_dlfcn_dl_get_constant_via_call()) + return 1; + if (!test_dlfcn_dl_get_private_var()) return 1; @@ -905,4 +953,7 @@ { if (!test_lnk_dl_get_constant()) + return 1; + + if (!test_lnk_dl_get_constant_via_call()) return 1; Index: uspace/app/hbench/Makefile =================================================================== --- uspace/app/hbench/Makefile (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/hbench/Makefile (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,49 @@ +# +# Copyright (c) 2018 Jiri Svoboda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. + +LIBS = math + +BINARY = hbench + +SOURCES = \ + benchlist.c \ + csv.c \ + env.c \ + main.c \ + utils.c \ + fs/dirread.c \ + fs/fileread.c \ + ipc/ns_ping.c \ + ipc/ping_pong.c \ + malloc/malloc1.c \ + malloc/malloc2.c \ + synch/fibril_mutex.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/app/hbench/benchlist.c =================================================================== --- uspace/app/hbench/benchlist.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/hbench/benchlist.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2018 Jiri Svoboda + * Copyright (c) 2018 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup hbench + * @{ + */ +/** + * @file + */ + +#include +#include "hbench.h" + +benchmark_t *benchmarks[] = { + &benchmark_dir_read, + &benchmark_fibril_mutex, + &benchmark_file_read, + &benchmark_malloc1, + &benchmark_malloc2, + &benchmark_ns_ping, + &benchmark_ping_pong +}; + +size_t benchmark_count = sizeof(benchmarks) / sizeof(benchmarks[0]); + +/** @} + */ Index: uspace/app/hbench/csv.c =================================================================== --- uspace/app/hbench/csv.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/hbench/csv.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2019 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup hbench + * @{ + */ +/** + * @file + */ + +#include +#include +#include "hbench.h" + +static FILE *csv_output = NULL; + +/** Open CSV benchmark report. + * + * @param filename Filename where to store the CSV. + * @return Whether it was possible to open the file. + */ +errno_t csv_report_open(const char *filename) +{ + csv_output = fopen(filename, "w"); + if (csv_output == NULL) { + return errno; + } + + fprintf(csv_output, "benchmark,run,size,duration_nanos\n"); + + return EOK; +} + +/** Add one entry to the report. + * + * When csv_report_open() was not called or failed, the function does + * nothing. + * + * @param run Performance data of the entry. + * @param run_index Run index, use negative values for warm-up. + * @param bench Benchmark information. + * @param workload_size Workload size. + */ +void csv_report_add_entry(bench_run_t *run, int run_index, + benchmark_t *bench, uint64_t workload_size) +{ + if (csv_output == NULL) { + return; + } + + fprintf(csv_output, "%s,%d,%" PRIu64 ",%lld\n", + bench->name, run_index, workload_size, + (long long) stopwatch_get_nanos(&run->stopwatch)); +} + +/** Close CSV report. + * + * When csv_report_open() was not called or failed, the function does + * nothing. + */ +void csv_report_close(void) +{ + if (csv_output != NULL) { + fclose(csv_output); + } +} + +/** @} + */ Index: uspace/app/hbench/doc/doxygroups.h =================================================================== --- uspace/app/hbench/doc/doxygroups.h (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/hbench/doc/doxygroups.h (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,44 @@ +/** @addtogroup hbench hbench + * @brief User space benchmarks + * @ingroup apps + * + * @details + * + * To add a new benchmark, you need to implement the actual benchmarking + * code and register it. + * + * Registration is done by adding + * extern benchmark_t bench_YOUR_NAME reference to benchlist.h + * and by adding it to the array in benchlist.c. + * + * The actual benchmark should reside in a separate file (see malloc/malloc1.c + * for example) and has to (at least) declare one function (the actual + * benchmark) and fill-in the benchmark_t structure. + * + * Fill-in the name of the benchmark, its description and a reference to the + * benchmark function to the benchmark_t. + * + * The benchmarking function has to accept trhee arguments: + * @li bench_env_t: benchmark environment configuration + * @li bench_run_t: call bench_run_start and bench_run_stop around the + * actual benchmarking code + * @li uint64_t: size of the workload - typically number of inner loops in + * your benchmark (used to self-calibrate benchmark size) + * + * Typically, the structure of the function is following: + * @code{c} + * static bool runnerconst bench_env_t const *envbench_run_t *run, uint64_t size) + * { + * bench_run_start(run); + * for (uint64_t i = 0; i < size; i++) { + * // measured action + * if (something_fails) { + * return bench_run_fail(run, "oops: %s (%d)", str_error(rc), rc); + * } + * } + * bench_run_stop(run); + * + * return true; + * } + * @endcode + */ Index: uspace/app/hbench/env.c =================================================================== --- uspace/app/hbench/env.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/hbench/env.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2019 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup hbench + * @{ + */ +/** + * @file + */ + +#include +#include +#include +#include "hbench.h" + +typedef struct { + ht_link_t link; + + char *key; + char *value; +} param_t; + +static size_t param_hash(const ht_link_t *item) +{ + param_t *param = hash_table_get_inst(item, param_t, link); + return str_size(param->key); +} + +static size_t param_key_hash(const void *key) +{ + const char *key_str = key; + return str_size(key_str); +} + +static bool param_key_equal(const void *key, const ht_link_t *item) +{ + param_t *param = hash_table_get_inst(item, param_t, link); + const char *key_str = key; + + return str_cmp(param->key, key_str) == 0; +} + +static bool param_equal(const ht_link_t *link_a, const ht_link_t *link_b) +{ + param_t *a = hash_table_get_inst(link_a, param_t, link); + param_t *b = hash_table_get_inst(link_b, param_t, link); + + return str_cmp(a->key, b->key) == 0; +} + +static void param_remove(ht_link_t *item) +{ + param_t *param = hash_table_get_inst(item, param_t, link); + free(param->key); + free(param->value); +} + +static hash_table_ops_t param_hash_table_ops = { + .hash = param_hash, + .key_hash = param_key_hash, + .key_equal = param_key_equal, + .equal = param_equal, + .remove_callback = param_remove +}; + +errno_t bench_env_init(bench_env_t *env) +{ + bool ok = hash_table_create(&env->parameters, 0, 0, ¶m_hash_table_ops); + if (!ok) { + return ENOMEM; + } + + env->run_count = DEFAULT_RUN_COUNT; + env->minimal_run_duration_nanos = MSEC2NSEC(DEFAULT_MIN_RUN_DURATION_SEC); + + return EOK; +} + +void bench_env_cleanup(bench_env_t *env) +{ + hash_table_destroy(&env->parameters); +} + +errno_t bench_env_param_set(bench_env_t *env, const char *key, const char *value) +{ + param_t *param = malloc(sizeof(param_t)); + if (param == NULL) { + return ENOMEM; + } + + param->key = str_dup(key); + param->value = str_dup(value); + + if ((param->key == NULL) || (param->value == NULL)) { + free(param->key); + free(param->value); + free(param); + + return ENOMEM; + } + + hash_table_insert(&env->parameters, ¶m->link); + + return EOK; +} + +const char *bench_env_param_get(bench_env_t *env, const char *key, const char *default_value) +{ + ht_link_t *item = hash_table_find(&env->parameters, (char *) key); + + if (item == NULL) { + return default_value; + } + + param_t *param = hash_table_get_inst(item, param_t, link); + return param->value; +} + +/** @} + */ Index: uspace/app/hbench/fs/dirread.c =================================================================== --- uspace/app/hbench/fs/dirread.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/hbench/fs/dirread.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2011 Martin Sucha + * Copyright (c) 2019 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup hbench + * @{ + */ + +#include +#include +#include +#include +#include "../hbench.h" + +/** Execute directory listing benchmark. + * + * Note that while this benchmark tries to measure speed of direct + * read, it rather measures speed of FS cache as it is highly probable + * that the corresponding blocks would be cached after first run. + */ +static bool runner(bench_env_t *env, bench_run_t *run, uint64_t size) +{ + const char *path = bench_env_param_get(env, "dirname", "/"); + + bench_run_start(run); + for (uint64_t i = 0; i < size; i++) { + DIR *dir = opendir(path); + if (dir == NULL) { + return bench_run_fail(run, "failed to open %s for reading: %s", + path, str_error(errno)); + } + + struct dirent *dp; + while ((dp = readdir(dir))) { + /* Do nothing */ + } + + closedir(dir); + } + bench_run_stop(run); + + return true; +} + +benchmark_t benchmark_dir_read = { + .name = "dir_read", + .desc = "Read contents of a directory (use 'dirname' param to alter the default).", + .entry = &runner, + .setup = NULL, + .teardown = NULL +}; + +/** + * @} + */ Index: uspace/app/hbench/fs/fileread.c =================================================================== --- uspace/app/hbench/fs/fileread.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/hbench/fs/fileread.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2011 Martin Sucha + * Copyright (c) 2019 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup hbench + * @{ + */ + +#include +#include +#include +#include "../hbench.h" + +#define BUFFER_SIZE 4096 + +/** Execute file reading benchmark. + * + * Note that while this benchmark tries to measure speed of file reading, + * it rather measures speed of FS cache as it is highly probable that the + * corresponding blocks would be cached after first run. + */ +static bool runner(bench_env_t *env, bench_run_t *run, uint64_t size) +{ + const char *path = bench_env_param_get(env, "filename", "/data/web/helenos.png"); + + char *buf = malloc(BUFFER_SIZE); + if (buf == NULL) { + return bench_run_fail(run, "failed to allocate %dB buffer", BUFFER_SIZE); + } + + bool ret = true; + + FILE *file = fopen(path, "r"); + if (file == NULL) { + bench_run_fail(run, "failed to open %s for reading: %s", + path, str_error(errno)); + ret = false; + goto leave_free_buf; + } + + bench_run_start(run); + for (uint64_t i = 0; i < size; i++) { + int rc = fseek(file, 0, SEEK_SET); + if (rc != 0) { + bench_run_fail(run, "failed to rewind %s: %s", + path, str_error(errno)); + ret = false; + goto leave_close; + } + while (!feof(file)) { + fread(buf, 1, BUFFER_SIZE, file); + if (ferror(file)) { + bench_run_fail(run, "failed to read from %s: %s", + path, str_error(errno)); + ret = false; + goto leave_close; + } + } + } + bench_run_stop(run); + +leave_close: + fclose(file); + +leave_free_buf: + free(buf); + + return ret; +} + +benchmark_t benchmark_file_read = { + .name = "file_read", + .desc = "Sequentially read contents of a file (use 'filename' param to alter the default).", + .entry = &runner, + .setup = NULL, + .teardown = NULL +}; + +/** + * @} + */ Index: uspace/app/hbench/hbench.h =================================================================== --- uspace/app/hbench/hbench.h (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/hbench/hbench.h (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2018 Jiri Svoboda + * Copyright (c) 2019 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup hbench + * @{ + */ +/** @file + */ + +#ifndef HBENCH_H_ +#define HBENCH_H_ + +#include +#include +#include +#include + +#define DEFAULT_RUN_COUNT 10 +#define DEFAULT_MIN_RUN_DURATION_SEC 10 + +/** Single run information. + * + * Used to store both performance information (now, only wall-clock + * time) as well as information about error. + * + * Use proper access functions when modifying data inside this structure. + * + * Eventually, we could collection of hardware counters etc. without + * modifying signatures of any existing benchmark. + */ +typedef struct { + stopwatch_t stopwatch; + char *error_message; + size_t error_message_buffer_size; +} bench_run_t; + +/** Benchmark environment configuration. + * + * Benchmarking code (runners) should use access functions to read + * data from this structure (now only bench_env_param_get). + * + * Harness can access it directly. + */ +typedef struct { + hash_table_t parameters; + size_t run_count; + nsec_t minimal_run_duration_nanos; +} bench_env_t; + +/** Actual benchmark runner. + * + * The first argument describes the environment, second is used to store + * information about the run (performance data or error message) and + * third describes workload size (number of iterations). + */ +typedef bool (*benchmark_entry_t)(bench_env_t *, bench_run_t *, uint64_t); + +/** Setup and teardown callback type. + * + * Unlike in benchmark_entry_t, we do not need to pass in number of + * iterations to execute (note that we use bench_run_t only to simplify + * creation of error messages). + */ +typedef bool (*benchmark_helper_t)(bench_env_t *, bench_run_t *); + +typedef struct { + const char *name; + const char *desc; + benchmark_entry_t entry; + benchmark_helper_t setup; + benchmark_helper_t teardown; +} benchmark_t; + +extern void bench_run_init(bench_run_t *, char *, size_t); +extern bool bench_run_fail(bench_run_t *, const char *, ...); + +/* + * We keep the following two functions inline to ensure that we start + * measurement as close to the surrounding code as possible. Note that + * this inlining is done at least on the level of individual wrappers + * (this one and the one provided by stopwatch_t) to pass the control + * as fast as possible to the actual timer used. + */ + +static inline void bench_run_start(bench_run_t *run) +{ + stopwatch_start(&run->stopwatch); +} + +static inline void bench_run_stop(bench_run_t *run) +{ + stopwatch_stop(&run->stopwatch); +} + +extern errno_t csv_report_open(const char *); +extern void csv_report_add_entry(bench_run_t *, int, benchmark_t *, uint64_t); +extern void csv_report_close(void); + +extern errno_t bench_env_init(bench_env_t *); +extern errno_t bench_env_param_set(bench_env_t *, const char *, const char *); +extern const char *bench_env_param_get(bench_env_t *, const char *, const char *); +extern void bench_env_cleanup(bench_env_t *); + +extern benchmark_t *benchmarks[]; +extern size_t benchmark_count; + +/* Put your benchmark descriptors here (and also to benchlist.c). */ +extern benchmark_t benchmark_dir_read; +extern benchmark_t benchmark_fibril_mutex; +extern benchmark_t benchmark_file_read; +extern benchmark_t benchmark_malloc1; +extern benchmark_t benchmark_malloc2; +extern benchmark_t benchmark_ns_ping; +extern benchmark_t benchmark_ping_pong; + +#endif + +/** @} + */ Index: uspace/app/hbench/ipc/ns_ping.c =================================================================== --- uspace/app/hbench/ipc/ns_ping.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/hbench/ipc/ns_ping.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2018 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup hbench + * @{ + */ + +#include +#include +#include +#include +#include +#include "../hbench.h" + +static bool runner(bench_env_t *env, bench_run_t *run, uint64_t niter) +{ + bench_run_start(run); + + for (uint64_t count = 0; count < niter; count++) { + errno_t rc = ns_ping(); + + if (rc != EOK) { + return bench_run_fail(run, "failed sending ping message: %s (%d)", + str_error(rc), rc); + } + } + + bench_run_stop(run); + + return true; +} + +benchmark_t benchmark_ns_ping = { + .name = "ns_ping", + .desc = "Name service IPC ping-pong benchmark", + .entry = &runner, + .setup = NULL, + .teardown = NULL +}; + +/** @} + */ Index: uspace/app/hbench/ipc/ping_pong.c =================================================================== --- uspace/app/hbench/ipc/ping_pong.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/hbench/ipc/ping_pong.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2009 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup hbench + * @{ + */ + +#include +#include +#include +#include +#include +#include "../hbench.h" + +static ipc_test_t *test = NULL; + +static bool setup(bench_env_t *env, bench_run_t *run) +{ + errno_t rc = ipc_test_create(&test); + if (rc != EOK) { + return bench_run_fail(run, + "failed contacting IPC test server (have you run /srv/test/ipc-test?): %s (%d)", + str_error(rc), rc); + } + + return true; +} + +static bool teardown(bench_env_t *env, bench_run_t *run) +{ + ipc_test_destroy(test); + return true; +} + +static bool runner(bench_env_t *env, bench_run_t *run, uint64_t niter) +{ + bench_run_start(run); + + for (uint64_t count = 0; count < niter; count++) { + errno_t rc = ipc_test_ping(test); + + if (rc != EOK) { + return bench_run_fail(run, "failed sending ping message: %s (%d)", + str_error(rc), rc); + } + } + + bench_run_stop(run); + + return true; +} + +benchmark_t benchmark_ping_pong = { + .name = "ping_pong", + .desc = "IPC ping-pong benchmark", + .entry = &runner, + .setup = &setup, + .teardown = &teardown +}; + +/** @} + */ Index: uspace/app/hbench/main.c =================================================================== --- uspace/app/hbench/main.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/hbench/main.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,429 @@ +/* + * Copyright (c) 2018 Jiri Svoboda + * Copyright (c) 2018 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup hbench + * @{ + */ +/** + * @file + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "hbench.h" + +#define MAX_ERROR_STR_LENGTH 1024 + +static void short_report(bench_run_t *info, int run_index, + benchmark_t *bench, uint64_t workload_size) +{ + csv_report_add_entry(info, run_index, bench, workload_size); + + usec_t duration_usec = NSEC2USEC(stopwatch_get_nanos(&info->stopwatch)); + + printf("Completed %" PRIu64 " operations in %llu us", + workload_size, duration_usec); + if (duration_usec > 0) { + double nanos = stopwatch_get_nanos(&info->stopwatch); + double thruput = (double) workload_size / (nanos / 1000000000.0l); + printf(", %.0f ops/s.\n", thruput); + } else { + printf(".\n"); + } +} + +/** Estimate square root value. + * + * @param value The value to compute square root of. + * @param precision Required precision (e.g. 0.00001). + * + * @details + * + * This is a temporary solution until we have proper sqrt() implementation + * in libmath. + * + * The algorithm uses Babylonian method [1]. + * + * [1] https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method + */ +static double estimate_square_root(double value, double precision) +{ + double estimate = 1.; + double prev_estimate = estimate + 10 * precision; + + while (fabs(estimate - prev_estimate) > precision) { + prev_estimate = estimate; + estimate = (prev_estimate + value / prev_estimate) / 2.; + } + + return estimate; +} + +/** Compute available statistics from given stopwatches. + * + * We compute normal mean for average duration of the workload and geometric + * mean for average thruput. Note that geometric mean is necessary to compute + * average throughput correctly - consider the following example: + * - we run always 60 operations, + * - first run executes in 30 s (i.e. 2 ops/s) + * - and second one in 10 s (6 ops/s). + * Then, naively, average throughput would be (2+6)/2 = 4 [ops/s]. However, we + * actually executed 60 + 60 ops in 30 + 10 seconds. So the actual average + * throughput is 3 ops/s (which is exactly what geometric mean means). + * + */ +static void compute_stats(bench_run_t *runs, size_t run_count, + uint64_t workload_size, double precision, double *out_duration_avg, + double *out_duration_sigma, double *out_thruput_avg) +{ + double inv_thruput_sum = 0.0; + double nanos_sum = 0.0; + double nanos_sum2 = 0.0; + + for (size_t i = 0; i < run_count; i++) { + double nanos = stopwatch_get_nanos(&runs[i].stopwatch); + double thruput = (double) workload_size / nanos; + + inv_thruput_sum += 1.0 / thruput; + nanos_sum += nanos; + nanos_sum2 += nanos * nanos; + } + *out_duration_avg = nanos_sum / run_count; + double sigma2 = (nanos_sum2 - nanos_sum * (*out_duration_avg)) / + ((double) run_count - 1); + // FIXME: implement sqrt properly + if (run_count > 1) { + *out_duration_sigma = estimate_square_root(sigma2, precision); + } else { + *out_duration_sigma = NAN; + } + *out_thruput_avg = 1.0 / (inv_thruput_sum / run_count); +} + +static void summary_stats(bench_run_t *runs, size_t run_count, + benchmark_t *bench, uint64_t workload_size) +{ + double duration_avg, duration_sigma, thruput_avg; + compute_stats(runs, run_count, workload_size, 0.001, + &duration_avg, &duration_sigma, &thruput_avg); + + printf("Average: %" PRIu64 " ops in %.0f us (sd %.0f us); " + "%.0f ops/s; Samples: %zu\n", + workload_size, duration_avg / 1000.0, duration_sigma / 1000.0, + thruput_avg * 1000000000.0, run_count); +} + +static bool run_benchmark(bench_env_t *env, benchmark_t *bench) +{ + printf("Warm up and determine workload size...\n"); + + /* + * We share this buffer across all runs as we know that it is + * used only on failure (and we abort after first error). + */ + char *error_msg = malloc(MAX_ERROR_STR_LENGTH + 1); + if (error_msg == NULL) { + printf("Out of memory!\n"); + return false; + } + str_cpy(error_msg, MAX_ERROR_STR_LENGTH, ""); + + bench_run_t helper_run; + bench_run_init(&helper_run, error_msg, MAX_ERROR_STR_LENGTH); + + bool ret = true; + + if (bench->setup != NULL) { + ret = bench->setup(env, &helper_run); + if (!ret) { + goto leave_error; + } + } + + /* + * Find workload size that is big enough to last few seconds. + * We also check that uint64_t is big enough. + */ + uint64_t workload_size = 0; + for (size_t bits = 0; bits <= 64; bits++) { + if (bits == 64) { + str_cpy(error_msg, MAX_ERROR_STR_LENGTH, "Workload too small even for 1 << 63"); + goto leave_error; + } + workload_size = ((uint64_t) 1) << bits; + + bench_run_t run; + bench_run_init(&run, error_msg, MAX_ERROR_STR_LENGTH); + + bool ok = bench->entry(env, &run, workload_size); + if (!ok) { + goto leave_error; + } + short_report(&run, -1, bench, workload_size); + + nsec_t duration = stopwatch_get_nanos(&run.stopwatch); + if (duration > env->minimal_run_duration_nanos) { + break; + } + } + + printf("Workload size set to %" PRIu64 ", measuring %zu samples.\n", + workload_size, env->run_count); + + bench_run_t *runs = calloc(env->run_count, sizeof(bench_run_t)); + if (runs == NULL) { + snprintf(error_msg, MAX_ERROR_STR_LENGTH, "failed allocating memory"); + goto leave_error; + } + for (size_t i = 0; i < env->run_count; i++) { + bench_run_init(&runs[i], error_msg, MAX_ERROR_STR_LENGTH); + + bool ok = bench->entry(env, &runs[i], workload_size); + if (!ok) { + free(runs); + goto leave_error; + } + short_report(&runs[i], i, bench, workload_size); + } + + summary_stats(runs, env->run_count, bench, workload_size); + printf("\nBenchmark completed\n"); + + free(runs); + + goto leave; + +leave_error: + printf("Error: %s\n", error_msg); + ret = false; + +leave: + if (bench->teardown != NULL) { + bool ok = bench->teardown(env, &helper_run); + if (!ok) { + printf("Error: %s\n", error_msg); + ret = false; + } + } + + free(error_msg); + + return ret; +} + +static int run_benchmarks(bench_env_t *env) +{ + unsigned int count_ok = 0; + unsigned int count_fail = 0; + + char *failed_names = NULL; + + printf("\n*** Running all benchmarks ***\n\n"); + + for (size_t it = 0; it < benchmark_count; it++) { + printf("%s (%s)\n", benchmarks[it]->name, benchmarks[it]->desc); + if (run_benchmark(env, benchmarks[it])) { + count_ok++; + continue; + } + + if (!failed_names) { + failed_names = str_dup(benchmarks[it]->name); + } else { + char *f = NULL; + asprintf(&f, "%s, %s", failed_names, benchmarks[it]->name); + if (!f) { + printf("Out of memory.\n"); + abort(); + } + free(failed_names); + failed_names = f; + } + count_fail++; + } + + printf("\nCompleted, %u benchmarks run, %u succeeded.\n", + count_ok + count_fail, count_ok); + if (failed_names) + printf("Failed benchmarks: %s\n", failed_names); + + return count_fail; +} + +static void list_benchmarks(void) +{ + size_t len = 0; + for (size_t i = 0; i < benchmark_count; i++) { + size_t len_now = str_length(benchmarks[i]->name); + if (len_now > len) + len = len_now; + } + + assert(can_cast_size_t_to_int(len) && "benchmark name length overflow"); + + for (size_t i = 0; i < benchmark_count; i++) + printf(" %-*s %s\n", (int) len, benchmarks[i]->name, benchmarks[i]->desc); + + printf(" %-*s Run all benchmarks\n", (int) len, "*"); +} + +static void print_usage(const char *progname) +{ + printf("Usage: %s [options] \n", progname); + printf("-h, --help " + "Print this help and exit\n"); + printf("-d, --duration MILLIS " + "Set minimal run duration (milliseconds)\n"); + printf("-n, --count N " + "Set number of measured runs\n"); + printf("-o, --output filename.csv " + "Store machine-readable data in filename.csv\n"); + printf("-p, --param KEY=VALUE " + "Additional parameters for the benchmark\n"); + printf(" is one of the following:\n"); + list_benchmarks(); +} + +static void handle_param_arg(bench_env_t *env, char *arg) +{ + char *value = NULL; + char *key = str_tok(arg, "=", &value); + bench_env_param_set(env, key, value); +} + +int main(int argc, char *argv[]) +{ + bench_env_t bench_env; + errno_t rc = bench_env_init(&bench_env); + if (rc != EOK) { + fprintf(stderr, "Failed to initialize internal params structure: %s\n", + str_error(rc)); + return -5; + } + + const char *short_options = "ho:p:n:d:"; + struct option long_options[] = { + { "duration", required_argument, NULL, 'd' }, + { "help", optional_argument, NULL, 'h' }, + { "count", required_argument, NULL, 'n' }, + { "output", required_argument, NULL, 'o' }, + { "param", required_argument, NULL, 'p' }, + { 0, 0, NULL, 0 } + }; + + char *csv_output_filename = NULL; + + int opt = 0; + while ((opt = getopt_long(argc, argv, short_options, long_options, NULL)) > 0) { + switch (opt) { + case 'd': + errno = EOK; + bench_env.minimal_run_duration_nanos = MSEC2NSEC(atoll(optarg)); + if ((errno != EOK) || (bench_env.minimal_run_duration_nanos <= 0)) { + fprintf(stderr, "Invalid -d argument.\n"); + return -3; + } + break; + case 'h': + print_usage(*argv); + return 0; + case 'n': + errno = EOK; + bench_env.run_count = (nsec_t) atoll(optarg); + if ((errno != EOK) || (bench_env.run_count <= 0)) { + fprintf(stderr, "Invalid -n argument.\n"); + return -3; + } + break; + case 'o': + csv_output_filename = optarg; + break; + case 'p': + handle_param_arg(&bench_env, optarg); + break; + case -1: + default: + break; + } + } + + if (optind + 1 != argc) { + print_usage(*argv); + fprintf(stderr, "Error: specify one benchmark to run or * for all.\n"); + return -3; + } + + const char *benchmark = argv[optind]; + + if (csv_output_filename != NULL) { + errno_t rc = csv_report_open(csv_output_filename); + if (rc != EOK) { + fprintf(stderr, "Failed to open CSV report '%s': %s\n", + csv_output_filename, str_error(rc)); + return -4; + } + } + + int exit_code = 0; + + if (str_cmp(benchmark, "*") == 0) { + exit_code = run_benchmarks(&bench_env); + } else { + bool benchmark_exists = false; + for (size_t i = 0; i < benchmark_count; i++) { + if (str_cmp(benchmark, benchmarks[i]->name) == 0) { + benchmark_exists = true; + exit_code = run_benchmark(&bench_env, benchmarks[i]) ? 0 : -1; + break; + } + } + if (!benchmark_exists) { + printf("Unknown benchmark \"%s\"\n", benchmark); + exit_code = -2; + } + } + + csv_report_close(); + bench_env_cleanup(&bench_env); + + return exit_code; +} + +/** @} + */ Index: uspace/app/hbench/malloc/malloc1.c =================================================================== --- uspace/app/hbench/malloc/malloc1.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/hbench/malloc/malloc1.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2018 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup hbench + * @{ + */ + +#include +#include +#include +#include "../hbench.h" + +static bool runner(bench_env_t *env, bench_run_t *run, uint64_t size) +{ + bench_run_start(run); + for (uint64_t i = 0; i < size; i++) { + void *p = malloc(1); + if (p == NULL) { + return bench_run_fail(run, + "failed to allocate 1B in run %" PRIu64 " (out of %" PRIu64 ")", + i, size); + } + free(p); + } + bench_run_stop(run); + + return true; +} + +benchmark_t benchmark_malloc1 = { + .name = "malloc1", + .desc = "User-space memory allocator benchmark, repeatedly allocate one block", + .entry = &runner, + .setup = NULL, + .teardown = NULL +}; + +/** @} + */ Index: uspace/app/hbench/malloc/malloc2.c =================================================================== --- uspace/app/hbench/malloc/malloc2.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/hbench/malloc/malloc2.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2018 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup hbench + * @{ + */ + +#include +#include +#include "../hbench.h" + +static bool runner(bench_env_t *env, bench_run_t *run, uint64_t niter) +{ + bench_run_start(run); + + void **p = malloc(niter * sizeof(void *)); + if (p == NULL) { + return bench_run_fail(run, "failed to allocate backend array (%" PRIu64 "B)", + niter * sizeof(void *)); + } + + for (uint64_t count = 0; count < niter; count++) { + p[count] = malloc(1); + if (p[count] == NULL) { + for (uint64_t j = 0; j < count; j++) { + free(p[j]); + } + free(p); + return bench_run_fail(run, + "failed to allocate 1B in run %" PRIu64 " (out of %" PRIu64 ")", + count, niter); + } + } + + for (uint64_t count = 0; count < niter; count++) + free(p[count]); + + free(p); + + bench_run_stop(run); + + return true; +} + +benchmark_t benchmark_malloc2 = { + .name = "malloc2", + .desc = "User-space memory allocator benchmark, allocate many small blocks", + .entry = &runner, + .setup = NULL, + .teardown = NULL +}; + +/** @} + */ Index: uspace/app/hbench/synch/fibril_mutex.c =================================================================== --- uspace/app/hbench/synch/fibril_mutex.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/hbench/synch/fibril_mutex.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2019 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup hbench + * @{ + */ + +#include +#include +#include "../hbench.h" + +/* + * Simple benchmark for fibril mutexes. There are two fibrils that compete + * over the same mutex as that is the simplest scenario. + */ + +typedef struct { + fibril_mutex_t mutex; + uint64_t counter; + atomic_bool done; +} shared_t; + +static errno_t competitor(void *arg) +{ + shared_t *shared = arg; + fibril_detach(fibril_get_id()); + + while (true) { + fibril_mutex_lock(&shared->mutex); + uint64_t local = shared->counter; + fibril_mutex_unlock(&shared->mutex); + if (local == 0) { + break; + } + } + + atomic_store(&shared->done, true); + + return EOK; +} + +static bool runner(bench_env_t *env, bench_run_t *run, uint64_t size) +{ + shared_t shared; + fibril_mutex_initialize(&shared.mutex); + shared.counter = size; + atomic_store(&shared.done, false); + + fid_t other = fibril_create(competitor, &shared); + fibril_add_ready(other); + + bench_run_start(run); + for (uint64_t i = 0; i < size; i++) { + fibril_mutex_lock(&shared.mutex); + shared.counter--; + fibril_mutex_unlock(&shared.mutex); + } + bench_run_stop(run); + + while (!atomic_load(&shared.done)) { + fibril_yield(); + } + + return true; +} + +benchmark_t benchmark_fibril_mutex = { + .name = "fibril_mutex", + .desc = "Speed of mutex lock/unlock operations", + .entry = &runner, + .setup = NULL, + .teardown = NULL +}; + +/** @} + */ Index: uspace/app/hbench/utils.c =================================================================== --- uspace/app/hbench/utils.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/hbench/utils.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2019 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup hbench + * @{ + */ +/** + * @file + */ + +#include +#include +#include "hbench.h" + +/** Initialize bench run structure. + * + * @param run Structure to intialize. + * @param error_buffer Pre-allocated memory to use for error messages. + * @param error_buffer_size Size of error_buffer. + */ +void bench_run_init(bench_run_t *run, char *error_buffer, size_t error_buffer_size) +{ + stopwatch_init(&run->stopwatch); + run->error_message = error_buffer; + run->error_message_buffer_size = error_buffer_size; +} + +/** Format error message on benchmark failure. + * + * This function always returns false so it can be easily used in benchmark + * runners as + * + * @code + * if (error) { + * return bench_run_fail(run, "we failed"); + * } + * @endcode + * + * @param run Current benchmark run. + * @param fmt printf-style message followed by extra arguments. + * @retval false Always. + */ +bool bench_run_fail(bench_run_t *run, const char *fmt, ...) +{ + va_list args; + va_start(args, fmt); + vsnprintf(run->error_message, run->error_message_buffer_size, fmt, args); + va_end(args); + + return false; +} + +/** @} + */ Index: uspace/app/init/untar.c =================================================================== --- uspace/app/init/untar.c (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/init/untar.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -45,5 +45,5 @@ typedef struct { const char *dev; - + service_id_t sid; aoff64_t offset; Index: uspace/app/kio/kio.c =================================================================== --- uspace/app/kio/kio.c (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/kio/kio.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -164,7 +164,7 @@ fibril_mutex_lock(&mtx); - size_t kio_start = (size_t) IPC_GET_ARG1(*call); - size_t kio_len = (size_t) IPC_GET_ARG2(*call); - size_t kio_stored = (size_t) IPC_GET_ARG3(*call); + size_t kio_start = (size_t) ipc_get_arg1(call); + size_t kio_len = (size_t) ipc_get_arg2(call); + size_t kio_stored = (size_t) ipc_get_arg3(call); size_t offset = (kio_start + kio_len - kio_stored) % kio_length; Index: uspace/app/lprint/Makefile =================================================================== --- uspace/app/lprint/Makefile (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/lprint/Makefile (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,35 @@ +# +# Copyright (c) 2018 Jiri Svoboda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +BINARY = lprint + +SOURCES = \ + lprint.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/app/lprint/doc/doxygroups.h =================================================================== --- uspace/app/lprint/doc/doxygroups.h (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/lprint/doc/doxygroups.h (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,4 @@ +/** @addtogroup lprint lprint + * @brief Print on a printer + * @ingroup apps + */ Index: uspace/app/lprint/lprint.c =================================================================== --- uspace/app/lprint/lprint.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) +++ uspace/app/lprint/lprint.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -0,0 +1,309 @@ +/* + * Copyright (c) 2018 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup lprint + * @{ + */ + +/** + * @file + * @brief Print on a printer + * + */ + +#include +#include +#include +#include +#include +#include + +#define NAME "lprint" + +#define BUF_SIZE 1024 + +static void syntax_print(void); + +/** Get default printer port. + * + * @param sid Place to store service ID of the printer port + * @return EOK on success or error code + */ +static errno_t lprint_get_def_printer_port(service_id_t *sid) +{ + category_id_t cid; + service_id_t *sids; + size_t nsids; + errno_t rc; + + rc = loc_category_get_id("printer-port", &cid, 0); + if (rc != EOK) + return EIO; + + rc = loc_category_get_svcs(cid, &sids, &nsids); + if (rc != EOK) + return EIO; + + if (nsids < 1) { + free(sids); + return EIO; + } + + *sid = sids[0]; + free(sids); + return EOK; +} + +/** Print a message. + * + * @param chardev Character device + * @param argc Number of arguments + * @param argv Arguments - strings to print + * + * @return EOK on success or error code + */ +static errno_t lprint_msg(chardev_t *chardev, int argc, char *argv[]) +{ + const char *msg; + size_t nbytes; + const char *sep; + errno_t rc; + + while (argc > 0) { + msg = *argv; + --argc; + ++argv; + + rc = chardev_write(chardev, msg, str_size(msg), &nbytes); + if (rc != EOK) { + printf(NAME ": Failed sending data.\n"); + return EIO; + } + + sep = argc > 0 ? " " : "\n"; + + rc = chardev_write(chardev, sep, str_size(sep), &nbytes); + if (rc != EOK) { + printf(NAME ": Failed sending data.\n"); + return EIO; + } + } + + return EOK; +} + +/** Print a file. + * + * @param chardev Character device + * @param fname File name + * + * @return EOK on success or error code + */ +static errno_t lprint_file(chardev_t *chardev, const char *fname) +{ + void *buf; + size_t nread, nwritten; + FILE *f = NULL; + errno_t rc; + + buf = malloc(BUF_SIZE); + if (buf == NULL) { + printf(NAME ": Out of memory.\n"); + rc = ENOMEM; + goto error; + } + + f = fopen(fname, "rb"); + if (f == NULL) { + printf(NAME ": Cannot open '%s'.\n", fname); + rc = EIO; + goto error; + } + + while (true) { + nread = fread(buf, 1, BUF_SIZE, f); + if (ferror(f)) { + printf(NAME ": Error reading file.\n"); + rc = EIO; + goto error; + } + + if (nread == 0) + break; + + rc = chardev_write(chardev, buf, nread, &nwritten); + if (rc != EOK) { + printf(NAME ": Failed sending data.\n"); + rc = EIO; + goto error; + } + + } + + fclose(f); + return EOK; +error: + if (buf != NULL) + free(buf); + if (f != NULL) + fclose(f); + return rc; +} + +int main(int argc, char **argv) +{ + chardev_t *chardev; + errno_t rc; + async_sess_t *sess; + service_id_t sid; + const char *svc_name = NULL; + bool msg_mode = false; + + if (argc < 2) { + printf(NAME ": Error, argument missing.\n"); + syntax_print(); + return 1; + } + + --argc; + ++argv; + + while (*argv != NULL && *argv[0] == '-') { + if (str_cmp(*argv, "-d") == 0) { + --argc; + ++argv; + + if (*argv == NULL) { + printf(NAME ": Error, argument missing.\n"); + syntax_print(); + return 1; + } + + svc_name = *argv; + --argc; + ++argv; + continue; + } + + if (str_cmp(*argv, "-m") == 0) { + msg_mode = true; + --argc; + ++argv; + continue; + } + + if (str_cmp(*argv, "--help") == 0) { + --argc; + ++argv; + + if (*argv != NULL) { + printf(NAME ": Error, unexpected argument.\n"); + syntax_print(); + return 1; + } + + syntax_print(); + return 0; + } + + printf(NAME ": Error, invalid argument.\n"); + syntax_print(); + return 1; + } + + if (argc < 1) { + printf(NAME ": Error, argument missing.\n"); + syntax_print(); + return 1; + } + + if (!msg_mode && argc > 1) { + printf(NAME ": Error, too many arguments.\n"); + syntax_print(); + return 1; + } + + if (svc_name != NULL) { + rc = loc_service_get_id(svc_name, &sid, 0); + if (rc != EOK) { + printf(NAME ": Failed resolving printer port service " + "'%s'.\n", svc_name); + return 1; + } + } else { + rc = lprint_get_def_printer_port(&sid); + if (rc != EOK) { + printf(NAME ": No printer found.\n"); + return 1; + } + } + + sess = loc_service_connect(sid, INTERFACE_DDF, 0); + if (sess == NULL) { + printf(NAME ": Failed connecting printer port service.\n"); + return 1; + } + + rc = chardev_open(sess, &chardev); + if (rc != EOK) { + async_hangup(sess); + printf(NAME ": Failed opening printer port device.\n"); + return 1; + } + + if (msg_mode) { + rc = lprint_msg(chardev, argc, argv); + if (rc != EOK) { + chardev_close(chardev); + return 1; + } + } else { + rc = lprint_file(chardev, argv[0]); + if (rc != EOK) { + chardev_close(chardev); + return 1; + } + } + + chardev_close(chardev); + return 0; +} + +/** Print syntax help. */ +static void syntax_print(void) +{ + printf("syntax:\n" + "\tlprint [] \n" + "\tlprint [] -m \n" + "options:\n" + "\t-d Print to the specified device\n"); +} + +/** + * @} + */ Index: uspace/app/mkbd/main.c =================================================================== --- uspace/app/mkbd/main.c (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/mkbd/main.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -39,4 +39,5 @@ #include #include +#include #include #include Index: uspace/app/mkext4/mkext4.c =================================================================== --- uspace/app/mkext4/mkext4.c (revision c878693123930f0906703462cf2807430679517e) +++ uspace/app/mkext4/mkext4.c (revision de9e28e0c0b35a214dcdc3688dc8579f50c5fbd6) @@ -56,4 +56,5 @@ aoff64_t nblocks; const char *label = ""; + unsigned int bsize = 4096; cfg.version = ext4_def_fs_version; @@ -68,5 +69,5 @@ ++argv; - while (*argv[0] == '-') { + while (*argv && *argv[0] == '-') { if (str_cmp(*argv, "--size") == 0) { --argc; @@ -87,4 +88,26 @@ --argc; ++argv; + continue; + } + + if (str_cmp(*argv, "--bsize") == 0) { + --argc; + ++argv; + if (*argv == NULL) { + printf(NAME ": Error, argument missing.\n"); + syntax_print(); + return 1; + } + + bsize = strtol(*argv, &endptr, 10); + if (*endptr != '\0') { + printf(NAME ": Error, invalid argument.\n"); + syntax_print(); + return 1; + } + + --argc; + ++argv; + continue; } @@ -107,4 +130,5 @@ --argc; ++argv; + continue; } @@ -122,4 +146,10 @@ --argc; ++argv; + continue; + } + + if (str_cmp(*argv, "--help") == 0) { + syntax_print(); + return 0; } @@ -128,4 +158,8 @@ ++argv; break; + } else { + printf(NAME ": Invalid argument: %s\n", *argv); + syntax_print(); + return 1; } } @@ -147,4 +181,5 @@ cfg.volume_name = label; + cfg.bsize = bsize; (void) nblocks; @@ -166,5 +201,6 @@ "\t--size Filesystem size, overrides device size\n" "\t--label