Changeset 1db44ea7 in mainline for uspace/lib

Timestamp:

2011-09-25T18:46:45Z (14 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

36cb22f

Parents:

dcc44ca1 (diff), f9d8c3a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes

Location:

uspace/lib

Files:

• c/arch/ia64/include/ddi.h (modified) (4 diffs)
• c/generic/adt/hash_table.c (modified) (1 diff)
• c/generic/adt/list.c (modified) (1 diff)
• c/generic/malloc.c (modified) (1 diff)
• c/generic/vfs/vfs.c (modified) (2 diffs)
• c/include/ipc/vfs.h (modified) (1 diff)
• c/include/vfs/vfs.h (modified) (1 diff)
• fs/libfs.c (modified) (1 diff)
• fs/libfs.h (modified) (1 diff)
• usbhid/src/hidpath.c (modified) (1 diff)

uspace/lib/c/arch/ia64/include/ddi.h

@@ -52 +52 @@
 static inline void pio_write_8(ioport8_t *port, uint8_t v)
 {
-        uintptr_t prt = (uintptr_t) port;
+        if (port < (ioport8_t *) IO_SPACE_BOUNDARY) {
+                uintptr_t prt = (uintptr_t) port;
 
-        *((ioport8_t *)(IA64_IOSPACE_ADDRESS +
-            ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
+                *((ioport8_t *)(IA64_IOSPACE_ADDRESS +
+                    ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
+        } else {
+                *port = v;
+        }
 
         asm volatile ("mf\n" ::: "memory");
@@ -62 +66 @@
 static inline void pio_write_16(ioport16_t *port, uint16_t v)
 {
-        uintptr_t prt = (uintptr_t) port;
+        if (port < (ioport16_t *) IO_SPACE_BOUNDARY) {
+                uintptr_t prt = (uintptr_t) port;
 
-        *((ioport16_t *)(IA64_IOSPACE_ADDRESS +
-            ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
+                *((ioport16_t *)(IA64_IOSPACE_ADDRESS +
+                    ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
+        } else {
+                *port = v;
+        }
 
         asm volatile ("mf\n" ::: "memory");
@@ -72 +80 @@
 static inline void pio_write_32(ioport32_t *port, uint32_t v)
 {
-        uintptr_t prt = (uintptr_t) port;
+        if (port < (ioport32_t *) IO_SPACE_BOUNDARY) {
+                uintptr_t prt = (uintptr_t) port;
 
-        *((ioport32_t *)(IA64_IOSPACE_ADDRESS +
-            ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
+                *((ioport32_t *)(IA64_IOSPACE_ADDRESS +
+                    ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
+        } else {
+                *port = v;
+        }
 
         asm volatile ("mf\n" ::: "memory");
@@ -82 +94 @@
 static inline uint8_t pio_read_8(ioport8_t *port)
 {
-        uintptr_t prt = (uintptr_t) port;
+        uint8_t v;
 
         asm volatile ("mf\n" ::: "memory");
 
-        return *((ioport8_t *)(IA64_IOSPACE_ADDRESS +
-            ((prt & 0xfff) | ((prt >> 2) << 12))));
+        if (port < (ioport8_t *) IO_SPACE_BOUNDARY) {
+                uintptr_t prt = (uintptr_t) port;
+
+                v = *((ioport8_t *)(IA64_IOSPACE_ADDRESS +
+                    ((prt & 0xfff) | ((prt >> 2) << 12))));
+        } else {
+                v = *port;
+        }
+
+        return v;
 }
 
 static inline uint16_t pio_read_16(ioport16_t *port)
 {
-        uintptr_t prt = (uintptr_t) port;
+        uint16_t v;
 
         asm volatile ("mf\n" ::: "memory");
 
-        return *((ioport16_t *)(IA64_IOSPACE_ADDRESS +
-            ((prt & 0xfff) | ((prt >> 2) << 12))));
+        if (port < (ioport16_t *) IO_SPACE_BOUNDARY) {
+                uintptr_t prt = (uintptr_t) port;
+
+                v = *((ioport16_t *)(IA64_IOSPACE_ADDRESS +
+                    ((prt & 0xfff) | ((prt >> 2) << 12))));
+        } else {
+                v = *port;
+        }
+
+        return v;
 }
 
 static inline uint32_t pio_read_32(ioport32_t *port)
 {
-        uintptr_t prt = (uintptr_t) port;
+        uint32_t v;
 
         asm volatile ("mf\n" ::: "memory");
 
-        return *((ioport32_t *)(IA64_IOSPACE_ADDRESS +
-            ((prt & 0xfff) | ((prt >> 2) << 12))));
+        if (port < (ioport32_t *) port) {
+                uintptr_t prt = (uintptr_t) port;
+
+                v = *((ioport32_t *)(IA64_IOSPACE_ADDRESS +
+                    ((prt & 0xfff) | ((prt >> 2) << 12))));
+        } else {
+                v = *port;
+        }
+
+        return v;
 }
 

uspace/lib/c/generic/adt/hash_table.c

@@ -190 +190 @@
 }
 
-/** Apply fucntion to all items in hash table.
+/** Apply function to all items in hash table.
  *
  * @param h   Hash table.

uspace/lib/c/generic/adt/list.c

@@ -33 +33 @@
 /**
  * @file
- * @brief       Functions completing doubly linked circular list implementaion.
+ * @brief       Functions completing doubly linked circular list implementation.
  *
  * This file contains some of the functions implementing doubly linked circular lists.

uspace/lib/c/generic/malloc.c

@@ -873 +873 @@
 void free(const void *addr)
 {
+        if (addr == NULL)
+                return;
+
         futex_down(&malloc_futex);
         

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

@@ -143 +143 @@
 
 int mount(const char *fs_name, const char *mp, const char *fqsn,
-    const char *opts, unsigned int flags)
+    const char *opts, unsigned int flags, unsigned int instance)
 {
         int null_id = -1;
@@ -181 +181 @@
 
         sysarg_t rc_orig;
-        aid_t req = async_send_2(exch, VFS_IN_MOUNT, service_id, flags, NULL);
+        aid_t req = async_send_3(exch, VFS_IN_MOUNT, service_id, flags,
+            instance, NULL);
         sysarg_t rc = async_data_write_start(exch, (void *) mpa, mpa_size);
         if (rc != EOK) {

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

@@ -56 +56 @@
         /** Unique identifier of the fs. */
         char name[FS_NAME_MAXLEN + 1];
+        unsigned int instance;
         bool concurrent_read_write;
         bool write_retains_size;

uspace/lib/c/include/vfs/vfs.h

@@ -49 +49 @@
 
 extern int mount(const char *, const char *, const char *, const char *,
-    unsigned int);
+    unsigned int, unsigned int);
 extern int unmount(const char *);
 

uspace/lib/fs/libfs.c

@@ -877 +877 @@
 }
 
+static FIBRIL_MUTEX_INITIALIZE(instances_mutex);
+static LIST_INITIALIZE(instances_list);
+
+typedef struct {
+        service_id_t service_id;
+        link_t link;
+        void *data;
+} fs_instance_t;
+
+int fs_instance_create(service_id_t service_id, void *data)
+{
+        fs_instance_t *inst = malloc(sizeof(fs_instance_t));
+        if (!inst)
+                return ENOMEM;
+
+        link_initialize(&inst->link);
+        inst->service_id = service_id;
+        inst->data = data;
+
+        fibril_mutex_lock(&instances_mutex);
+        list_foreach(instances_list, link) {
+                fs_instance_t *cur = list_get_instance(link, fs_instance_t,
+                    link);
+
+                if (cur->service_id == service_id) {
+                        fibril_mutex_unlock(&instances_mutex);
+                        free(inst);
+                        return EEXIST;
+                }
+
+                /* keep the list sorted */
+                if (cur->service_id < service_id) {
+                        list_insert_before(&inst->link, &cur->link);
+                        fibril_mutex_unlock(&instances_mutex);
+                        return EOK;
+                }
+        }
+        list_append(&inst->link, &instances_list);
+        fibril_mutex_unlock(&instances_mutex);
+
+        return EOK;
+}
+
+int fs_instance_get(service_id_t service_id, void **idp)
+{
+        fibril_mutex_lock(&instances_mutex);
+        list_foreach(instances_list, link) {
+                fs_instance_t *inst = list_get_instance(link, fs_instance_t,
+                    link);
+
+                if (inst->service_id == service_id) {
+                        *idp = inst->data;
+                        fibril_mutex_unlock(&instances_mutex);
+                        return EOK;
+                }
+        }
+        fibril_mutex_unlock(&instances_mutex);
+        return ENOENT;
+}
+
+int fs_instance_destroy(service_id_t service_id)
+{
+        fibril_mutex_lock(&instances_mutex);
+        list_foreach(instances_list, link) {
+                fs_instance_t *inst = list_get_instance(link, fs_instance_t,
+                    link);
+
+                if (inst->service_id == service_id) {
+                        list_remove(&inst->link);
+                        fibril_mutex_unlock(&instances_mutex);
+                        free(inst);
+                        return EOK;
+                }
+        }
+        fibril_mutex_unlock(&instances_mutex);
+        return ENOENT;
+}
+
 /** @}
  */

uspace/lib/fs/libfs.h

@@ -105 +105 @@
 extern void fs_node_initialize(fs_node_t *);
 
+extern int fs_instance_create(service_id_t, void *);
+extern int fs_instance_get(service_id_t, void **);
+extern int fs_instance_destroy(service_id_t);
+
 #endif
 

uspace/lib/usbhid/src/hidpath.c

@@ -76 +76 @@
                                     int32_t usage_page, int32_t usage)
 {       
-        usb_hid_report_usage_path_t *item;
-
-        if(!(item=malloc(sizeof(usb_hid_report_usage_path_t)))) {
+        usb_hid_report_usage_path_t *item
+                = malloc(sizeof(usb_hid_report_usage_path_t));
+
+        if (item == NULL) {
                 return ENOMEM;
         }