Changes in / [0f31e2b:1c6c4092] in mainline

Files:

• .bzrignore (modified) (1 diff)
• Makefile (modified) (4 diffs)
• boot/arch/amd64/Makefile.inc (modified) (1 diff)
• boot/arch/sparc64/include/arch.h (modified) (1 diff)
• boot/arch/sparc64/src/asm.S (modified) (1 diff)
• boot/arch/sparc64/src/main.c (modified) (4 diffs)
• boot/generic/src/balloc.c (modified) (1 diff)
• dist/Makefile (deleted)
• kernel/arch/sparc64/src/sun4v/asm.S (modified) (1 diff)
• tools/toolchain.sh (modified) (4 diffs)
• uspace/Makefile (modified) (2 diffs)
• uspace/app/bdsh/cmds/modules/mount/mount.c (modified) (3 diffs)
• uspace/doc/doxygroups.h (modified) (1 diff)
• uspace/drv/pciintel/pci.c (modified) (4 diffs)
• uspace/drv/uhci-hcd/main.c (modified) (4 diffs)
• uspace/drv/uhci-hcd/pci.c (modified) (2 diffs)
• uspace/drv/uhci-hcd/pci.h (modified) (1 diff)
• uspace/drv/uhci-hcd/uhci.c (modified) (12 diffs)
• uspace/drv/usbhid/hiddev.c (modified) (3 diffs)
• uspace/drv/usbhid/kbddev.c (modified) (2 diffs)
• uspace/drv/usbhid/usbhid.ma (modified) (1 diff)
• uspace/drv/usbhub/usbhub.c (modified) (2 diffs)
• uspace/drv/usbmid/explore.c (modified) (2 diffs)
• uspace/drv/usbmouse/Makefile (deleted)
• uspace/drv/usbmouse/init.c (deleted)
• uspace/drv/usbmouse/main.c (deleted)
• uspace/drv/usbmouse/mouse.c (deleted)
• uspace/drv/usbmouse/mouse.h (deleted)
• uspace/drv/usbmouse/usbmouse.ma (deleted)
• uspace/lib/c/generic/loader.c (modified) (1 diff)
• uspace/lib/c/generic/vfs/vfs.c (modified) (3 diffs)
• uspace/lib/c/include/ipc/dev_iface.h (modified) (1 diff)
• uspace/lib/drv/Makefile (modified) (1 diff)
• uspace/lib/drv/generic/dev_iface.c (modified) (2 diffs)
• uspace/lib/drv/generic/remote_pci.c (deleted)
• uspace/lib/drv/include/pci_dev_iface.h (deleted)
• uspace/lib/drv/include/remote_pci.h (deleted)
• uspace/lib/usb/include/usb/request.h (modified) (1 diff)
• uspace/lib/usb/src/request.c (modified) (3 diffs)
• uspace/srv/devmap/devmap.c (modified) (2 diffs)
• uspace/srv/fs/fat/fat_dentry.c (modified) (1 diff)
• uspace/srv/fs/fat/fat_ops.c (modified) (4 diffs)
• uspace/srv/hid/console/console.c (modified) (7 diffs)

.bzrignore

@@ -89 +89 @@
 ./uspace/drv/usbhid/usbhid
 ./uspace/drv/usbmid/usbmid
-./uspace/drv/usbmouse/usbmouse
 ./uspace/drv/vhc/vhc
 ./uspace/srv/bd/ata_bd/ata_bd

Makefile

@@ -42 +42 @@
 CONFIG_HEADER = config.h
 
-.PHONY: all precheck cscope autotool config_auto config_default config distclean clean check distfile dist
+.PHONY: all precheck cscope autotool config_auto config_default config distclean clean check
 
 all: $(COMMON_MAKEFILE) $(COMMON_HEADER) $(CONFIG_MAKEFILE) $(CONFIG_HEADER)
@@ -64 +64 @@
 endif
 
-# Autotool (detects compiler features)
-
 $(COMMON_MAKEFILE): autotool
 $(COMMON_HEADER): autotool
@@ -72 +70 @@
         $(AUTOTOOL)
         -[ -f $(COMMON_HEADER_PREV) ] && diff -q $(COMMON_HEADER_PREV) $(COMMON_HEADER) && mv -f $(COMMON_HEADER_PREV) $(COMMON_HEADER)
-
-# Build-time configuration
 
 $(CONFIG_MAKEFILE): config_default
@@ -88 +84 @@
         $(CONFIG) $<
 
-# Distribution files
-
-distfile: all
-        $(MAKE) -C dist distfile
-
-dist:
-        $(MAKE) -C dist dist
-
-# Cleaning
-
 distclean: clean
-        rm -f $(CSCOPE).out $(COMMON_MAKEFILE) $(COMMON_HEADER) $(COMMON_HEADER_PREV) $(CONFIG_MAKEFILE) $(CONFIG_HEADER) tools/*.pyc tools/checkers/*.pyc dist/HelenOS-*
+        rm -f $(CSCOPE).out $(COMMON_MAKEFILE) $(COMMON_HEADER) $(COMMON_HEADER_PREV) $(CONFIG_MAKEFILE) $(CONFIG_HEADER) tools/*.pyc tools/checkers/*.pyc
 
 clean:

boot/arch/amd64/Makefile.inc

@@ -48 +48 @@
         usbhid \
         usbmid \
-        usbmouse \
         vhc
 

boot/arch/sparc64/include/arch.h

@@ -41 +41 @@
 #define STACK_BIAS                   2047
 #define STACK_WINDOW_SAVE_AREA_SIZE  (16 * 8)
-#define STACK_ARG_SAVE_AREA_SIZE     (6 * 8)
 
 #define NWINDOWS  8

boot/arch/sparc64/src/asm.S

@@ -152 +152 @@
 .global ofw
 ofw:
-        save %sp, -(STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE), %sp
+        save %sp, -STACK_WINDOW_SAVE_AREA_SIZE, %sp
         set ofw_cif, %l0
         ldx [%l0], %l0

boot/arch/sparc64/src/main.c

@@ -190 +190 @@
         bootinfo.memmap.zones[0].start += OBP_BIAS;
         bootinfo.memmap.zones[0].size -= OBP_BIAS;
-        bootinfo.memmap.total -= OBP_BIAS;
 }
 
@@ -205 +204 @@
         bootinfo.physmem_start = ofw_get_physmem_start();
         ofw_memmap(&bootinfo.memmap);
-
-        if (arch == ARCH_SUN4V)
-                sun4v_fixups();
         
         void *bootinfo_pa = ofw_translate(&bootinfo);
@@ -257 +253 @@
                 
                 /*
-                 * At this point, we claim and map the physical memory that we
-                 * are going to use. We should be safe in case of the virtual
+                 * At this point, we claim the physical memory that we are
+                 * going to use. We should be safe in case of the virtual
                  * address space because the OpenFirmware, according to its
-                 * SPARC binding, should restrict its use of virtual memory to
-                 * addresses from [0xffd00000; 0xffefffff] and [0xfe000000;
-                 * 0xfeffffff].
+                 * SPARC binding, should restrict its use of virtual memory
+                 * to addresses from [0xffd00000; 0xffefffff] and
+                 * [0xfe000000; 0xfeffffff].
+                 *
+                 * We don't map this piece of memory. We simply rely on
+                 * SILO to have it done for us already in this case.
+                 *
+                 * XXX SILO only maps 8 MB for us here. We should improve
+                 *     this code to be totally independent on the behavior
+                 *     of SILO.
+                 *
                  */
                 ofw_claim_phys(bootinfo.physmem_start + dest[i - 1],
                     ALIGN_UP(components[i - 1].inflated, PAGE_SIZE));
