Changes in / [1c6c4092:0f31e2b] 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 (added)
• 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 (added)
• uspace/drv/usbmouse/init.c (added)
• uspace/drv/usbmouse/main.c (added)
• uspace/drv/usbmouse/mouse.c (added)
• uspace/drv/usbmouse/mouse.h (added)
• uspace/drv/usbmouse/usbmouse.ma (added)
• 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 (added)
• uspace/lib/drv/include/pci_dev_iface.h (added)
• uspace/lib/drv/include/remote_pci.h (added)
• 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
+.PHONY: all precheck cscope autotool config_auto config_default config distclean clean check distfile dist
 
 all: $(COMMON_MAKEFILE) $(COMMON_HEADER) $(CONFIG_MAKEFILE) $(CONFIG_HEADER)
@@ -64 +64 @@
 endif
 
+# Autotool (detects compiler features)
+
 $(COMMON_MAKEFILE): autotool
 $(COMMON_HEADER): autotool
@@ -70 +72 @@
         $(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
@@ -84 +88 @@
         $(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
+        rm -f $(CSCOPE).out $(COMMON_MAKEFILE) $(COMMON_HEADER) $(COMMON_HEADER_PREV) $(CONFIG_MAKEFILE) $(CONFIG_HEADER) tools/*.pyc tools/checkers/*.pyc dist/HelenOS-*
 
 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, %sp
+        save %sp, -(STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_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;
 }
 
@@ -204 +205 @@
         bootinfo.physmem_start = ofw_get_physmem_start();
         ofw_memmap(&bootinfo.memmap);
+
+        if (arch == ARCH_SUN4V)
+                sun4v_fixups();
         
         void *bootinfo_pa = ofw_translate(&bootinfo);
@@ -253 +257 @@
                 
                 /*
-                 * At this point, we claim the physical memory that we are
-                 * going to use. We should be safe in case of the virtual
+                 * 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
                  * 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].
-                 *
-                 * 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.
-                 *
+                 * SPARC binding, should restrict its use of virtual memory to
+                 * addresses from [0xffd00000; 0xffefffff] and [0xfe000000;
+                 * 0xfeffffff].
                  */
                 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,
@@ -304 +303 @@
                 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:
-        wrpr PSTATE_PRIV_BIT, %pstate
-        save %o1, -STACK_WINDOW_SAVE_AREA_SIZE, %sp
+        save %o1, -(STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_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() {
@@ -69 +139 @@
         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
         
@@ -118 +192 @@
         echo " - native C library with headers"
         echo
-        
-        show_countdown 10
 }
 
@@ -281 +353 @@
 
 show_dependencies
+check_dependecies
+show_countdown 10
 
 case "$1" in

uspace/Makefile

@@ -122 +122 @@
                 drv/usbhub \
                 drv/usbmid \
+                drv/usbmouse \
                 drv/vhc
 endif
@@ -138 +139 @@
                 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"
@@ -40 +41 @@
 static const char *cmdname = "mount";
 
-/* Dispays help for mount in various levels */
+static struct option const long_options[] = {
+        { "help", no_argument, 0, 'h' },
+        { 0, 0, 0, 0 }
+};
+
+
+/* Displays help for mount in various levels */
 void help_cmd_mount(unsigned int level)
 {
@@ -59 +66 @@
         unsigned int argc;
         const char *mopts = "";
-        int rc;
+        int rc, c, opt_ind;
 
         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.\n",
+                printf("%s: invalid number of arguments. Try `mount --help'\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"
@@ -121 +122 @@
 }
 
+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,
@@ -126 +136 @@
 };
 
-static ddf_dev_ops_t pci_fun_ops;
+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 int pci_add_device(ddf_dev_t *);
@@ -593 +615 @@
 {
         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 = {
@@ -70 +69 @@
 }
 /*----------------------------------------------------------------------------*/
-#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");
@@ -88 +89 @@
         int ret =
             pci_get_my_registers(device, &io_reg_base, &io_reg_size, &irq);
-
-        CHECK_RET_RETURN(ret,
+        CHECK_RET_FREE_HC_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_enable_interrupts(device);
-//      CHECK_RET_RETURN(ret, "Failed(%d) to get enable interrupts:\n", ret);
+        ret = pci_disable_legacy(device);
+        CHECK_RET_FREE_HC_RETURN(ret,
+            "Failed(%d) disable legacy USB: %s.\n", ret, str_error(ret));
 
-        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");
+#if 0
+        ret = pci_enable_interrupts(device);
+        if (ret != EOK) {
+                usb_log_warning(
+                    "Failed(%d) to enable interrupts, fall back to polling.\n",
+                    ret);
+        }
+#endif
 
-        ret = uhci_init(uhci_hc, device, (void*)io_reg_base, io_reg_size);
-        if (ret != EOK) {
-                usb_log_error("Failed to init uhci-hcd.\n");
-                free(uhci_hc);
-                return ret;
-        }
+        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 uhci_hc, but that does not matter since no one
+         * We might free hcd, but that does not matter since no one
          * else would access driver_data anyway.
          */
-        device->driver_data = uhci_hc;
+        device->driver_data = hcd;
+
+        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,
-            &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;
-        }
+            &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);
-        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;
+        CHECK_RET_FINI_FREE_RETURN(ret,
+            "Failed(%d) to setup UHCI root hub.\n", ret);
+        rh->driver_data = hcd->ddf_instance;
 
         ret = ddf_fun_bind(rh);
-        if (ret != EOK) {
-                usb_log_error("Failed to register root hub.\n");
-                uhci_fini(uhci_hc);
-                free(uhci_hc);
-                free(rh);
-                return ret;
-        }
+        CHECK_RET_FINI_FREE_RETURN(ret,
+            "Failed(%d) to register UHCI root hub.\n", 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"
@@ -128 +129 @@
         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;
@@ -126 +125 @@
 
         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);
 
@@ -155 +158 @@
 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);
@@ -171 +176 @@
         /* 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 */
@@ -200 +205 @@
                 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);
         }
 
