Changes in / [e080332:5f7d96e] in mainline

Files:

• .bzrignore (modified) (1 diff)
• boot/Makefile.common (modified) (1 diff)
• kernel/arch/amd64/src/amd64.c (modified) (1 diff)
• kernel/arch/arm32/include/mach/integratorcp/integratorcp.h (modified) (1 diff)
• kernel/arch/arm32/include/mach/testarm/testarm.h (modified) (1 diff)
• kernel/arch/arm32/include/machine_func.h (modified) (1 diff)
• kernel/arch/arm32/src/mach/gta02/gta02.c (modified) (3 diffs)
• kernel/arch/arm32/src/mach/integratorcp/integratorcp.c (modified) (2 diffs)
• kernel/arch/arm32/src/mach/testarm/testarm.c (modified) (2 diffs)
• kernel/arch/ia32/src/ia32.c (modified) (1 diff)
• kernel/arch/ia64/src/ia64.c (modified) (1 diff)
• kernel/arch/mips32/src/mips32.c (modified) (1 diff)
• kernel/arch/ppc32/src/ppc32.c (modified) (1 diff)
• kernel/arch/sparc64/src/sun4u/sparc64.c (modified) (2 diffs)
• kernel/arch/sparc64/src/sun4v/sparc64.c (modified) (2 diffs)
• kernel/generic/include/ddi/irq.h (modified) (1 diff)
• kernel/generic/src/ddi/irq.c (modified) (2 diffs)
• kernel/generic/src/ipc/irq.c (modified) (4 diffs)
• uspace/Makefile (modified) (1 diff)
• uspace/app/init/init.c (modified) (3 diffs)
• uspace/app/sysinfo/Makefile (added)
• uspace/app/sysinfo/sysinfo.c (added)
• uspace/app/tester/Makefile (modified) (1 diff)
• uspace/app/tester/ipc/connect.c (deleted)
• uspace/app/tester/ipc/connect.def (deleted)
• uspace/app/tester/ipc/register.c (deleted)
• uspace/app/tester/ipc/register.def (deleted)
• uspace/app/tester/tester.c (modified) (1 diff)
• uspace/app/tester/tester.h (modified) (1 diff)
• uspace/app/tester/vfs/vfs1.c (modified) (2 diffs)
• uspace/drv/ns8250/ns8250.c (modified) (3 diffs)
• uspace/drv/pciintel/pci.c (modified) (2 diffs)
• uspace/drv/root/root.c (modified) (3 diffs)
• uspace/drv/rootpc/rootpc.c (modified) (3 diffs)
• uspace/drv/rootpc/rootpc.ma (modified) (1 diff)
• uspace/drv/usbkbd/main.c (modified) (4 diffs)
• uspace/drv/vhc/hcd.c (modified) (2 diffs)
• uspace/lib/c/generic/async_rel.c (modified) (1 diff)
• uspace/lib/c/generic/device/hw_res.c (modified) (1 diff)
• uspace/lib/c/generic/devmap.c (modified) (1 diff)
• uspace/lib/c/generic/fibril_synch.c (modified) (6 diffs)
• uspace/lib/c/include/device/hw_res.h (modified) (1 diff)
• uspace/lib/c/include/fibril_synch.h (modified) (2 diffs)
• uspace/lib/c/include/ipc/kbd.h (modified) (1 diff)
• uspace/lib/packet/generic/packet_server.c (modified) (4 diffs)
• uspace/srv/devman/devman.c (modified) (8 diffs)
• uspace/srv/devmap/devmap.c (modified) (10 diffs)
• uspace/srv/fs/devfs/devfs_ops.c (modified) (7 diffs)
• uspace/srv/hid/console/console.c (modified) (6 diffs)
• uspace/srv/net/tl/tcp/tcp.c (modified) (1 diff)
• uspace/srv/vfs/vfs_lookup.c (modified) (1 diff)

.bzrignore

@@ -52 +52 @@
 ./uspace/app/ping/ping
 ./uspace/app/redir/redir
+./uspace/app/sysinfo/sysinfo
 ./uspace/app/sbi/sbi
 ./uspace/app/stats/stats

boot/Makefile.common

@@ -144 +144 @@
         $(USPACE_PATH)/app/ping/ping \
         $(USPACE_PATH)/app/stats/stats \
+        $(USPACE_PATH)/app/sysinfo/sysinfo \
         $(USPACE_PATH)/app/tasks/tasks \
         $(USPACE_PATH)/app/top/top \

kernel/arch/amd64/src/amd64.c