-                
-                ofw_map(bootinfo.physmem_start + dest[i - 1], dest[i - 1],
-                    ALIGN_UP(components[i - 1].inflated, PAGE_SIZE), -1);
                 
                 int err = inflate(components[i - 1].start, components[i - 1].size,
@@ -303 +304 @@
                 sun4u_smp();
         
+        if (arch == ARCH_SUN4V)
+                sun4v_fixups();
+        
         printf("Booting the kernel ...\n");
         jump_to_kernel(bootinfo.physmem_start | BSP_PROCESSOR, &bootinfo, subarch,

boot/generic/src/balloc.c

@@ -65 +65 @@
 void *balloc_rebase(void *ptr)
 {
-        return (void *) (((uintptr_t) ptr - phys_base) + ballocs->base);
+        return (void *) ((uintptr_t) ptr - phys_base + ballocs->base);
 }

kernel/arch/sparc64/src/sun4v/asm.S

@@ -41 +41 @@
 .global switch_to_userspace
 switch_to_userspace:
-        save %o1, -(STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE), %sp
+        wrpr PSTATE_PRIV_BIT, %pstate
+        save %o1, -STACK_WINDOW_SAVE_AREA_SIZE, %sp
         flushw
         wrpr %g0, 0, %cleanwin          ! avoid information leak

tools/toolchain.sh

@@ -28 +28 @@
 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
-
-GMP_MAIN=<<EOF
-#define GCC_GMP_VERSION_NUM(a, b, c) \
-        (((a) << 16L) | ((b) << 8) | (c))
-
-#define GCC_GMP_VERSION \
-        GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
-
-#if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,2)
-        choke me
-#endif
-EOF
-
-MPFR_MAIN=<<EOF
-#if MPFR_VERSION < MPFR_VERSION_NUM(2, 4, 2)
-choke me
-        #endif
-EOF
-
-MPC_MAIN=<<EOF
-#if MPC_VERSION < MPC_VERSION_NUM(0, 8, 1)
-        choke me
-#endif
-EOF
-
-#
-# Check if the library described in the argument
-# exists and has acceptable version.
-#
-check_dependency() {
-        DEPENDENCY="$1"
-        HEADER="$2"
-        BODY="$3"
-        
-        FNAME="/tmp/conftest-$$"
-        
-        echo "#include ${HEADER}" > "${FNAME}.c"
-        echo >> "${FNAME}.c"
-        echo "int main()" >> "${FNAME}.c"
-        echo "{" >> "${FNAME}.c"
-        echo "${BODY}" >> "${FNAME}.c"
-        echo "  return 0;" >> "${FNAME}.c"
-        echo "}" >> "${FNAME}.c"
-        
-        cc -c -o "${FNAME}.o" "${FNAME}.c" 2> "${FNAME}.log"
-        RC="$?"
-        
-        if [ "$RC" -ne "0" ] ; then
-                echo " ${DEPENDENCY} not found, too old or compiler error."
-                echo " Please recheck manually the source file \"${FNAME}.c\"."
-                echo " The compilation of the toolchain is probably going to fail,"
-                echo " you have been warned."
-                echo
-                echo " ===== Compiler output ====="
-                cat "${FNAME}.log"
-                echo " ==========================="
-                echo
-        else
-                echo " ${DEPENDENCY} found"
-                rm -f "${FNAME}.log" "${FNAME}.o" "${FNAME}.c"
-        fi
-}
-
-check_dependecies() {
-        echo ">>> Basic dependency check"
-        check_dependency "GMP" "<gmp.h>" "${GMP_MAIN}"
-        check_dependency "MPFR" "<mpfr.h>" "${MPFR_MAIN}"
-        check_dependency "MPC" "<mpc.h>" "${MPC_MAIN}"
-        echo
-}
 
 check_error() {
@@ -139 +69 @@
         echo " sparc64    SPARC V9"
         echo " all        build all targets"
-        echo
-        echo "The toolchain will be installed to the directory specified by"
-        echo "the CROSS_PREFIX environment variable. If the variable is not"
-        echo "defined, /usr/local will be used by default."
         echo
         
@@ -192 +118 @@
         echo " - native C library with headers"
         echo
+        
+        show_countdown 10
 }
 
@@ -353 +281 @@
 
 show_dependencies
-check_dependecies
-show_countdown 10
 
 case "$1" in

uspace/Makefile

@@ -122 +122 @@
                 drv/usbhub \
                 drv/usbmid \
-                drv/usbmouse \
                 drv/vhc
 endif
@@ -139 +138 @@
                 drv/usbhub \
                 drv/usbmid \
-                drv/usbmouse \
                 drv/vhc
 endif

uspace/app/bdsh/cmds/modules/mount/mount.c

@@ -31 +31 @@
 #include <vfs/vfs.h>
 #include <errno.h>
-#include <getopt.h>
 #include "config.h"
 #include "util.h"
@@ -41 +40 @@
 static const char *cmdname = "mount";
 
-static struct option const long_options[] = {
-        { "help", no_argument, 0, 'h' },
-        { 0, 0, 0, 0 }
-};
-
-
-/* Displays help for mount in various levels */
+/* Dispays help for mount in various levels */
 void help_cmd_mount(unsigned int level)
 {
@@ -66 +59 @@
         unsigned int argc;
         const char *mopts = "";
-        int rc, c, opt_ind;
+        int rc;
 
         argc = cli_count_args(argv);
 
-        for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
-                c = getopt_long(argc, argv, "h", long_options, &opt_ind);
-                switch (c) {
-                case 'h':
-                        help_cmd_mount(HELP_LONG);
-                        return CMD_SUCCESS;
-                }
-        }
-
         if ((argc < 4) || (argc > 5)) {
-                printf("%s: invalid number of arguments. Try `mount --help'\n",
+                printf("%s: invalid number of arguments.\n",
                     cmdname);
                 return CMD_FAILURE;

uspace/doc/doxygroups.h

@@ -245 +245 @@
 
         /**
-         * @defgroup drvusbmouse USB mouse driver
-         * @ingroup usb
-         * @brief USB driver for mouse with boot protocol.
-         */
-
-        /**
          * @defgroup drvusbuhci UHCI driver
          * @ingroup usb

uspace/drv/pciintel/pci.c

@@ -59 +59 @@
 #include <ddi.h>
 #include <libarch/ddi.h>
-#include <pci_dev_iface.h>
 
 #include "pci.h"
@@ -122 +121 @@
 }
 
-static int pci_config_space_write_16(ddf_fun_t *fun, uint32_t address, uint16_t data)
-{
-        if (address > 254)
-                return EINVAL;
-        pci_conf_write_16(PCI_FUN(fun), address, data);
-        return EOK;
-}
-
-
 static hw_res_ops_t pciintel_hw_res_ops = {
         &pciintel_get_resources,
@@ -136 +126 @@
 };
 
-static pci_dev_iface_t pci_dev_ops = {
-        .config_space_read_8 = NULL,
-        .config_space_read_16 = NULL,
-        .config_space_read_32 = NULL,
-        .config_space_write_8 = NULL,
-        .config_space_write_16 = &pci_config_space_write_16,
-        .config_space_write_32 = NULL
-};
-
-static ddf_dev_ops_t pci_fun_ops = {
-        .interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops,
-        .interfaces[PCI_DEV_IFACE] = &pci_dev_ops
-};
+static ddf_dev_ops_t pci_fun_ops;
 
 static int pci_add_device(ddf_dev_t *);
@@ -615 +593 @@
 {
         pci_fun_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops;
-        pci_fun_ops.interfaces[PCI_DEV_IFACE] = &pci_dev_ops;
 }
 

uspace/drv/uhci-hcd/main.c

@@ -34 +34 @@
 #include <ddf/driver.h>
 #include <ddf/interrupt.h>
-#include <device/hw_res.h>
-#include <errno.h>
-#include <str_error.h>
-
 #include <usb_iface.h>
 #include <usb/ddfiface.h>
+#include <device/hw_res.h>
+
+#include <errno.h>
+
 #include <usb/debug.h>
 
@@ -50 +50 @@
 
 static int uhci_add_device(ddf_dev_t *device);
+
 /*----------------------------------------------------------------------------*/
 static driver_ops_t uhci_driver_ops = {
@@ -69 +70 @@
 }
 /*----------------------------------------------------------------------------*/
+#define CHECK_RET_RETURN(ret, message...) \
+if (ret != EOK) { \
+        usb_log_error(message); \
+        return ret; \
+}
+
 static int uhci_add_device(ddf_dev_t *device)
 {
         assert(device);
-        uhci_t *hcd = NULL;
-#define CHECK_RET_FREE_HC_RETURN(ret, message...) \
-if (ret != EOK) { \
-        usb_log_error(message); \
-        if (hcd != NULL) \
-                free(hcd); \
-        return ret; \
-}
 
         usb_log_info("uhci_add_device() called\n");
@@ -89 +88 @@
         int ret =
             pci_get_my_registers(device, &io_reg_base, &io_reg_size, &irq);
-        CHECK_RET_FREE_HC_RETURN(ret,
+
+        CHECK_RET_RETURN(ret,
             "Failed(%d) to get I/O addresses:.\n", ret, device->handle);
         usb_log_info("I/O regs at 0x%X (size %zu), IRQ %d.\n",
             io_reg_base, io_reg_size, irq);
 
-        ret = pci_disable_legacy(device);
-        CHECK_RET_FREE_HC_RETURN(ret,
-            "Failed(%d) disable legacy USB: %s.\n", ret, str_error(ret));
+//      ret = pci_enable_interrupts(device);
+//      CHECK_RET_RETURN(ret, "Failed(%d) to get enable interrupts:\n", ret);
 
-#if 0
-        ret = pci_enable_interrupts(device);
+        uhci_t *uhci_hc = malloc(sizeof(uhci_t));
+        ret = (uhci_hc != NULL) ? EOK : ENOMEM;
+        CHECK_RET_RETURN(ret, "Failed to allocate memory for uhci hcd driver.\n");
+
+        ret = uhci_init(uhci_hc, device, (void*)io_reg_base, io_reg_size);
         if (ret != EOK) {
-                usb_log_warning(
-                    "Failed(%d) to enable interrupts, fall back to polling.\n",
-                    ret);
+                usb_log_error("Failed to init uhci-hcd.\n");
+                free(uhci_hc);
+                return ret;
         }
-#endif
-
-        hcd = malloc(sizeof(uhci_t));
-        ret = (hcd != NULL) ? EOK : ENOMEM;
-        CHECK_RET_FREE_HC_RETURN(ret,
-            "Failed(%d) to allocate memory for uhci hcd.\n", ret);
-
-        ret = uhci_init(hcd, device, (void*)io_reg_base, io_reg_size);
-        CHECK_RET_FREE_HC_RETURN(ret, "Failed(%d) to init uhci-hcd.\n",
-            ret);
-#undef CHECK_RET_FREE_HC_RETURN
 
         /*
-         * We might free hcd, but that does not matter since no one
+         * We might free uhci_hc, but that does not matter since no one
          * else would access driver_data anyway.
          */
-        device->driver_data = hcd;
+        device->driver_data = uhci_hc;
+        ret = register_interrupt_handler(device, irq, irq_handler,
+            &uhci_hc->interrupt_code);
+        if (ret != EOK) {
+                usb_log_error("Failed to register interrupt handler.\n");
+                uhci_fini(uhci_hc);
+                free(uhci_hc);
+                return ret;
+        }
 
-        ddf_fun_t *rh = NULL;
-#define CHECK_RET_FINI_FREE_RETURN(ret, message...) \
-if (ret != EOK) { \
-        usb_log_error(message); \
-        if (hcd != NULL) {\
-                uhci_fini(hcd); \
-                free(hcd); \
-        } \
-        if (rh != NULL) \
-                free(rh); \
-        return ret; \
-}
-
-        /* It does no harm if we register this on polling */
-        ret = register_interrupt_handler(device, irq, irq_handler,
-            &hcd->interrupt_code);
-        CHECK_RET_FINI_FREE_RETURN(ret,
-            "Failed(%d) to register interrupt handler.\n", ret);
-
+        ddf_fun_t *rh;
         ret = setup_root_hub(&rh, device);
-        CHECK_RET_FINI_FREE_RETURN(ret,
-            "Failed(%d) to setup UHCI root hub.\n", ret);
-        rh->driver_data = hcd->ddf_instance;
+        if (ret != EOK) {
+                usb_log_error("Failed to setup uhci root hub.\n");
+                uhci_fini(uhci_hc);
+                free(uhci_hc);
+                return ret;
+        }
+        rh->driver_data = uhci_hc->ddf_instance;
 
         ret = ddf_fun_bind(rh);
-        CHECK_RET_FINI_FREE_RETURN(ret,
-            "Failed(%d) to register UHCI root hub.\n", ret);
+        if (ret != EOK) {
+                usb_log_error("Failed to register root hub.\n");
+                uhci_fini(uhci_hc);
+                free(uhci_hc);
+                free(rh);
+                return ret;
+        }
 
         return EOK;
-#undef CHECK_RET_FINI_FREE_RETURN
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/uhci-hcd/pci.c

@@ -40 +40 @@
 
 #include <usb/debug.h>
-#include <pci_dev_iface.h>
 
 #include "pci.h"
@@ -129 +128 @@
         return enabled ? EOK : EIO;
 }
-/*----------------------------------------------------------------------------*/
-int pci_disable_legacy(ddf_dev_t *device)
-{
-        assert(device);
-        int parent_phone = devman_parent_device_connect(device->handle,
-                IPC_FLAG_BLOCKING);
-        if (parent_phone < 0) {
-                return parent_phone;
-        }
-
-        /* See UHCI design guide for these values,
-         * write all WC bits in USB legacy register */
-        sysarg_t address = 0xc0;
-        sysarg_t value = 0x8f00;
-
-  int rc = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
-            IPC_M_CONFIG_SPACE_WRITE_16, address, value);
-        async_hangup(parent_phone);
-
-  return rc;
-}
-/*----------------------------------------------------------------------------*/
 /**
  * @}

uspace/drv/uhci-hcd/pci.h

@@ -40 +40 @@
 int pci_get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
 int pci_enable_interrupts(ddf_dev_t *);
-int pci_disable_legacy(ddf_dev_t *);
 
 #endif

uspace/drv/uhci-hcd/uhci.c

@@ -90 +90 @@
         .interfaces[USBHC_DEV_IFACE] = &uhci_iface,
 };
-/*----------------------------------------------------------------------------*/
+
 static int uhci_init_transfer_lists(uhci_t *instance);
 static int uhci_init_mem_structures(uhci_t *instance);
@@ -115 +115 @@
         } else (void) 0
 
-        /* Create UHCI function. */
+        /*
+         * Create UHCI function.
+         */
         instance->ddf_instance = ddf_fun_create(dev, fun_exposed, "uhci");
         ret = (instance->ddf_instance == NULL) ? ENOMEM : EOK;
-        CHECK_RET_DEST_FUN_RETURN(ret,
-            "Failed to create UHCI device function.\n");
+        CHECK_RET_DEST_FUN_RETURN(ret, "Failed to create UHCI device function.\n");
 
         instance->ddf_instance->ops = &uhci_ops;
@@ -125 +126 @@
 
         ret = ddf_fun_bind(instance->ddf_instance);
-        CHECK_RET_DEST_FUN_RETURN(ret,
-            "Failed(%d) to bind UHCI device function: %s.\n",
+        CHECK_RET_DEST_FUN_RETURN(ret, "Failed(%d) to bind UHCI device function: %s.\n",
             ret, str_error(ret));
 
@@ -132 +132 @@
         regs_t *io;
         ret = pio_enable(regs, reg_size, (void**)&io);
-        CHECK_RET_DEST_FUN_RETURN(ret,
-            "Failed(%d) to gain access to registers at %p: %s.\n",
+        CHECK_RET_DEST_FUN_RETURN(ret, "Failed(%d) to gain access to registers at %p: %s.\n",
             ret, str_error(ret), io);
         instance->registers = io;
-        usb_log_debug("Device registers at %p(%u) accessible.\n",
-            io, reg_size);
+        usb_log_debug("Device registers at %p(%u) accessible.\n", io, reg_size);
 
         ret = uhci_init_mem_structures(instance);
-        CHECK_RET_DEST_FUN_RETURN(ret,
-            "Failed to initialize UHCI memory structures.\n");
+        CHECK_RET_DEST_FUN_RETURN(ret, "Failed to initialize UHCI memory structures.\n");
 
         uhci_init_hw(instance);
-        instance->cleaner =
-            fibril_create(uhci_interrupt_emulator, instance);
+
+        instance->cleaner = fibril_create(uhci_interrupt_emulator, instance);
         fibril_add_ready(instance->cleaner);
 
@@ -158 +155 @@
 void uhci_init_hw(uhci_t *instance)
 {
-        assert(instance);
-
         /* reset everything, who knows what touched it before us */
         pio_write_16(&instance->registers->usbcmd, UHCI_CMD_GLOBAL_RESET);
@@ -176 +171 @@
         /* enable all interrupts, but resume interrupt */
         pio_write_16(&instance->registers->usbintr,
-            UHCI_INTR_CRC | UHCI_INTR_COMPLETE | UHCI_INTR_SHORT_PACKET);
+                  UHCI_INTR_CRC | UHCI_INTR_COMPLETE | UHCI_INTR_SHORT_PACKET);
 
         /* Start the hc with large(64B) packet FSBR */
@@ -205 +200 @@
                 interrupt_commands[1].addr = (void*)&instance->registers->usbsts;
                 instance->interrupt_code.cmdcount =
-                    sizeof(uhci_cmds) / sizeof(irq_cmd_t);
+                                sizeof(uhci_cmds) / sizeof(irq_cmd_t);
         }
 
@@ -254 +249 @@
         ret = transfer_list_init(&instance->transfers_bulk_full, "BULK_FULL");
         CHECK_RET_CLEAR_RETURN(ret, "Failed to init BULK list.");
-
         ret = transfer_list_init(&instance->transfers_control_full, "CONTROL_FULL");
         CHECK_RET_CLEAR_RETURN(ret, "Failed to init CONTROL FULL list.");
-
         ret = transfer_list_init(&instance->transfers_control_slow, "CONTROL_SLOW");
         CHECK_RET_CLEAR_RETURN(ret, "Failed to init CONTROL SLOW list.");
-
         ret = transfer_list_init(&instance->transfers_interrupt, "INTERRUPT");
         CHECK_RET_CLEAR_RETURN(ret, "Failed to init INTERRUPT list.");
@@ -300 +292 @@
             low_speed, batch->transfer_type, batch->max_packet_size)) {
                 usb_log_warning("Invalid USB packet specified %s SPEED %d %zu.\n",
-                    low_speed ? "LOW" : "FULL" , batch->transfer_type,
+                          low_speed ? "LOW" : "FULL" , batch->transfer_type,
                     batch->max_packet_size);
                 return ENOTSUP;
@@ -317 +309 @@
 {
         assert(instance);
+//      if ((status & (UHCI_STATUS_INTERRUPT | UHCI_STATUS_ERROR_INTERRUPT)) == 0)
+//              return;
+//      usb_log_debug2("UHCI interrupt: %X.\n", status);
         transfer_list_remove_finished(&instance->transfers_interrupt);
         transfer_list_remove_finished(&instance->transfers_control_slow);
@@ -345 +340 @@
         uhci_t *instance = (uhci_t*)arg;
         assert(instance);
-
-#define QH(queue) \
-        instance->transfers_##queue.queue_head
-
         while (1) {
                 const uint16_t cmd = pio_read_16(&instance->registers->usbcmd);
                 const uint16_t sts = pio_read_16(&instance->registers->usbsts);
-                const uint16_t intr =
-                    pio_read_16(&instance->registers->usbintr);
-
+                const uint16_t intr = pio_read_16(&instance->registers->usbintr);
                 if (((cmd & UHCI_CMD_RUN_STOP) != 1) || (sts != 0)) {
                         usb_log_debug2("Command: %X Status: %X Intr: %x\n",
@@ -364 +353 @@
                 if (frame_list != addr_to_phys(instance->frame_list)) {
                         usb_log_debug("Framelist address: %p vs. %p.\n",
-                            frame_list, addr_to_phys(instance->frame_list));
-                }
-
+                                frame_list, addr_to_phys(instance->frame_list));
+                }
                 int frnum = pio_read_16(&instance->registers->frnum) & 0x3ff;
                 usb_log_debug2("Framelist item: %d \n", frnum );
 
-                uintptr_t expected_pa = instance->frame_list[frnum] & (~0xf);
-                uintptr_t real_pa = addr_to_phys(QH(interrupt));
-                if (expected_pa != real_pa) {
+                queue_head_t* qh = instance->transfers_interrupt.queue_head;
+
+                if ((instance->frame_list[frnum] & (~0xf)) != (uintptr_t)addr_to_phys(qh)) {
                         usb_log_debug("Interrupt QH: %p vs. %p.\n",
-                            expected_pa, real_pa);
-                }
-
-                expected_pa = QH(interrupt)->next_queue & (~0xf);
-                real_pa = addr_to_phys(QH(control_slow));
-                if (expected_pa != real_pa) {
-                        usb_log_debug("Control Slow QH: %p vs. %p.\n",
-                            expected_pa, real_pa);
-                }
-
-                expected_pa = QH(control_slow)->next_queue & (~0xf);
-                real_pa = addr_to_phys(QH(control_full));
-                if (expected_pa != real_pa) {
-                        usb_log_debug("Control Full QH: %p vs. %p.\n",
-                            expected_pa, real_pa);
-                }
-
-                expected_pa = QH(control_full)->next_queue & (~0xf);
-                real_pa = addr_to_phys(QH(bulk_full));
-                if (expected_pa != real_pa ) {
-                        usb_log_debug("Bulk QH: %p vs. %p.\n",
-                            expected_pa, real_pa);
-                }
+                                instance->frame_list[frnum] & (~0xf), addr_to_phys(qh));
+                }
+
+                if ((qh->next_queue & (~0xf))
+                  != (uintptr_t)addr_to_phys(instance->transfers_control_slow.queue_head)) {
+                        usb_log_debug("Control Slow QH: %p vs. %p.\n", qh->next_queue & (~0xf),
+                                addr_to_phys(instance->transfers_control_slow.queue_head));
+                }
+                qh = instance->transfers_control_slow.queue_head;
+
+                if ((qh->next_queue & (~0xf))
+                  != (uintptr_t)addr_to_phys(instance->transfers_control_full.queue_head)) {
+                        usb_log_debug("Control Full QH: %p vs. %p.\n", qh->next_queue & (~0xf),
+                                addr_to_phys(instance->transfers_control_full.queue_head));\
+                }
+                qh = instance->transfers_control_full.queue_head;
+
+                if ((qh->next_queue & (~0xf))
+                  != (uintptr_t)addr_to_phys(instance->transfers_bulk_full.queue_head)) {
+                        usb_log_debug("Bulk QH: %p vs. %p.\n", qh->next_queue & (~0xf),
+                                addr_to_phys(instance->transfers_bulk_full.queue_head));
+                }
+/*
+        uint16_t cmd = pio_read_16(&instance->registers->usbcmd);
+        cmd |= UHCI_CMD_RUN_STOP;
+        pio_write_16(&instance->registers->usbcmd, cmd);
+*/
                 async_usleep(UHCI_DEBUGER_TIMEOUT);
         }
         return 0;
-#undef QH
 }
 /*----------------------------------------------------------------------------*/
 bool allowed_usb_packet(
-    bool low_speed, usb_transfer_type_t transfer, size_t size)
+        bool low_speed, usb_transfer_type_t transfer, size_t size)
 {
         /* see USB specification chapter 5.5-5.8 for magic numbers used here */
-        switch(transfer)
-        {
-        case USB_TRANSFER_ISOCHRONOUS:
-                return (!low_speed && size < 1024);
-        case USB_TRANSFER_INTERRUPT:
-                return size <= (low_speed ? 8 : 64);
-        case USB_TRANSFER_CONTROL: /* device specifies its own max size */
-                return (size <= (low_speed ? 8 : 64));
-        case USB_TRANSFER_BULK: /* device specifies its own max size */
-                return (!low_speed && size <= 64);
+        switch(transfer) {
+                case USB_TRANSFER_ISOCHRONOUS:
+                        return (!low_speed && size < 1024);
+                case USB_TRANSFER_INTERRUPT:
+                        return size <= (low_speed ? 8 : 64);
+                case USB_TRANSFER_CONTROL: /* device specifies its own max size */
+                        return (size <= (low_speed ? 8 : 64));
+                case USB_TRANSFER_BULK: /* device specifies its own max size */
+                        return (!low_speed && size <= 64);
         }
         return false;

uspace/drv/usbhid/hiddev.c

@@ -149 +149 @@
         usb_log_info("Processing descriptors...\n");
         
+        // get the first configuration descriptor
+        usb_standard_configuration_descriptor_t config_desc;
+        
         int rc;
-
-        uint8_t *descriptors = NULL;
-        size_t descriptors_size;
-        rc = usb_request_get_full_configuration_descriptor_alloc(
-            &hid_dev->ctrl_pipe, 0, (void **) &descriptors, &descriptors_size);
-        if (rc != EOK) {
-                usb_log_error("Failed to retrieve config descriptor: %s.\n",
-                    str_error(rc));
-                return rc;
+        rc = usb_request_get_bare_configuration_descriptor(&hid_dev->ctrl_pipe,
+            0, &config_desc);
+        
+        if (rc != EOK) {
+                usb_log_error("Failed to get bare config descriptor: %s.\n",
+                    str_error(rc));
+                return rc;
+        }
+        
+        // prepare space for all underlying descriptors
+        uint8_t *descriptors = (uint8_t *)malloc(config_desc.total_length);
+        if (descriptors == NULL) {
+                usb_log_error("No memory!.\n");
+                return ENOMEM;
+        }
+        
+        size_t transferred = 0;
+        // get full configuration descriptor
+        rc = usb_request_get_full_configuration_descriptor(&hid_dev->ctrl_pipe,
+            0, descriptors, config_desc.total_length, &transferred);
+        
+        if (rc != EOK) {
+                usb_log_error("Failed to get full config descriptor: %s.\n",
+                    str_error(rc));
+                free(descriptors);
+                return rc;
+        }
+        
+        if (transferred != config_desc.total_length) {
+                usb_log_error("Configuration descriptor has wrong size (%u, "
+                    "expected %u).\n", transferred, config_desc.total_length);
+                free(descriptors);
+                return ELIMIT;
         }
         
@@ -174 +201 @@
         
         rc = usb_endpoint_pipe_initialize_from_configuration(
-            endpoint_mapping, 1, descriptors, descriptors_size,
+            endpoint_mapping, 1, descriptors, config_desc.total_length,
             &hid_dev->wire);
         
@@ -206 +233 @@
         assert(endpoint_mapping[0].interface != NULL);
         
-        rc = usbhid_dev_get_report_descriptor(hid_dev,
-            descriptors, descriptors_size,
+        rc = usbhid_dev_get_report_descriptor(hid_dev, descriptors, transferred,
             (uint8_t *)endpoint_mapping[0].interface);
         

uspace/drv/usbhid/kbddev.c

@@ -255 +255 @@
         usb_log_debug2("\nLock keys after: 0x%x\n\n", kbd_dev->lock_keys);
         
-        if (key == KC_CAPS_LOCK || key == KC_NUM_LOCK || key == KC_SCROLL_LOCK) {
+        if (key = KC_CAPS_LOCK || key == KC_NUM_LOCK || key == KC_SCROLL_LOCK) {
                 // do not send anything to the console, this is our business
                 return;
@@ -289 +289 @@
 
         usb_log_debug2("Sending key %d to the console\n", ev.key);
-        if (kbd_dev->console_phone < 0) {
-                usb_log_warning(
-                    "Connection to console not ready, key discarded.\n");
-                return;
-        }
+        assert(kbd_dev->console_phone != -1);
         
         async_msg_4(kbd_dev->console_phone, KBD_EVENT, ev.type, ev.key, 

uspace/drv/usbhid/usbhid.ma

@@ -1 @@
-100 usb&interface&class=HID&subclass=0x01&protocol=0x01
+10 usb&class=hid
+10 usb&class=HID
 10 usb&interface&class=HID
+10 usb&hid

uspace/drv/usbhub/usbhub.c

@@ -149 +149 @@
         }
 
-        /* Retrieve full configuration descriptor. */
-        uint8_t *descriptors = NULL;
-        size_t descriptors_size = 0;
-        opResult = usb_request_get_full_configuration_descriptor_alloc(
+        //configuration descriptor
+        /// \TODO check other configurations?
+        usb_standard_configuration_descriptor_t config_descriptor;
+        opResult = usb_request_get_bare_configuration_descriptor(
             &hub->endpoints.control, 0,
-            (void **) &descriptors, &descriptors_size);
-        if (opResult != EOK) {
-                usb_log_error("Could not get configuration descriptor: %s.\n",
-                    str_error(opResult));
+        &config_descriptor);
+        if(opResult!=EOK){
+                dprintf(USB_LOG_LEVEL_ERROR, "could not get configuration descriptor, %d",opResult);
                 return opResult;
         }
-        usb_standard_configuration_descriptor_t *config_descriptor
-            = (usb_standard_configuration_descriptor_t *) descriptors;
-
-        /* Set configuration. */
+        //set configuration
         opResult = usb_request_set_configuration(&hub->endpoints.control,
-            config_descriptor->configuration_number);
-
-        if (opResult != EOK) {
-                usb_log_error("Failed to set hub configuration: %s.\n",
-                    str_error(opResult));
+                config_descriptor.configuration_number);
+
+        if (opResult != EOK) {
+                dprintf(USB_LOG_LEVEL_ERROR,
+                                "something went wrong when setting hub`s configuration, %d",
+                                opResult);
                 return opResult;
         }
         dprintf(USB_LOG_LEVEL_DEBUG, "\tused configuration %d",
-                        config_descriptor->configuration_number);
+                        config_descriptor.configuration_number);
+
+        //full configuration descriptor
+        size_t transferred = 0;
+        uint8_t * descriptors = (uint8_t *)malloc(config_descriptor.total_length);
+        if (descriptors == NULL) {
+                dprintf(USB_LOG_LEVEL_ERROR, "insufficient memory");
+                return ENOMEM;
+        }
+        opResult = usb_request_get_full_configuration_descriptor(&hub->endpoints.control,
+            0, descriptors,
+            config_descriptor.total_length, &transferred);
+        if(opResult!=EOK){
+                free(descriptors);
+                dprintf(USB_LOG_LEVEL_ERROR,
+                                "could not get full configuration descriptor, %d",opResult);
+                return opResult;
+        }
+        if (transferred != config_descriptor.total_length) {
+                dprintf(USB_LOG_LEVEL_ERROR,
+                                "received incorrect full configuration descriptor");
+                return ELIMIT;
+        }
 
         usb_endpoint_mapping_t endpoint_mapping[1] = {
@@ -185 +204 @@
         opResult = usb_endpoint_pipe_initialize_from_configuration(
             endpoint_mapping, 1,
-            descriptors, descriptors_size,
+            descriptors, config_descriptor.total_length,
             &hub->device_connection);
         if (opResult != EOK) {

uspace/drv/usbmid/explore.c

@@ -42 +42 @@
 #include "usbmid.h"
 
+/** Allocate and retrieve full configuration descriptor.
+ *
+ * @param[in] dev USB device.
+ * @param[in] config_index Configuration index.
+ * @param[out] size Pointer where to store size of the allocated buffer.
+ * @return Allocated full configuration descriptor.
+ * @retval NULL Error occured.
+ */
+static void *get_configuration_descriptor(usbmid_device_t *dev,
+    size_t config_index, size_t *size)
+{
+        usb_standard_configuration_descriptor_t config_descriptor;
+        int rc = usb_request_get_bare_configuration_descriptor(&dev->ctrl_pipe,
+            config_index, &config_descriptor);
+        if (rc != EOK) {
+                usb_log_error("Failed getting configuration descriptor: %s.\n",
+                    str_error(rc));
+                return NULL;
+        }
+
+        void *full_config_descriptor = malloc(config_descriptor.total_length);
+        if (full_config_descriptor == NULL) {
+                usb_log_fatal("Out of memory (wanted: %zuB).\n",
+                    (size_t) config_descriptor.total_length);
+                return NULL;
+        }
+
+        size_t full_config_descriptor_size;
+        rc = usb_request_get_full_configuration_descriptor(&dev->ctrl_pipe,
+            config_index,
+            full_config_descriptor, config_descriptor.total_length,
+            &full_config_descriptor_size);
+        if (rc != EOK) {
+                usb_log_error("Failed getting configuration descriptor: %s.\n",
+                    str_error(rc));
+                free(full_config_descriptor);
+                return NULL;
+        }
+
+        if (full_config_descriptor_size != config_descriptor.total_length) {
+                usb_log_error("Failed getting full configuration descriptor.\n");
+                free(full_config_descriptor);
+                return NULL;
+        }
+
+        if (size != NULL) {
+                *size = full_config_descriptor_size;
+        }
+
+        return full_config_descriptor;
+}
+
 /** Find starting indexes of all interface descriptors in a configuration.
  *
@@ -126 +178 @@
 
         size_t config_descriptor_size;
-        uint8_t *config_descriptor_raw = NULL;
-        rc = usb_request_get_full_configuration_descriptor_alloc(
-            &dev->ctrl_pipe, 0,
-            (void **) &config_descriptor_raw, &config_descriptor_size);
-        if (rc != EOK) {
-                usb_log_error("Failed getting full config descriptor: %s.\n",
-                    str_error(rc));
+        uint8_t *config_descriptor_raw = get_configuration_descriptor(dev, 0,
+            &config_descriptor_size);
+        if (config_descriptor_raw == NULL) {
                 return false;
         }

uspace/lib/c/generic/loader.c

@@ -160 +160 @@
         int rc = async_data_write_start(ldr->phone_id, (void *) pa, pa_len);
         if (rc != EOK) {
-                free(pa);
                 async_wait_for(req, NULL);
                 return rc;

uspace/lib/c/generic/vfs/vfs.c

@@ -69 +69 @@
         char *ncwd_path;
         char *ncwd_path_nc;
-        size_t total_size; 
 
         fibril_mutex_lock(&cwd_mutex);
@@ -78 +77 @@
                         return NULL;
                 }
-                total_size = cwd_size + 1 + size + 1;
-                ncwd_path_nc = malloc(total_size);
+                ncwd_path_nc = malloc(cwd_size + 1 + size + 1);
                 if (!ncwd_path_nc) {
                         fibril_mutex_unlock(&cwd_mutex);
                         return NULL;
                 }
-                str_cpy(ncwd_path_nc, total_size, cwd_path);
+                str_cpy(ncwd_path_nc, cwd_size + 1 + size + 1, cwd_path);
                 ncwd_path_nc[cwd_size] = '/';
                 ncwd_path_nc[cwd_size + 1] = '\0';
         } else {
-                total_size = size + 1;
-                ncwd_path_nc = malloc(total_size);
+                ncwd_path_nc = malloc(size + 1);
                 if (!ncwd_path_nc) {
                         fibril_mutex_unlock(&cwd_mutex);
@@ -96 +93 @@
                 ncwd_path_nc[0] = '\0';
         }
-        str_append(ncwd_path_nc, total_size, path);
+        str_append(ncwd_path_nc, cwd_size + 1 + size + 1, path);
         ncwd_path = canonify(ncwd_path_nc, retlen);
         if (!ncwd_path) {

uspace/lib/c/include/ipc/dev_iface.h

@@ -38 +38 @@
         CHAR_DEV_IFACE,
 
-        /** Interface provided by any PCI device. */
-        PCI_DEV_IFACE,
-
         /** Interface provided by any USB device. */
         USB_DEV_IFACE,

uspace/lib/drv/Makefile

@@ -38 +38 @@
         generic/remote_hw_res.c \
         generic/remote_usb.c \
-        generic/remote_pci.c \
         generic/remote_usbhc.c
 

uspace/lib/drv/generic/dev_iface.c

@@ -43 +43 @@
 #include "remote_usb.h"
 #include "remote_usbhc.h"
-#include "remote_pci.h"
 
 static iface_dipatch_table_t remote_ifaces = {
@@ -49 +48 @@
                 &remote_hw_res_iface,
                 &remote_char_dev_iface,
-                &remote_pci_iface,
                 &remote_usb_iface,
                 &remote_usbhc_iface

uspace/lib/usb/include/usb/request.h

@@ -106 +106 @@
 int usb_request_get_full_configuration_descriptor(usb_endpoint_pipe_t *, int,
     void *, size_t, size_t *);
-int usb_request_get_full_configuration_descriptor_alloc(usb_endpoint_pipe_t *,
-    int, void **, size_t *);
 int usb_request_set_configuration(usb_endpoint_pipe_t *, uint8_t);
 

uspace/lib/usb/src/request.c

@@ -412 +412 @@
 }
 
-/** Retrieve full configuration descriptor, allocate space for it.
- *
- * The function takes care that full configuration descriptor is returned
- * (i.e. the function will fail when less data then descriptor.totalLength
- * is returned).
- *
- * @param[in] pipe Control endpoint pipe (session must be already started).
- * @param[in] index Configuration index.
- * @param[out] descriptor_ptr Where to store pointer to allocated buffer.
- * @param[out] descriptor_size Where to store the size of the descriptor.
- * @return Error code.
- */
-int usb_request_get_full_configuration_descriptor_alloc(
-    usb_endpoint_pipe_t *pipe, int index,
-    void **descriptor_ptr, size_t *descriptor_size)
-{
-        int rc;
-
-        if (descriptor_ptr == NULL) {
-                return EBADMEM;
-        }
-
-        usb_standard_configuration_descriptor_t bare_config;
-        rc = usb_request_get_bare_configuration_descriptor(pipe, index,
-            &bare_config);
-        if (rc != EOK) {
-                return rc;
-        }
-
-        if (bare_config.descriptor_type != USB_DESCTYPE_CONFIGURATION) {
-                return ENOENT;
-        }
-        if (bare_config.total_length < sizeof(bare_config)) {
-                return ELIMIT;
-        }
-
-        void *buffer = malloc(bare_config.total_length);
-        if (buffer == NULL) {
-                return ENOMEM;
-        }
-
-        size_t transferred = 0;
-        rc = usb_request_get_full_configuration_descriptor(pipe, index,
-            buffer, bare_config.total_length, &transferred);
-        if (rc != EOK) {
-                free(buffer);
-                return rc;
-        }
-
-        if (transferred != bare_config.total_length) {
-                free(buffer);
-                return ELIMIT;
-        }
-
-        /* Everything looks okay, copy the pointers. */
-
-        *descriptor_ptr = buffer;
-
-        if (descriptor_size != NULL) {
-                *descriptor_size = bare_config.total_length;
-        }
-
-        return EOK;
-}
-
 /** Set configuration of USB device.
  *
@@ -569 +504 @@
  *
  * @param[in] pipe Control endpoint pipe (session must be already started).
- * @param[in] index String index (in native endianess),
- *      first index has number 1 (index from descriptors can be used directly).
+ * @param[in] index String index (in native endianess).
  * @param[in] lang String language (in native endianess).
  * @param[out] string_ptr Where to store allocated string in native encoding.
@@ -581 +515 @@
                 return EBADMEM;
         }
-        /*
-         * Index is actually one byte value and zero index is used
-         * to retrieve list of supported languages.
-         */
-        if ((index < 1) || (index > 0xFF)) {
+        /* Index is actually one byte value. */
+        if (index > 0xFF) {
                 return ERANGE;
         }

uspace/srv/devmap/devmap.c

@@ -123 +123 @@
 static devmap_handle_t last_handle = 0;
 static devmap_device_t *null_devices[NULL_DEVICES];
-
-/*
- * Dummy list for null devices. This is necessary so that null devices can
- * be used just as any other devices, e.g. in devmap_device_unregister_core().
- */
-static LIST_INITIALIZE(dummy_null_driver_devices);
 
 static devmap_handle_t devmap_create_handle(void)
@@ -959 +953 @@
         device->name = dev_name;
         
-        /*
-         * Insert device into list of all devices and into null devices array.
-         * Insert device into a dummy list of null driver's devices so that it
-         * can be safely removed later.
-         */
+        /* Insert device into list of all devices
+           and into null devices array */
         list_append(&device->devices, &devices_list);
-        list_append(&device->driver_devices, &dummy_null_driver_devices);
         null_devices[i] = device;
         

uspace/srv/fs/fat/fat_dentry.c

@@ -42 +42 @@
 static bool is_d_char(const char ch)
 {
-        if (isalnum(ch) || ch == '_' || ch == '-')
+        if (isalnum(ch) || ch == '_')
                 return true;
         else

uspace/srv/fs/fat/fat_ops.c

@@ -325 +325 @@
                     uint16_t_le2host(d->firstc));
                 if (rc != EOK) {
-                        (void) block_put(b);
                         (void) fat_node_put(FS_NODE(nodep));
                         return rc;
@@ -812 +811 @@
         fibril_mutex_unlock(&childp->idx->lock);
         childp->lnkcnt = 0;
-        childp->refcnt++;       /* keep the node in memory until destroyed */
         childp->dirty = true;
         fibril_mutex_unlock(&childp->lock);
@@ -1490 +1488 @@
         fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
         fs_node_t *fn;
-        fat_node_t *nodep;
         int rc;
 
@@ -1502 +1499 @@
                 return;
         }
-
-        nodep = FAT_NODE(fn);
-        /*
-         * We should have exactly two references. One for the above
-         * call to fat_node_get() and one from fat_unlink().
-         */
-        assert(nodep->refcnt == 2);
 
         rc = fat_destroy_node(fn);

uspace/srv/hid/console/console.c

@@ -41 +41 @@
 #include <ipc/ns.h>
 #include <errno.h>
-#include <str_error.h>
 #include <ipc/console.h>
 #include <unistd.h>
@@ -65 +64 @@
 #define NAME       "console"
 #define NAMESPACE  "term"
-/** Interval for checking for new keyboard (1/4s). */
-#define HOTPLUG_WATCH_INTERVAL (1000 * 250)
 
 /** Phone to the keyboard driver. */
@@ -715 +712 @@
 }
 
-static int connect_keyboard_or_mouse(const char *devname,
-    async_client_conn_t handler, const char *path)
+static int connect_keyboard(char *path)
 {
         int fd = open(path, O_RDONLY);
@@ -729 +725 @@
         }
         
-        int rc = async_connect_to_me(phone, SERVICE_CONSOLE, 0, 0, handler);
+        /* NB: The callback connection is slotted for removal */
+        sysarg_t phonehash;
+        sysarg_t taskhash;
+        int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, SERVICE_CONSOLE,
+            0, 0, NULL, NULL, NULL, &taskhash, &phonehash);
         if (rc != EOK) {
-                printf(NAME ": " \
-                    "Failed to create callback from input device: %s.\n",
-                    str_error(rc));
+                printf(NAME ": Failed to create callback from input device\n");
                 return rc;
         }
         
-        printf(NAME ": found %s \"%s\".\n", devname, path);
+        async_new_connection(taskhash, phonehash, 0, NULL, keyboard_events);
+
+        printf(NAME ": we got a hit (new keyboard \"%s\").\n", path);
 
         return phone;
 }
 
-static int connect_keyboard(const char *path)
-{
-        return connect_keyboard_or_mouse("keyboard", keyboard_events, path);
-}
-
-static int connect_mouse(const char *path)
-{
-        return connect_keyboard_or_mouse("mouse", mouse_events, path);
-}
-
-struct hid_class_info {
-        char *classname;
-        int (*connection_func)(const char *);
-};
-
-/** Periodically check for new keyboards in /dev/class/.
+/** Try to connect to given keyboard, bypassing provided libc routines.
  *
- * @param arg Class name.
- * @return This function should never exit.
+ * @param devmap_path Path to keyboard without /dev prefix.
+ * @return Phone or error code.
  */
-static int check_new_device_fibril(void *arg)
-{
-        struct hid_class_info *dev_info = arg;
-
-        size_t index = 1;
+static int connect_keyboard_bypass(char *devmap_path)
+{
+        int devmap_phone = async_connect_me_to_blocking(PHONE_NS,
+            SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
+        if (devmap_phone < 0) {
+                return devmap_phone;
+        }
+        ipc_call_t answer;
+        aid_t req = async_send_2(devmap_phone, DEVMAP_DEVICE_GET_HANDLE,
+            0, 0,  &answer);
+
+        sysarg_t retval = async_data_write_start(devmap_phone,
+            devmap_path, str_size(devmap_path));
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
+                async_hangup(devmap_phone);
+                return retval;
+        }
+
+        async_wait_for(req, &retval);
+
+        if (retval != EOK) {
+                async_hangup(devmap_phone);
+                return retval;
+        }
+
+        devmap_handle_t handle = (devmap_handle_t) IPC_GET_ARG1(answer);
+
+        async_hangup(devmap_phone);
+
+        int phone = async_connect_me_to(PHONE_NS,
+            SERVICE_DEVMAP, DEVMAP_CONNECT_TO_DEVICE, handle);
+        if (phone < 0) {
+                return phone;
+        }
+
+        /* NB: The callback connection is slotted for removal */
+        sysarg_t phonehash;
+        sysarg_t taskhash;
+        int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, SERVICE_CONSOLE,
+            0, 0, NULL, NULL, NULL, &taskhash, &phonehash);
+        if (rc != EOK) {
+                printf(NAME ": Failed to create callback from input device\n");
+                return rc;
+        }
+
+        async_new_connection(taskhash, phonehash, 0, NULL, keyboard_events);
+
+        printf(NAME ": we got a hit (new keyboard \"/dev/%s\").\n",
+            devmap_path);
+
+        return phone;
+}
+
+
+static int check_new_keyboards(void *arg)
+{
+        char *class_name = (char *) arg;
+
+        int index = 1;
 
         while (true) {
-                async_usleep(HOTPLUG_WATCH_INTERVAL);
+                async_usleep(1 * 500 * 1000);
                 char *path;
-                int rc = asprintf(&path, "/dev/class/%s\\%zu",
-                    dev_info->classname, index);
+                int rc = asprintf(&path, "class/%s\\%d", class_name, index);
                 if (rc < 0) {
                         continue;
                 }
                 rc = 0;
-                rc = dev_info->connection_func(path);
+                rc = connect_keyboard_bypass(path);
                 if (rc > 0) {
                         /* We do not allow unplug. */
@@ -792 +831 @@
 /** Start a fibril monitoring hot-plugged keyboards.
  */
-static void check_new_devices_in_background(int (*connection_func)(const char *),
-    const char *classname)
-{
-        struct hid_class_info *dev_info = malloc(sizeof(struct hid_class_info));
-        if (dev_info == NULL) {
-                printf(NAME ": " \
-                    "out of memory, will not start hot-plug-watch fibril.\n");
-                return;
-        }
-        int rc;
-
-        rc = asprintf(&dev_info->classname, "%s", classname);
-        if (rc < 0) {
-                printf(NAME ": failed to format classname: %s.\n",
-                    str_error(rc));
-                return;
-        }
-        dev_info->connection_func = connection_func;
-
-        fid_t fid = fibril_create(check_new_device_fibril, (void *)dev_info);
+static void check_new_keyboards_in_background()
+{
+        fid_t fid = fibril_create(check_new_keyboards, (void *)"keyboard");
         if (!fid) {
-                printf(NAME
-                    ": failed to create hot-plug-watch fibril for %s.\n",
-                    classname);
+                printf(NAME ": failed to create hot-plug-watch fibril.\n");
                 return;
         }
@@ -829 +849 @@
         }
 
-        mouse_phone = connect_mouse("/dev/hid_in/mouse");
+        /* Connect to mouse device */
+        mouse_phone = -1;
+        int mouse_fd = open("/dev/hid_in/mouse", O_RDONLY);
+        
+        if (mouse_fd < 0) {
+                printf(NAME ": Notice - failed opening %s\n", "/dev/hid_in/mouse");
+                goto skip_mouse;
+        }
+        
+        mouse_phone = fd_phone(mouse_fd);
         if (mouse_phone < 0) {
-                printf(NAME ": Failed to connect to mouse device: %s.\n",
-                    str_error(mouse_phone));
-        }
+                printf(NAME ": Failed to connect to mouse device\n");
+                goto skip_mouse;
+        }
+        
+        if (async_connect_to_me(mouse_phone, SERVICE_CONSOLE, 0, 0, mouse_events)
+            != 0) {
+                printf(NAME ": Failed to create callback from mouse device\n");
+                mouse_phone = -1;
+                goto skip_mouse;
+        }
+        
+skip_mouse:
         
         /* Connect to framebuffer driver */
@@ -917 +955 @@
         
         /* Start fibril for checking on hot-plugged keyboards. */
-        check_new_devices_in_background(connect_keyboard, "keyboard");
-        check_new_devices_in_background(connect_mouse, "mouse");
+        check_new_keyboards_in_background();
 
         return true;