@@ -249 +254 @@
         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.");
@@ -292 +300 @@
             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;
@@ -309 +317 @@
 {
         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);
@@ -340 +345 @@
         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",
@@ -353 +364 @@
                 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 );
 
-                queue_head_t* qh = instance->transfers_interrupt.queue_head;
-
-                if ((instance->frame_list[frnum] & (~0xf)) != (uintptr_t)addr_to_phys(qh)) {
+                uintptr_t expected_pa = instance->frame_list[frnum] & (~0xf);
+                uintptr_t real_pa = addr_to_phys(QH(interrupt));
+                if (expected_pa != real_pa) {
                         usb_log_debug("Interrupt QH: %p vs. %p.\n",
-                                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);
-*/
+                            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);
+                }
                 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;
-        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",
+
+        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;
-        }
-        
-        // 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;
         }
         
@@ -201 +174 @@
         
         rc = usb_endpoint_pipe_initialize_from_configuration(
-            endpoint_mapping, 1, descriptors, config_desc.total_length,
+            endpoint_mapping, 1, descriptors, descriptors_size,
             &hid_dev->wire);
         
@@ -233 +206 @@
         assert(endpoint_mapping[0].interface != NULL);
         
-        rc = usbhid_dev_get_report_descriptor(hid_dev, descriptors, transferred,
+        rc = usbhid_dev_get_report_descriptor(hid_dev,
+            descriptors, descriptors_size,
             (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);
-        assert(kbd_dev->console_phone != -1);
+        if (kbd_dev->console_phone < 0) {
+                usb_log_warning(
+                    "Connection to console not ready, key discarded.\n");
+                return;
+        }
         
         async_msg_4(kbd_dev->console_phone, KBD_EVENT, ev.type, ev.key, 

uspace/drv/usbhid/usbhid.ma

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

uspace/drv/usbhub/usbhub.c

@@ -149 +149 @@
         }
 
-        //configuration descriptor
-        /// \TODO check other configurations?
-        usb_standard_configuration_descriptor_t config_descriptor;
-        opResult = usb_request_get_bare_configuration_descriptor(
+        /* Retrieve full configuration descriptor. */
+        uint8_t *descriptors = NULL;
+        size_t descriptors_size = 0;
+        opResult = usb_request_get_full_configuration_descriptor_alloc(
             &hub->endpoints.control, 0,
-        &config_descriptor);
-        if(opResult!=EOK){
-                dprintf(USB_LOG_LEVEL_ERROR, "could not get configuration descriptor, %d",opResult);
+            (void **) &descriptors, &descriptors_size);
+        if (opResult != EOK) {
+                usb_log_error("Could not get configuration descriptor: %s.\n",
+                    str_error(opResult));
                 return opResult;
         }
-        //set configuration
+        usb_standard_configuration_descriptor_t *config_descriptor
+            = (usb_standard_configuration_descriptor_t *) descriptors;
+
+        /* Set configuration. */
         opResult = usb_request_set_configuration(&hub->endpoints.control,
-                config_descriptor.configuration_number);
-
-        if (opResult != EOK) {
-                dprintf(USB_LOG_LEVEL_ERROR,
-                                "something went wrong when setting hub`s configuration, %d",
-                                opResult);
+            config_descriptor->configuration_number);
+
+        if (opResult != EOK) {
+                usb_log_error("Failed to set hub configuration: %s.\n",
+                    str_error(opResult));
                 return opResult;
         }
         dprintf(USB_LOG_LEVEL_DEBUG, "\tused configuration %d",
-                        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;
-        }
+                        config_descriptor->configuration_number);
 
         usb_endpoint_mapping_t endpoint_mapping[1] = {
@@ -204 +185 @@
         opResult = usb_endpoint_pipe_initialize_from_configuration(
             endpoint_mapping, 1,
-            descriptors, config_descriptor.total_length,
+            descriptors, descriptors_size,
             &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.
  *
@@ -178 +126 @@
 
         size_t config_descriptor_size;
-        uint8_t *config_descriptor_raw = get_configuration_descriptor(dev, 0,
-            &config_descriptor_size);
-        if (config_descriptor_raw == NULL) {
+        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));
                 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);
@@ -77 +78 @@
                         return NULL;
                 }
-                ncwd_path_nc = malloc(cwd_size + 1 + size + 1);
+                total_size = cwd_size + 1 + size + 1;
+                ncwd_path_nc = malloc(total_size);
                 if (!ncwd_path_nc) {
                         fibril_mutex_unlock(&cwd_mutex);
                         return NULL;
                 }
-                str_cpy(ncwd_path_nc, cwd_size + 1 + size + 1, cwd_path);
+                str_cpy(ncwd_path_nc, total_size, cwd_path);
                 ncwd_path_nc[cwd_size] = '/';
                 ncwd_path_nc[cwd_size + 1] = '\0';
         } else {
-                ncwd_path_nc = malloc(size + 1);
+                total_size = size + 1;
+                ncwd_path_nc = malloc(total_size);
                 if (!ncwd_path_nc) {
                         fibril_mutex_unlock(&cwd_mutex);
@@ -93 +96 @@
                 ncwd_path_nc[0] = '\0';
         }
-        str_append(ncwd_path_nc, cwd_size + 1 + size + 1, path);
+        str_append(ncwd_path_nc, total_size, 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 = {
@@ -48 +49 @@
                 &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.
  *
@@ -504 +569 @@
  *
  * @param[in] pipe Control endpoint pipe (session must be already started).
- * @param[in] index String index (in native endianess).
+ * @param[in] index String index (in native endianess),
+ *      first index has number 1 (index from descriptors can be used directly).
  * @param[in] lang String language (in native endianess).
  * @param[out] string_ptr Where to store allocated string in native encoding.
@@ -515 +581 @@
                 return EBADMEM;
         }
-        /* Index is actually one byte value. */
-        if (index > 0xFF) {
+        /*
+         * Index is actually one byte value and zero index is used
+         * to retrieve list of supported languages.
+         */
+        if ((index < 1) || (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)
@@ -953 +959 @@
         device->name = dev_name;
         
-        /* Insert device into list of all devices
-           and into null devices array */
+        /*
+         * 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.
+         */
         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 == '_')
+        if (isalnum(ch) || 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;
@@ -811 +812 @@
         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);
@@ -1488 +1490 @@
         fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
         fs_node_t *fn;
+        fat_node_t *nodep;
         int rc;
 
@@ -1499 +1502 @@
                 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>
@@ -64 +65 @@
 #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. */
@@ -712 +715 @@
 }
 
-static int connect_keyboard(char *path)
+static int connect_keyboard_or_mouse(const char *devname,
+    async_client_conn_t handler, const char *path)
 {
         int fd = open(path, O_RDONLY);
@@ -725 +729 @@
         }
         
-        /* 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);
+        int rc = async_connect_to_me(phone, SERVICE_CONSOLE, 0, 0, handler);
         if (rc != EOK) {
-                printf(NAME ": Failed to create callback from input device\n");
+                printf(NAME ": " \
+                    "Failed to create callback from input device: %s.\n",
+                    str_error(rc));
                 return rc;
         }
         
-        async_new_connection(taskhash, phonehash, 0, NULL, keyboard_events);
-
-        printf(NAME ": we got a hit (new keyboard \"%s\").\n", path);
+        printf(NAME ": found %s \"%s\".\n", devname, path);
 
         return phone;
 }
 
-/** Try to connect to given keyboard, bypassing provided libc routines.
+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/.
  *
- * @param devmap_path Path to keyboard without /dev prefix.
- * @return Phone or error code.
+ * @param arg Class name.
+ * @return This function should never exit.
  */
-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;
+static int check_new_device_fibril(void *arg)
+{
+        struct hid_class_info *dev_info = arg;
+
+        size_t index = 1;
 
         while (true) {
-                async_usleep(1 * 500 * 1000);
+                async_usleep(HOTPLUG_WATCH_INTERVAL);
                 char *path;
-                int rc = asprintf(&path, "class/%s\\%d", class_name, index);
+                int rc = asprintf(&path, "/dev/class/%s\\%zu",
+                    dev_info->classname, index);
                 if (rc < 0) {
                         continue;
                 }
                 rc = 0;
-                rc = connect_keyboard_bypass(path);
+                rc = dev_info->connection_func(path);
                 if (rc > 0) {
                         /* We do not allow unplug. */
@@ -831 +792 @@
 /** Start a fibril monitoring hot-plugged keyboards.
  */
-static void check_new_keyboards_in_background()
-{
-        fid_t fid = fibril_create(check_new_keyboards, (void *)"keyboard");
+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);
         if (!fid) {
-                printf(NAME ": failed to create hot-plug-watch fibril.\n");
+                printf(NAME
+                    ": failed to create hot-plug-watch fibril for %s.\n",
+                    classname);
                 return;
         }
@@ -849 +829 @@
         }
 
-        /* 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);
+        mouse_phone = connect_mouse("/dev/hid_in/mouse");
         if (mouse_phone < 0) {
-                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:
+                printf(NAME ": Failed to connect to mouse device: %s.\n",
+                    str_error(mouse_phone));
+        }
         
         /* Connect to framebuffer driver */
@@ -955 +917 @@
         
         /* Start fibril for checking on hot-plugged keyboards. */
-        check_new_keyboards_in_background();
+        check_new_devices_in_background(connect_keyboard, "keyboard");
+        check_new_devices_in_background(connect_mouse, "mouse");
 
         return true;