@@ -199 +199 @@
 void arch_post_smp_init(void)
 {
+        /* Currently the only supported platform for amd64 is 'pc'. */
+        static const char *platform = "pc";
+
+        sysinfo_set_item_data("platform", NULL, (void *) platform,
+            str_size(platform));
+
 #ifdef CONFIG_PC_KBD
         /*

kernel/arch/arm32/include/mach/integratorcp/integratorcp.h

@@ -106 +106 @@
 extern void icp_frame_init(void);
 extern size_t icp_get_irq_count(void);
+extern const char *icp_get_platform_name(void);
 
 extern struct arm_machine_ops icp_machine_ops;

kernel/arch/arm32/include/mach/testarm/testarm.h

@@ -74 +74 @@
 extern void gxemul_frame_init(void);
 extern size_t gxemul_get_irq_count(void);
+extern const char *gxemul_get_platform_name(void);
 
 extern struct arm_machine_ops gxemul_machine_ops;

kernel/arch/arm32/include/machine_func.h

@@ -56 +56 @@
         void (*machine_input_init)(void);
         size_t (*machine_get_irq_count)(void);
+        const char *(*machine_get_platform_name)(void);
 };
 

kernel/arch/arm32/src/mach/gta02/gta02.c

@@ -71 +71 @@
 static void gta02_input_init(void);
 static size_t gta02_get_irq_count(void);
+static const char *gta02_get_platform_name(void);
 
 static void gta02_timer_irq_init(void);
@@ -92 +93 @@
         gta02_output_init,
         gta02_input_init,
-        gta02_get_irq_count
+        gta02_get_irq_count,
+        gta02_get_platform_name
 };
 
@@ -235 +237 @@
 }
 
+const char *gta02_get_platform_name(void)
+{
+        return "gta02";
+}
+
 static void gta02_timer_irq_init(void)
 {

kernel/arch/arm32/src/mach/integratorcp/integratorcp.c

@@ -65 +65 @@
         icp_output_init,
         icp_input_init,
-        icp_get_irq_count
+        icp_get_irq_count,
+        icp_get_platform_name
 };
 
@@ -342 +343 @@
 }
 
+const char *icp_get_platform_name(void)
+{
+        return "integratorcp";
+}
+
 /** @}
  */

kernel/arch/arm32/src/mach/testarm/testarm.c

@@ -65 +65 @@
         gxemul_output_init,
         gxemul_input_init,
-        gxemul_get_irq_count
+        gxemul_get_irq_count,
+        gxemul_get_platform_name
 };
 
@@ -132 +133 @@
 }
 
+const char *gxemul_get_platform_name(void)
+{
+        return "gxemul";
+}
+
 /** Starts gxemul Real Time Clock device, which asserts regular interrupts.
  *

kernel/arch/ia32/src/ia32.c

@@ -157 +157 @@
 void arch_post_smp_init(void)
 {
+        /* Currently the only supported platform for ia32 is 'pc'. */
+        static const char *platform = "pc";
+
+        sysinfo_set_item_data("platform", NULL, (void *) platform,
+            str_size(platform));
+
 #ifdef CONFIG_PC_KBD
         /*

kernel/arch/ia64/src/ia64.c

@@ -147 +147 @@
 void arch_post_smp_init(void)
 {
+        static const char *platform;
+
+        /* Set platform name. */
+#ifdef MACHINE_ski
+        platform = "pc";
+#endif
+#ifdef MACHINE_i460GX
+        platform = "i460GX";
+#endif
+        sysinfo_set_item_data("platform", NULL, (void *) platform,
+            str_size(platform));
+
 #ifdef MACHINE_ski
         ski_instance_t *ski_instance = skiin_init();

kernel/arch/mips32/src/mips32.c

@@ -168 +168 @@
 void arch_post_smp_init(void)
 {
+        static const char *platform;
+
+        /* Set platform name. */
+#ifdef MACHINE_msim
+        platform = "msim";
+#endif
+#ifdef MACHINE_bgxemul
+        platform = "gxemul";
+#endif
+#ifdef MACHINE_lgxemul
+        platform = "gxemul";
+#endif
+        sysinfo_set_item_data("platform", NULL, (void *) platform,
+            str_size(platform));
+
 #ifdef CONFIG_MIPS_KBD
         /*

kernel/arch/ppc32/src/ppc32.c

@@ -249 +249 @@
 void arch_post_smp_init(void)
 {
+        /* Currently the only supported platform for ppc32 is 'mac'. */
+        static const char *platform = "mac";
+
+        sysinfo_set_item_data("platform", NULL, (void *) platform,
+            str_size(platform));
+
         ofw_tree_walk_by_device_type("mac-io", macio_register, NULL);
 }

kernel/arch/sparc64/src/sun4u/sparc64.c

@@ -50 +50 @@
 #include <ddi/irq.h>
 #include <str.h>
+#include <sysinfo/sysinfo.h>
 
 memmap_t memmap;
@@ -111 +112 @@
 void arch_post_smp_init(void)
 {
+        /* Currently the only supported platform for sparc64/sun4u is 'sun4u'. */
+        static const char *platform = "sun4u";
+
+        sysinfo_set_item_data("platform", NULL, (void *) platform,
+            str_size(platform));
+
         standalone_sparc64_console_init();
 }

kernel/arch/sparc64/src/sun4v/sparc64.c

@@ -52 +52 @@
 #include <str.h>
 #include <arch/drivers/niagara.h>
+#include <sysinfo/sysinfo.h>
 
 memmap_t memmap;
@@ -109 +110 @@
 void arch_post_smp_init(void)
 {
+        /* Currently the only supported platform for sparc64/sun4v is 'sun4v'. */
+        static const char *platform = "sun4v";
+
+        sysinfo_set_item_data("platform", NULL, (void *) platform,
+            str_size(platform));
+
         niagarain_init();
 }

kernel/generic/include/ddi/irq.h

@@ -189 +189 @@
 extern hash_table_t irq_uspace_hash_table;
 
+extern inr_t last_inr;
+
 extern void irq_init(size_t, size_t);
 extern void irq_initialize(irq_t *);

kernel/generic/src/ddi/irq.c

@@ -136 +136 @@
 static size_t buckets;
 
+/** Last valid INR. */
+inr_t last_inr = 0;
+
 /** Initialize IRQ subsystem.
  *
@@ -145 +148 @@
 {
         buckets = chains;
+        last_inr = inrs - 1;
+
         /*
          * Be smart about the choice of the hash table operations.

kernel/generic/src/ipc/irq.c

@@ -131 +131 @@
 /** Register an answerbox as a receiving end for IRQ notifications.
  *
- * @param box     Receiving answerbox.
- * @param inr     IRQ number.
- * @param devno   Device number.
- * @param imethod Interface and method to be associated
- *                with the notification.
- * @param ucode   Uspace pointer to top-half pseudocode.
- *
- * @return EBADMEM, ENOENT or EEXISTS on failure or 0 on success.
+ * @param box           Receiving answerbox.
+ * @param inr           IRQ number.
+ * @param devno         Device number.
+ * @param imethod       Interface and method to be associated with the
+ *                      notification.
+ * @param ucode         Uspace pointer to top-half pseudocode.
+ * @return              EOK on success or a negative error code.
  *
  */
@@ -148 +147 @@
                 (sysarg_t) devno
         };
+
+        if ((inr < 0) || (inr > last_inr))
+                return ELIMIT;
         
         irq_code_t *code;
@@ -208 +210 @@
 /** Unregister task from IRQ notification.
  *
- * @param box   Answerbox associated with the notification.
- * @param inr   IRQ number.
- * @param devno Device number.
- *
+ * @param box           Answerbox associated with the notification.
+ * @param inr           IRQ number.
+ * @param devno         Device number.
+ * @return              EOK on success or a negative error code.
  */
 int ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno)
@@ -219 +221 @@
                 (sysarg_t) devno
         };
+
+        if ((inr < 0) || (inr > last_inr))
+                return ELIMIT;
         
         irq_spinlock_lock(&irq_uspace_hash_table_lock, true);

uspace/Makefile

@@ -55 +55 @@
         app/nettest2 \
         app/ping \
+        app/sysinfo \
         srv/clip \
         srv/devmap \

uspace/app/init/init.c

@@ -57 +57 @@
 #define DEVFS_MOUNT_POINT  "/dev"
 
-#define SCRATCH_FS_TYPE      "tmpfs"
-#define SCRATCH_MOUNT_POINT  "/scratch"
+#define TMPFS_FS_TYPE      "tmpfs"
+#define TMPFS_MOUNT_POINT  "/tmp"
 
 #define DATA_FS_TYPE      "fat"
@@ -235 +235 @@
 }
 
-static bool mount_scratch(void)
-{
-        int rc = mount(SCRATCH_FS_TYPE, SCRATCH_MOUNT_POINT, "", "", 0);
-        return mount_report("Scratch filesystem", SCRATCH_MOUNT_POINT,
-            SCRATCH_FS_TYPE, NULL, rc);
+static bool mount_tmpfs(void)
+{
+        int rc = mount(TMPFS_FS_TYPE, TMPFS_MOUNT_POINT, "", "", 0);
+        return mount_report("Temporary filesystem", TMPFS_MOUNT_POINT,
+            TMPFS_FS_TYPE, NULL, rc);
 }
 
@@ -271 +271 @@
         }
         
-        mount_scratch();
+        mount_tmpfs();
         
         spawn("/srv/fhc");

uspace/app/tester/Makefile

@@ -51 +51 @@
         vfs/vfs1.c \
         ipc/ping_pong.c \
-        ipc/register.c \
-        ipc/connect.c \
         loop/loop1.c \
         mm/malloc1.c \

uspace/app/tester/tester.c

@@ -60 +60 @@
 #include "vfs/vfs1.def"
 #include "ipc/ping_pong.def"
-#include "ipc/register.def"
-#include "ipc/connect.def"
 #include "loop/loop1.def"
 #include "mm/malloc1.def"

uspace/app/tester/tester.h

@@ -77 +77 @@
 extern const char *test_vfs1(void);
 extern const char *test_ping_pong(void);
-extern const char *test_register(void);
-extern const char *test_connect(void);
 extern const char *test_loop1(void);
 extern const char *test_malloc1(void);

uspace/app/tester/vfs/vfs1.c

@@ -40 +40 @@
 #include "../tester.h"
 
-#define FS_TYPE      "tmpfs"
-#define MOUNT_POINT  "/tmp"
-#define OPTIONS      ""
-#define FLAGS        0
-
-#define TEST_DIRECTORY  MOUNT_POINT "/testdir"
+#define TEST_DIRECTORY  "/tmp/testdir"
 #define TEST_FILE       TEST_DIRECTORY "/testfile"
 #define TEST_FILE2      TEST_DIRECTORY "/nextfile"
@@ -75 +70 @@
 const char *test_vfs1(void)
 {
-        if (mkdir(MOUNT_POINT, 0) != 0)
+        int rc;
+        if ((rc = mkdir(TEST_DIRECTORY, 0)) != 0) {
+                TPRINTF("rc=%d\n", rc);
                 return "mkdir() failed";
-        TPRINTF("Created directory %s\n", MOUNT_POINT);
-        
-        int rc = mount(FS_TYPE, MOUNT_POINT, "", OPTIONS, FLAGS);
-        switch (rc) {
-        case EOK:
-                TPRINTF("Mounted %s on %s\n", FS_TYPE, MOUNT_POINT);
-                break;
-        case EBUSY:
-                TPRINTF("(INFO) Filesystem already mounted on %s\n", MOUNT_POINT);
-                break;
-        default:
-                TPRINTF("(ERR) IPC returned errno %d (is tmpfs loaded?)\n", rc);
-                return "mount() failed";
         }
-        
-        if (mkdir(TEST_DIRECTORY, 0) != 0)
-                return "mkdir() failed";
         TPRINTF("Created directory %s\n", TEST_DIRECTORY);
         

uspace/drv/ns8250/ns8250.c

@@ -342 +342 @@
                 printf(NAME ": failed to connect to the parent driver of the "
                     "device %s.\n", dev->name);
-                ret = EPARTY;   /* FIXME: use another EC */
+                ret = dev->parent_phone;
                 goto failed;
         }
         
         /* Get hw resources. */
-        if (!get_hw_resources(dev->parent_phone, &hw_resources)) {
+        ret = get_hw_resources(dev->parent_phone, &hw_resources);
+        if (ret != EOK) {
                 printf(NAME ": failed to get hw resources for the device "
                     "%s.\n", dev->name);
-                ret = EPARTY;   /* FIXME: use another EC */
                 goto failed;
         }
@@ -374 +374 @@
                                 printf(NAME ": i/o range assigned to the device "
                                     "%s is too small.\n", dev->name);
-                                ret = EPARTY;   /* FIXME: use another EC */
+                                ret = ELIMIT;
                                 goto failed;
                         }
@@ -390 +390 @@
                 printf(NAME ": missing hw resource(s) for the device %s.\n",
                     dev->name);
-                ret = EPARTY;   /* FIXME: use another EC */
+                ret = ENOENT;
                 goto failed;
         }

uspace/drv/pciintel/pci.c

@@ -452 +452 @@
 static int pci_add_device(device_t *dev)
 {
+        int rc;
+
         printf(NAME ": pci_add_device\n");
         
@@ -466 +468 @@
                     "parent's driver.\n");
                 delete_pci_bus_data(bus_data);
-                return EPARTY;  /* FIXME: use another EC */
+                return dev->parent_phone;
         }
         
         hw_resource_list_t hw_resources;
         
-        if (!get_hw_resources(dev->parent_phone, &hw_resources)) {
+        rc = get_hw_resources(dev->parent_phone, &hw_resources);
+        if (rc != EOK) {
                 printf(NAME ": pci_add_device failed to get hw resources for "
                     "the device.\n");
                 delete_pci_bus_data(bus_data);
                 ipc_hangup(dev->parent_phone);
-                return EPARTY;  /* FIXME: use another EC */
+                return rc;
         }       
         

uspace/drv/root/root.c

@@ -47 +47 @@
 #include <macros.h>
 #include <inttypes.h>
+#include <sysinfo.h>
 
 #include <driver.h>
@@ -55 +56 @@
 
 #define PLATFORM_DEVICE_NAME "hw"
-#define PLATFORM_DEVICE_MATCH_ID STRING(UARCH)
+#define PLATFORM_DEVICE_MATCH_ID_FMT "platform/%s"
 #define PLATFORM_DEVICE_MATCH_SCORE 100
 
@@ -100 +101 @@
 static int add_platform_child(device_t *parent)
 {
+        char *match_id;
+        char *platform;
+        size_t platform_size;
+        int res;
+
+        /* Get platform name from sysinfo. */
+
+        platform = sysinfo_get_data("platform", &platform_size);
+        if (platform == NULL) {
+                printf(NAME ": Failed to obtain platform name.\n");
+                return ENOENT;
+        }
+
+        /* Null-terminate string. */
+        platform = realloc(platform, platform_size + 1);
+        if (platform == NULL) {
+                printf(NAME ": Memory allocation failed.\n");
+                return ENOMEM;
+        }
+
+        platform[platform_size] = '\0';
+
+        /* Construct match ID. */
+
+        if (asprintf(&match_id, PLATFORM_DEVICE_MATCH_ID_FMT, platform) == -1) {
+                printf(NAME ": Memory allocation failed.\n");
+                return ENOMEM;
+        }
+
+        /* Add child. */
+
         printf(NAME ": adding new child for platform device.\n");
         printf(NAME ":   device node is `%s' (%d %s)\n", PLATFORM_DEVICE_NAME,
-            PLATFORM_DEVICE_MATCH_SCORE, PLATFORM_DEVICE_MATCH_ID);
-        
-        int res = child_device_register_wrapper(parent, PLATFORM_DEVICE_NAME,
-            PLATFORM_DEVICE_MATCH_ID, PLATFORM_DEVICE_MATCH_SCORE,
-            NULL);
+            PLATFORM_DEVICE_MATCH_SCORE, match_id);
+
+        res = child_device_register_wrapper(parent, PLATFORM_DEVICE_NAME,
+            match_id, PLATFORM_DEVICE_MATCH_SCORE, NULL);
 
         return res;

uspace/drv/rootpc/rootpc.c

@@ -28 +28 @@
 
 /**
- * @defgroup root_pc Root HW device driver for ia32 and amd64 platform.
- * @brief HelenOS root HW device driver for ia32 and amd64 platform.
+ * @defgroup root_pc PC platform driver.
+ * @brief HelenOS PC platform driver.
  * @{
  */
@@ -182 +182 @@
         /* Register child devices. */
         if (!rootpc_add_children(dev)) {
-                printf(NAME ": failed to add child devices for platform "
-                    "ia32.\n");
+                printf(NAME ": failed to add child devices for PC platform.\n");
         }
         
@@ -196 +195 @@
 int main(int argc, char *argv[])
 {
-        printf(NAME ": HelenOS rootpc device driver\n");
+        printf(NAME ": HelenOS PC platform driver\n");
         root_pc_init();
         return driver_main(&rootpc_driver);

uspace/drv/rootpc/rootpc.ma

@@ -1 @@
-10 ia32
-10 amd64
+10 platform/pc

uspace/drv/usbkbd/main.c

@@ -29 +29 @@
 #include <driver.h>
 #include <ipc/driver.h>
+#include <ipc/kbd.h>
+#include <io/keycode.h>
+#include <io/console.h>
 #include <errno.h>
 #include <fibril.h>
@@ -41 +44 @@
 #define GUESSED_POLL_ENDPOINT 1
 
+static void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *);
+static device_ops_t keyboard_ops = {
+        .default_handler = default_connection_handler
+};
+
+static int console_callback_phone = -1;
+
+/** Default handler for IPC methods not handled by DDF.
+ *
+ * @param dev Device handling the call.
+ * @param icallid Call id.
+ * @param icall Call data.
+ */
+void default_connection_handler(device_t *dev,
+    ipc_callid_t icallid, ipc_call_t *icall)
+{
+        sysarg_t method = IPC_GET_IMETHOD(*icall);
+
+        if (method == IPC_M_CONNECT_TO_ME) {
+                int callback = IPC_GET_ARG5(*icall);
+
+                if (console_callback_phone != -1) {
+                        ipc_answer_0(icallid, ELIMIT);
+                        return;
+                }
+
+                console_callback_phone = callback;
+                ipc_answer_0(icallid, EOK);
+                return;
+        }
+
+        ipc_answer_0(icallid, EINVAL);
+}
+
+static void send_key(int key, int type, wchar_t c) {
+        async_msg_4(console_callback_phone, KBD_EVENT, type, key,
+            KM_NUM_LOCK, c);
+}
+
+static void send_alnum(int key, wchar_t c) {
+        printf(NAME ": sending key '%lc' to console\n", (wint_t) c);
+        send_key(key, KEY_PRESS, c);
+        send_key(key, KEY_RELEASE, c);
+}
+
 /*
  * Callbacks for parser
@@ -183 +231 @@
                 sizeof(usb_hid_report_in_callbacks_t));
         callbacks->keyboard = usbkbd_process_keycodes;
+
+        if (console_callback_phone != -1) {
+                static size_t counter = 0;
+                counter++;
+                if (counter > 3) {
+                        counter = 0;
+                        send_alnum(KC_A, L'a');
+                }
+        }
 
         usb_hid_parse_report(kbd_dev->parser, buffer, actual_size, callbacks, 
@@ -289 +346 @@
         fibril_add_ready(fid);
 
+        dev->ops = &keyboard_ops;
+
+        add_device_to_class(dev, "keyboard");
+
         /*
          * Hurrah, device is initialized.

uspace/drv/vhc/hcd.c

@@ -72 +72 @@
 
         /*
-         * Initialize address management.
-         */
-        address_init();
-
-        /*
          * Initialize our hub and announce its presence.
          */
@@ -108 +103 @@
         printf(NAME ": virtual USB host controller driver.\n");
 
+        /*
+         * Initialize address management.
+         */
+        address_init();
+
+        /*
+         * Run the transfer scheduler.
+         */
         hc_manager();
 
+        /*
+         * We are also a driver within devman framework.
+         */
         return driver_main(&vhc_driver);
 }

uspace/lib/c/generic/async_rel.c

@@ -239 +239 @@
                  */
 retry:
-                rel_phone = ipc_connect_me_to(key_phone, 0, 0, 0);
+                rel_phone = async_connect_me_to(key_phone, 0, 0, 0);
                 if (rel_phone >= 0) {
                         /* success, do nothing */

uspace/lib/c/generic/device/hw_res.c

@@ -38 +38 @@
 #include <malloc.h>
 
-bool get_hw_resources(int dev_phone, hw_resource_list_t *hw_resources)
+int get_hw_resources(int dev_phone, hw_resource_list_t *hw_resources)
 {
         sysarg_t count = 0;
         int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE), GET_RESOURCE_LIST, &count);
         hw_resources->count = count;
-        if (EOK != rc) {
-                return false;
-        }
+        if (rc != EOK)
+                return rc;
         
         size_t size = count * sizeof(hw_resource_t);
         hw_resources->resources = (hw_resource_t *)malloc(size);
-        if (NULL == hw_resources->resources) {
-                return false;
-        }
+        if (!hw_resources->resources)
+                return ENOMEM;
         
         rc = async_data_read_start(dev_phone, hw_resources->resources, size);
-        if (EOK != rc) {
+        if (rc != EOK) {
                 free(hw_resources->resources);
                 hw_resources->resources = NULL;
-                return false;
+                return rc;
         }
                  
-        return true;     
+        return EOK;
 }
 

uspace/lib/c/generic/devmap.c

@@ -279 +279 @@
         
         if (flags & IPC_FLAG_BLOCKING) {
-                phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,
+                phone = async_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,
                     DEVMAP_CONNECT_TO_DEVICE, handle);
         } else {
-                phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
+                phone = async_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
                     DEVMAP_CONNECT_TO_DEVICE, handle);
         }

uspace/lib/c/generic/fibril_synch.c

@@ -139 +139 @@
 static void _fibril_mutex_unlock_unsafe(fibril_mutex_t *fm)
 {
-        assert(fm->counter <= 0);
         if (fm->counter++ < 0) {
                 link_t *tmp;
@@ -165 +164 @@
 void fibril_mutex_unlock(fibril_mutex_t *fm)
 {
+        assert(fibril_mutex_is_locked(fm));
         futex_down(&async_futex);
         _fibril_mutex_unlock_unsafe(fm);
         futex_up(&async_futex);
+}
+
+bool fibril_mutex_is_locked(fibril_mutex_t *fm)
+{
+        bool locked = false;
+        
+        futex_down(&async_futex);
+        if (fm->counter <= 0) 
+                locked = true;
+        futex_up(&async_futex);
+        
+        return locked;
 }
 
@@ -230 +242 @@
 {
         futex_down(&async_futex);
-        assert(frw->readers || (frw->writers == 1));
         if (frw->readers) {
                 if (--frw->readers) {
@@ -296 +307 @@
 void fibril_rwlock_read_unlock(fibril_rwlock_t *frw)
 {
+        assert(fibril_rwlock_is_read_locked(frw));
         _fibril_rwlock_common_unlock(frw);
 }
@@ -301 +313 @@
 void fibril_rwlock_write_unlock(fibril_rwlock_t *frw)
 {
+        assert(fibril_rwlock_is_write_locked(frw));
         _fibril_rwlock_common_unlock(frw);
+}
+
+bool fibril_rwlock_is_read_locked(fibril_rwlock_t *frw)
+{
+        bool locked = false;
+
+        futex_down(&async_futex);
+        if (frw->readers)
+                locked = true;
+        futex_up(&async_futex);
+
+        return locked;
+}
+
+bool fibril_rwlock_is_write_locked(fibril_rwlock_t *frw)
+{
+        bool locked = false;
+
+        futex_down(&async_futex);
+        if (frw->writers) {
+                assert(frw->writers == 1);
+                locked = true;
+        }
+        futex_up(&async_futex);
+
+        return locked;
+}
+
+bool fibril_rwlock_is_locked(fibril_rwlock_t *frw)
+{
+        return fibril_rwlock_is_read_locked(frw) ||
+            fibril_rwlock_is_write_locked(frw);
 }
 
@@ -314 +359 @@
 {
         awaiter_t wdata;
+
+        assert(fibril_mutex_is_locked(fm));
 
         if (timeout < 0)

uspace/lib/c/include/device/hw_res.h

@@ -95 +95 @@
 
 
-bool get_hw_resources(int dev_phone, hw_resource_list_t *hw_resources);
-
-bool enable_interrupt(int dev_phone);
+extern int get_hw_resources(int, hw_resource_list_t *);
+extern bool enable_interrupt(int);
 
 

uspace/lib/c/include/fibril_synch.h

@@ -105 +105 @@
 extern bool fibril_mutex_trylock(fibril_mutex_t *);
 extern void fibril_mutex_unlock(fibril_mutex_t *);
+extern bool fibril_mutex_is_locked(fibril_mutex_t *);
 
 extern void fibril_rwlock_initialize(fibril_rwlock_t *);
@@ -111 +112 @@
 extern void fibril_rwlock_read_unlock(fibril_rwlock_t *);
 extern void fibril_rwlock_write_unlock(fibril_rwlock_t *);
+extern bool fibril_rwlock_is_read_locked(fibril_rwlock_t *);
+extern bool fibril_rwlock_is_write_locked(fibril_rwlock_t *);
+extern bool fibril_rwlock_is_locked(fibril_rwlock_t *);
 
 extern void fibril_condvar_initialize(fibril_condvar_t *);

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

@@ -39 +39 @@
 
 #include <ipc/ipc.h>
+#include <ipc/dev_iface.h>
 
 typedef enum {
-        KBD_YIELD = IPC_FIRST_USER_METHOD,
+        KBD_YIELD = DEV_FIRST_CUSTOM_METHOD,
         KBD_RECLAIM
 } kbd_request_t;

uspace/lib/packet/generic/packet_server.c

@@ -135 +135 @@
 /** Creates a new packet of dimensions at least as given.
  *
- * Should be used only when the global data are locked.
- *
  * @param[in] length    The total length of the packet, including the header,
  *                      the addresses and the data of the packet.
@@ -153 +151 @@
         packet_t *packet;
         int rc;
+
+        assert(fibril_mutex_is_locked(&ps_globals.lock));
 
         // already locked
@@ -233 +233 @@
 /** Release the packet and returns it to the appropriate free packet queue.
  *
- * Should be used only when the global data are locked.
- *
  * @param[in] packet    The packet to be released.
  *
@@ -242 +240 @@
         int index;
         int result;
+
+        assert(fibril_mutex_is_locked(&ps_globals.lock));
 
         for (index = 0; (index < FREE_QUEUES_COUNT - 1) &&

uspace/srv/devman/devman.c

@@ -392 +392 @@
         printf(NAME ": create_root_node\n");
 
+        fibril_rwlock_write_lock(&tree->rwlock);
         node = create_dev_node();
         if (node != NULL) {
@@ -401 +402 @@
                 tree->root_node = node;
         }
+        fibril_rwlock_write_unlock(&tree->rwlock);
 
         return node != NULL;
@@ -463 +465 @@
 /** Start a driver
  *
- * The driver's mutex is assumed to be locked.
- *
  * @param drv           The driver's structure.
  * @return              True if the driver's task is successfully spawned, false
@@ -473 +473 @@
         int rc;
 
+        assert(fibril_mutex_is_locked(&drv->driver_mutex));
+        
         printf(NAME ": start_driver '%s'\n", drv->name);
         
@@ -867 +869 @@
 /** Find the device node structure of the device witch has the specified handle.
  *
- * Device tree's rwlock should be held at least for reading.
- *
  * @param tree          The device tree where we look for the device node.
  * @param handle        The handle of the device.
@@ -876 +876 @@
 {
         unsigned long key = handle;
-        link_t *link = hash_table_find(&tree->devman_devices, &key);
+        link_t *link;
+        
+        assert(fibril_rwlock_is_locked(&tree->rwlock));
+        
+        link = hash_table_find(&tree->devman_devices, &key);
         return hash_table_get_instance(link, node_t, devman_link);
 }
@@ -932 +936 @@
 /** Insert new device into device tree.
  *
- * The device tree's rwlock should be already held exclusively when calling this
- * function.
- *
  * @param tree          The device tree.
  * @param node          The newly added device node. 
@@ -949 +950 @@
         assert(tree != NULL);
         assert(dev_name != NULL);
+        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
         
         node->name = dev_name;

uspace/srv/devmap/devmap.c

@@ -46 +46 @@
 #include <str.h>
 #include <ipc/devmap.h>
+#include <assert.h>
 
 #define NAME          "devmap"
@@ -208 +209 @@
 }
 
-/** Find namespace with given name.
- *
- * The devices_list_mutex should be already held when
- * calling this function.
- *
- */
+/** Find namespace with given name. */
 static devmap_namespace_t *devmap_namespace_find_name(const char *name)
 {
         link_t *item;
+        
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+        
         for (item = namespaces_list.next; item != &namespaces_list; item = item->next) {
                 devmap_namespace_t *namespace =
@@ -229 +228 @@
 /** Find namespace with given handle.
  *
- * The devices_list_mutex should be already held when
- * calling this function.
- *
  * @todo: use hash table
  *
@@ -238 +234 @@
 {
         link_t *item;
+        
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+        
         for (item = namespaces_list.next; item != &namespaces_list; item = item->next) {
                 devmap_namespace_t *namespace =
@@ -248 +247 @@
 }
 
-/** Find device with given name.
- *
- * The devices_list_mutex should be already held when
- * calling this function.
- *
- */
+/** Find device with given name. */
 static devmap_device_t *devmap_device_find_name(const char *ns_name,
     const char *name)
 {
         link_t *item;
+        
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+        
         for (item = devices_list.next; item != &devices_list; item = item->next) {
                 devmap_device_t *device =
@@ -271 +268 @@
 /** Find device with given handle.
  *
- * The devices_list_mutex should be already held when
- * calling this function.
- *
  * @todo: use hash table
  *
@@ -280 +274 @@
 {
         link_t *item;
+        
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+        
         for (item = devices_list.next; item != &devices_list; item = item->next) {
                 devmap_device_t *device =
@@ -290 +287 @@
 }
 
-/** Create a namespace (if not already present)
- *
- * The devices_list_mutex should be already held when
- * calling this function.
- *
- */
+/** Create a namespace (if not already present). */
 static devmap_namespace_t *devmap_namespace_create(const char *ns_name)
 {
-        devmap_namespace_t *namespace = devmap_namespace_find_name(ns_name);
+        devmap_namespace_t *namespace;
+        
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+        
+        namespace = devmap_namespace_find_name(ns_name);
         if (namespace != NULL)
                 return namespace;
@@ -323 +319 @@
 }
 
-/** Destroy a namespace (if it is no longer needed)
- *
- * The devices_list_mutex should be already held when
- * calling this function.
- *
- */
+/** Destroy a namespace (if it is no longer needed). */
 static void devmap_namespace_destroy(devmap_namespace_t *namespace)
 {
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+
         if (namespace->refcnt == 0) {
                 list_remove(&(namespace->namespaces));
@@ -339 +332 @@
 }
 
-/** Increase namespace reference count by including device
- *
- * The devices_list_mutex should be already held when
- * calling this function.
- *
- */
+/** Increase namespace reference count by including device. */
 static void devmap_namespace_addref(devmap_namespace_t *namespace,
     devmap_device_t *device)
 {
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+
         device->namespace = namespace;
         namespace->refcnt++;
 }
 
-/** Decrease namespace reference count
- *
- * The devices_list_mutex should be already held when
- * calling this function.
- *
- */
+/** Decrease namespace reference count. */
 static void devmap_namespace_delref(devmap_namespace_t *namespace)
 {
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+
         namespace->refcnt--;
         devmap_namespace_destroy(namespace);
 }
 
-/** Unregister device and free it
- *
- * The devices_list_mutex should be already held when
- * calling this function.
- *
- */
+/** Unregister device and free it. */
 static void devmap_device_unregister_core(devmap_device_t *device)
 {
+        assert(fibril_mutex_is_locked(&devices_list_mutex));
+
         devmap_namespace_delref(device->namespace);
         list_remove(&(device->devices));

uspace/srv/fs/devfs/devfs_ops.c

@@ -60 +60 @@
 typedef struct {
         devmap_handle_t handle;
-        int phone;
+        int phone;              /**< When < 0, the structure is incomplete. */
         size_t refcount;
         link_t link;
+        fibril_condvar_t cv;    /**< Broadcast when completed. */
 } device_t;
 
@@ -227 +228 @@
                         [DEVICES_KEY_HANDLE] = (unsigned long) node->handle
                 };
-                
+                link_t *lnk;
+
                 fibril_mutex_lock(&devices_mutex);
-                link_t *lnk = hash_table_find(&devices, key);
+restart:
+                lnk = hash_table_find(&devices, key);
                 if (lnk == NULL) {
                         device_t *dev = (device_t *) malloc(sizeof(device_t));
@@ -237 +240 @@
                         }
                         
+                        dev->handle = node->handle;
+                        dev->phone = -1;        /* mark as incomplete */
+                        dev->refcount = 1;
+                        fibril_condvar_initialize(&dev->cv);
+
+                        /*
+                         * Insert the incomplete device structure so that other
+                         * fibrils will not race with us when we drop the mutex
+                         * below.
+                         */
+                        hash_table_insert(&devices, key, &dev->link);
+
+                        /*
+                         * Drop the mutex to allow recursive devfs requests.
+                         */
+                        fibril_mutex_unlock(&devices_mutex);
+
                         int phone = devmap_device_connect(node->handle, 0);
+
+                        fibril_mutex_lock(&devices_mutex);
+
+                        /*
+                         * Notify possible waiters about this device structure
+                         * being completed (or destroyed).
+                         */
+                        fibril_condvar_broadcast(&dev->cv);
+
                         if (phone < 0) {
+                                /*
+                                 * Connecting failed, need to remove the
+                                 * entry and free the device structure.
+                                 */
+                                hash_table_remove(&devices, key, DEVICES_KEYS);
                                 fibril_mutex_unlock(&devices_mutex);
+
                                 free(dev);
                                 return ENOENT;
                         }
                         
-                        dev->handle = node->handle;
+                        /* Set the correct phone. */
                         dev->phone = phone;
-                        dev->refcount = 1;
-                        
-                        hash_table_insert(&devices, key, &dev->link);
                 } else {
                         device_t *dev = hash_table_get_instance(lnk, device_t, link);
+
+                        if (dev->phone < 0) {
+                                /*
+                                 * Wait until the device structure is completed
+                                 * and start from the beginning as the device
+                                 * structure might have entirely disappeared
+                                 * while we were not holding the mutex in
+                                 * fibril_condvar_wait().
+                                 */
+                                fibril_condvar_wait(&dev->cv, &devices_mutex);
+                                goto restart;
+                        }
+
                         dev->refcount++;
                 }
@@ -564 +609 @@
                 
                 device_t *dev = hash_table_get_instance(lnk, device_t, link);
+                assert(dev->phone >= 0);
                 
                 ipc_callid_t callid;
@@ -627 +673 @@
                 
                 device_t *dev = hash_table_get_instance(lnk, device_t, link);
+                assert(dev->phone >= 0);
                 
                 ipc_callid_t callid;
@@ -696 +743 @@
                 
                 device_t *dev = hash_table_get_instance(lnk, device_t, link);
+                assert(dev->phone >= 0);
                 dev->refcount--;
                 
@@ -743 +791 @@
                 
                 device_t *dev = hash_table_get_instance(lnk, device_t, link);
+                assert(dev->phone >= 0);
                 
                 /* Make a request at the driver */

uspace/srv/hid/console/console.c

@@ -317 +317 @@
 static void change_console(console_t *cons)
 {
-        if (cons == active_console)
+        if (cons == active_console) {
                 return;
+        }
         
         fb_pending_flush();
@@ -458 +459 @@
                         if (IPC_GET_ARG1(call) == 1) {
                                 int newcon = gcons_mouse_btn((bool) IPC_GET_ARG2(call));
-                                if (newcon != -1)
+                                if (newcon != -1) {
                                         change_console(&consoles[newcon]);
+                                }
                         }
                         retval = 0;
@@ -710 +712 @@
 }
 
-static bool console_init(char *input)
-{
-        /* Connect to input device */
-        int input_fd = open(input, O_RDONLY);
-        if (input_fd < 0) {
-                printf(NAME ": Failed opening %s\n", input);
-                return false;
-        }
-        
-        kbd_phone = fd_phone(input_fd);
-        if (kbd_phone < 0) {
+static int connect_keyboard(char *path)
+{
+        int fd = open(path, O_RDONLY);
+        if (fd < 0) {
+                return fd;
+        }
+        
+        int phone = fd_phone(fd);
+        if (phone < 0) {
                 printf(NAME ": Failed to connect to input device\n");
-                return false;
+                return phone;
         }
         
         /* NB: The callback connection is slotted for removal */
         sysarg_t phonehash;
-        if (ipc_connect_to_me(kbd_phone, SERVICE_CONSOLE, 0, 0, &phonehash) != 0) {
+        int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, SERVICE_CONSOLE,
+            0, 0, NULL, NULL, NULL, NULL, &phonehash);
+        if (rc != EOK) {
                 printf(NAME ": Failed to create callback from input device\n");
+                return rc;
+        }
+        
+        async_new_connection(phonehash, 0, NULL, keyboard_events);
+
+        printf(NAME ": we got a hit (new keyboard \"%s\").\n", path);
+
+        return phone;
+}
+
+
+static int check_new_keyboards(void *arg)
+{
+        char *class_name = (char *) arg;
+
+        int index = 1;
+
+        while (true) {
+                async_usleep(1 * 500 * 1000);
+                char *path;
+                int rc = asprintf(&path, "/dev/class/%s\\%d", class_name, index);
+                if (rc < 0) {
+                        continue;
+                }
+                rc = 0;
+                rc = connect_keyboard(path);
+                if (rc > 0) {
+                        /* We do not allow unplug. */
+                        index++;
+                }
+
+                free(path);
+        }
+
+        return EOK;
+}
+
+
+/** Start a fibril monitoring hot-plugged keyboards.
+ */
+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.\n");
+                return;
+        }
+        fibril_add_ready(fid);
+}
+
+static bool console_init(char *input)
+{
+        /* Connect to input device */
+        kbd_phone = connect_keyboard(input);
+        if (kbd_phone < 0) {
                 return false;
         }
-        
-        async_new_connection(phonehash, 0, NULL, keyboard_events);
-        
+
         /* Connect to mouse device */
         mouse_phone = -1;
@@ -749 +804 @@
         }
         
+        sysarg_t phonehash;
         if (ipc_connect_to_me(mouse_phone, SERVICE_CONSOLE, 0, 0, &phonehash) != 0) {
                 printf(NAME ": Failed to create callback from mouse device\n");
@@ -841 +897 @@
         async_set_interrupt_received(interrupt_received);
         
+        /* Start fibril for checking on hot-plugged keyboards. */
+        check_new_keyboards_in_background();
+
         return true;
 }
@@ -860 +919 @@
         if (!console_init(argv[1]))
                 return -1;
-        
+
         printf(NAME ": Accepting connections\n");
         async_manager();

uspace/srv/net/tl/tcp/tcp.c

@@ -2085 +2085 @@
         if (!fibril) {
                 free(operation_timeout);
-                return EPARTY;  /* FIXME: use another EC */
-        }
+                return ENOMEM;
+        }
+
 //      fibril_mutex_lock(&socket_data->operation.mutex);
         /* Start the timeout fibril */

uspace/srv/vfs/vfs_lookup.c

@@ -179 +179 @@
         fibril_mutex_unlock(&plb_mutex);
         
-        if (((int) rc < EOK) || (!result))
+        if ((int) rc < EOK)
                 return (int) rc;
+
+        if (!result)
+                return EOK;
         
         result->triplet.fs_handle = (fs_handle_t) rc;