flounder: making const pointers in receiving handlers, using CONST_CAST as a temporar...
authorAdam Turowski <adam.turowski@inf.ethz.ch>
Wed, 22 Feb 2017 16:00:12 +0000 (17:00 +0100)
committerAdam Turowski <adam.turowski@inf.ethz.ch>
Wed, 22 Feb 2017 16:05:07 +0000 (17:05 +0100)
Signed-off-by: Adam Turowski <adam.turowski@inf.ethz.ch>

59 files changed:
include/barrelfish/barrelfish.h
include/barrelfish/multihop_chan.h
include/hashtable/dictionary.h
include/octopus/trigger.h
include/octopus_server/service.h
lib/ahci/ahci.c
lib/barrelfish/multihop_chan.c
lib/bulk_transfer/backends/sm/buffers.c
lib/bulk_transfer/backends/sm/bulk_sm_impl.h
lib/hashtable/hashtable.c
lib/int_route/server/init.c
lib/octopus/client/handler.h
lib/octopus/client/pubsub.c
lib/octopus/client/trigger.c
lib/octopus/server/capstorage.c
lib/octopus/server/service.c
lib/posixcompat/sockets.c
lib/rcce/ring_barriers.c
lib/term/client/client_blocking.c
lib/term/server/server.c
tools/flounder/BackendCommon.hs
tools/flounder/Multihop.hs
usr/acpi/acpi.c
usr/acpi/acpi_service.c
usr/acpi/acpi_shared.h
usr/acpi/arch/x86/acpi_interrupts_arch.c
usr/acpi/arch/x86/ioapic.h
usr/acpi/arch/x86/ioapic_controller_client.c
usr/acpi/pcilnk_controller_client.c
usr/arrakismon/ps.h
usr/arrakismon/vmkitmon.c
usr/bcached/bcached.h
usr/bcached/main.c
usr/bcached/service.c
usr/drivers/e1000/e1000n.c
usr/drivers/serial/basic_service.c
usr/drivers/serial/serial.h
usr/drivers/serial/serial_kernel.c
usr/drivers/serial/serial_omap44xx.c
usr/drivers/serial/serial_pc16550d.c
usr/drivers/serial/serial_pl011.c
usr/drivers/xeon_phi/domain.c
usr/drivers/xeon_phi/interphi.c
usr/drivers/xeon_phi/xphi_service.c
usr/kaluga/start_cpu.c
usr/kaluga/start_int_ctrl.c
usr/kaluga/start_pci.c
usr/monitor/inter.c
usr/monitor/monitor_rpc_server.c
usr/monitor/multihop_support.c
usr/ramfsd/service.c
usr/skb/include/skb_server.h
usr/skb/skb_service.c
usr/spawnd/service.c
usr/tests/distops/main.c
usr/tests/idctest/idctest.c
usr/tests/multihoptest/latencytest.c
usr/tests/multihoptest/multihoptest.c
usr/vmkitmon/pc16550d.c

index 00b8833..48f9400 100644 (file)
@@ -66,4 +66,6 @@ static inline void * memdup(const void *ptr, size_t size) {
 void messages_wait_and_handle_next(void);
 void __attribute__((noreturn)) messages_handler_loop(void);
 
+typedef void *CONST_CAST;
+
 #endif
index 8b56d2e..62123de 100644 (file)
@@ -78,7 +78,7 @@ struct multihop_bind_continuation {
 
 // message receive handler
 struct multihop_receive_handler {
-    void (*handler)(void *arg, uint8_t *message, size_t length);
+    void (*handler)(void *arg, const uint8_t *message, size_t length);
     void *arg;
 };
 
index 19fd4b1..77df554 100644 (file)
@@ -33,7 +33,7 @@ struct dictionary {
     ENTRY_TYPE (*get)(struct dictionary*, const char*, size_t, void**);
     ENTRY_TYPE (*get_capability)(struct dictionary*, char*, struct capref*);
     int (*size)(struct dictionary*);
-    int (*remove)(struct dictionary*, char*, size_t);
+    int (*remove)(struct dictionary*, const char*, size_t);
 };
 
 #endif /*DICTIONARY_H_*/
index 39df6c1..ae40e41 100644 (file)
@@ -25,7 +25,7 @@
 
 #define TRIGGER_ALWAYS (OCT_PERSIST | OCT_ON_SET | OCT_ON_DEL | OCT_ALWAYS_SET)
 
-typedef void(*trigger_handler_fn)(octopus_mode_t mode, char* record, void* state);
+typedef void(*trigger_handler_fn)(octopus_mode_t mode, const char* record, void* state);
 octopus_trigger_t oct_mktrigger(errval_t, octopus_binding_type_t, octopus_mode_t,
         trigger_handler_fn, void*);
 errval_t oct_remove_trigger(octopus_trigger_id_t);
index 29e4b19..8d4fbd5 100644 (file)
@@ -57,28 +57,28 @@ struct oct_reply_state {
 
 errval_t new_oct_reply_state(struct oct_reply_state**, oct_reply_handler_fn);
 
-void get_names_handler(struct octopus_binding*, char*, octopus_trigger_t);
-void get_handler(struct octopus_binding*, char*, octopus_trigger_t);
-void set_handler(struct octopus_binding*, char*, uint64_t, octopus_trigger_t, bool);
+void get_names_handler(struct octopus_binding*, const char*, octopus_trigger_t);
+void get_handler(struct octopus_binding*, const char*, octopus_trigger_t);
+void set_handler(struct octopus_binding*, const char*, uint64_t, octopus_trigger_t, bool);
 void get_with_idcap_handler(struct octopus_binding*, struct capref,
                             octopus_trigger_t);
-void set_with_idcap_handler(struct octopus_binding*, struct capref, char*,
+void set_with_idcap_handler(struct octopus_binding*, struct capref, const char*,
                             uint64_t, octopus_trigger_t, bool);
-void del_handler(struct octopus_binding*, char*, octopus_trigger_t);
-void exists_handler(struct octopus_binding*, char*, octopus_trigger_t);
-void wait_for_handler(struct octopus_binding*, char*);
+void del_handler(struct octopus_binding*, const char*, octopus_trigger_t);
+void exists_handler(struct octopus_binding*, const char*, octopus_trigger_t);
+void wait_for_handler(struct octopus_binding*, const char*);
 void remove_trigger_handler(struct octopus_binding*, octopus_trigger_id_t);
 
-void subscribe_handler(struct octopus_binding*, char*, uint64_t, uint64_t);
-void publish_handler(struct octopus_binding*, char*);
+void subscribe_handler(struct octopus_binding*, const char*, uint64_t, uint64_t);
+void publish_handler(struct octopus_binding*, const char*);
 void unsubscribe_handler(struct octopus_binding*, uint64_t);
 
 void get_identifier(struct octopus_binding*);
 void identify_binding(struct octopus_binding*, uint64_t, octopus_binding_type_t);
 
 // Capability Storage
-void get_cap_handler(struct octopus_binding*, char*);
-void put_cap_handler(struct octopus_binding*, char*, struct capref);
-void remove_cap_handler(struct octopus_binding*, char*);
+void get_cap_handler(struct octopus_binding*, const char*);
+void put_cap_handler(struct octopus_binding*, const char*, struct capref);
+void remove_cap_handler(struct octopus_binding*, const char*);
 
 #endif /* OCTOPUS_SERVICE_H_ */
index 962d04a..b9aec3f 100644 (file)
@@ -38,7 +38,7 @@ struct mgmt_close_call_st
 };
 
 static void ahci_mgmt_identify_response_cb(struct ahci_mgmt_binding *b,
-        uint8_t *identify_data, size_t data_len)
+        const uint8_t *identify_data, size_t data_len)
 {
     struct bind_st *bst = b->st;
     struct ahci_binding *ahci_binding = bst->ahci_binding[bst->port];
@@ -52,7 +52,7 @@ static void ahci_mgmt_identify_response_cb(struct ahci_mgmt_binding *b,
     if (has_identify) {
         free(ahci_binding->identify_data);
     }
-    ahci_binding->identify_data = identify_data;
+    ahci_binding->identify_data = (CONST_CAST)identify_data;
     ahci_binding->identify_length = data_len;
     ata_identify_initialize(&ahci_binding->identify,
             (void*)ahci_binding->identify_data);
index 7b90382..1371457 100644 (file)
@@ -517,7 +517,7 @@ errval_t multihop_send_capability(struct multihop_chan *mc,
  */
 static void handle_multihop_message(struct monitor_binding *mon_closure,
         multihop_vci_t vci, uint8_t direction, uint8_t flags, uint32_t ack,
-        uint8_t *buf, size_t buflen)
+        const uint8_t *buf, size_t buflen)
 {
 
     struct multihop_chan *mc = multihop_chan_mappings_lookup(vci);
index 9ac78ba..af8a905 100644 (file)
@@ -330,7 +330,7 @@ void bulk_sm_move_rx_call(
         uint32_t                 bufferid,
         uint32_t                 tid,
         struct capref            cap,
-        uint8_t                  *meta,
+        const uint8_t            *meta,
         size_t                   metasize)
 {
     errval_t err = SYS_ERR_OK;
@@ -368,7 +368,7 @@ void bulk_sm_move_rx_call(
     //send reply & inform user
     if (err_is_ok(err)){
         if (channel->callbacks->move_received) {
-            channel->callbacks->move_received(channel, buffer, meta);
+            channel->callbacks->move_received(channel, buffer, (CONST_CAST)meta);
         }
 
         txcont = MKCONT(bulk_sm_flounder_msg_sent_debug_cb,
@@ -394,7 +394,7 @@ void bulk_sm_move_trusted_rx_call(
         bulk_ctrl_poolid_t       poolid,
         uint32_t                 bufferid,
         uint32_t                 tid,
-        uint8_t                  *meta,
+        const uint8_t            *meta,
         size_t                   metasize)
 {
     //call normal handler with a NULL_CAP
@@ -443,7 +443,7 @@ void bulk_sm_copy_rx_call(
         uint32_t                 bufferid,
         uint32_t                 tid,
         struct capref            cap,
-        uint8_t                  *meta,
+        const uint8_t            *meta,
         size_t                   metasize)
 {
     errval_t err = SYS_ERR_OK;
@@ -479,7 +479,7 @@ void bulk_sm_copy_rx_call(
 
     if (err_is_ok(err)){
         if (channel->callbacks->copy_received) {
-            channel->callbacks->copy_received(channel, buffer, meta);
+            channel->callbacks->copy_received(channel, buffer, (CONST_CAST)meta);
         }
 
         txcont = MKCONT(bulk_sm_flounder_msg_sent_debug_cb,
@@ -506,7 +506,7 @@ void bulk_sm_copy_trusted_rx_call(
         bulk_ctrl_poolid_t       poolid,
         uint32_t                 bufferid,
         uint32_t                 tid,
-        uint8_t                  *meta,
+        const uint8_t            *meta,
         size_t                   metasize)
 {
     //call normal handler with a NULL_CAP
@@ -556,7 +556,7 @@ void bulk_sm_pass_rx_call(
         uint32_t                 bufferid,
         uint32_t                 tid,
         struct capref            cap,
-        uint8_t                  *meta,
+        const uint8_t            *meta,
         size_t                   metasize)
 {
     BULK_DEBUG_PRINT("%s", "bulk_sm_pass_rx_call called\n");
@@ -596,7 +596,7 @@ void bulk_sm_pass_rx_call(
     //send reply & inform user
     if (err_is_ok(err)){
         if (channel->callbacks->buffer_received) {
-            channel->callbacks->buffer_received(channel, buffer, meta);
+            channel->callbacks->buffer_received(channel, buffer, (CONST_CAST)meta);
         }
 
         txcont = MKCONT(bulk_sm_flounder_msg_sent_debug_cb,
@@ -622,7 +622,7 @@ void bulk_sm_pass_trusted_rx_call(
         bulk_ctrl_poolid_t       poolid,
         uint32_t                 bufferid,
         uint32_t                 tid,
-        uint8_t                  *meta,
+        const uint8_t            *meta,
         size_t                   metasize)
 {
     //call normal handler with a NULL_CAP
index efac1c2..e57033a 100644 (file)
@@ -51,7 +51,7 @@ void bulk_sm_move_rx_call(
         uint32_t                 bufferid,
         uint32_t                 tid,
         struct capref            cap,
-        uint8_t                  *meta,
+        const uint8_t            *meta,
         size_t                   metasize);
 
 void bulk_sm_move_trusted_rx_call(
@@ -59,7 +59,7 @@ void bulk_sm_move_trusted_rx_call(
         bulk_ctrl_poolid_t       poolid,
         uint32_t                 bufferid,
         uint32_t                 tid,
-        uint8_t                  *meta,
+        const uint8_t            *meta,
         size_t                   metasize);
 
 void bulk_sm_move_rx_response(
@@ -73,7 +73,7 @@ void bulk_sm_copy_rx_call(
         uint32_t                 bufferid,
         uint32_t                 tid,
         struct capref            cap,
-        uint8_t                  *meta,
+        const uint8_t            *meta,
         size_t                   metasize);
 
 void bulk_sm_copy_trusted_rx_call(
@@ -81,7 +81,7 @@ void bulk_sm_copy_trusted_rx_call(
         bulk_ctrl_poolid_t       poolid,
         uint32_t                 bufferid,
         uint32_t                 tid,
-        uint8_t                  *meta,
+        const uint8_t            *meta,
         size_t                   metasize);
 
 void bulk_sm_copy_rx_response(
@@ -95,7 +95,7 @@ void bulk_sm_pass_rx_call(
         uint32_t                 bufferid,
         uint32_t                 tid,
         struct capref            cap,
-        uint8_t                  *meta,
+        const uint8_t            *meta,
         size_t                   metasize);
 
 void bulk_sm_pass_trusted_rx_call(
@@ -103,7 +103,7 @@ void bulk_sm_pass_trusted_rx_call(
         bulk_ctrl_poolid_t       poolid,
         uint32_t                 bufferid,
         uint32_t                 tid,
-        uint8_t                  *meta,
+        const uint8_t            *meta,
         size_t                   metasize);
 
 void bulk_sm_pass_rx_response(
index 02f8dfe..0555af5 100644 (file)
@@ -184,7 +184,7 @@ static ENTRY_TYPE ht_get_capability(struct dictionary *dict, char *key,
     return 0;
 }
 
-static int ht_remove(struct dictionary *dict, char *key, size_t key_len)
+static int ht_remove(struct dictionary *dict, const char *key, size_t key_len)
 {
     assert(dict != NULL);
     struct hashtable *ht = (struct hashtable*) dict;
index 7888136..eb57bbd 100644 (file)
@@ -209,7 +209,7 @@ static void driver_route_call(struct int_route_service_binding *b,
 }
 
 static void ctrl_register_controller(struct int_route_controller_binding *_binding,
-        char *label, char *class) {
+        const char *label, const char *class) {
     struct controller_driver * c = add_controller(controller_head);
     c->label = malloc(strlen(label)+1);
     assert(c->label != NULL);
index 0f951cb..cfc82f9 100644 (file)
@@ -21,8 +21,8 @@
 #include <octopus/pubsub.h>
 
 void trigger_handler(struct octopus_binding*, octopus_trigger_id_t,
-        uint64_t, octopus_mode_t, char*, uint64_t);
+        uint64_t, octopus_mode_t, const char*, uint64_t);
 void subscription_handler(struct octopus_binding*, subscription_t,
-        uint64_t, octopus_mode_t, char*, uint64_t);
+        uint64_t, octopus_mode_t, const char*, uint64_t);
 
 #endif /* OCT_HANDLER_H_ */
index 7269dc6..cb2fcf2 100644 (file)
@@ -31,7 +31,7 @@
 #include "handler.h"
 
 void subscription_handler(struct octopus_binding *b, subscription_t id,
-        uint64_t fn, octopus_mode_t mode, char *record,
+        uint64_t fn, octopus_mode_t mode, const char *record,
         uint64_t st)
 {
 
index ee9ba42..652ab01 100644 (file)
@@ -27,7 +27,7 @@
 #include "common.h"
 
 void trigger_handler(struct octopus_binding* b, octopus_trigger_id_t id,
-        uint64_t t, octopus_mode_t mode, char* record, uint64_t st)
+        uint64_t t, octopus_mode_t mode, const char* record, uint64_t st)
 {
     assert(t != 0);
 
index 68637f8..d546131 100644 (file)
@@ -53,12 +53,12 @@ static void get_cap_reply(struct octopus_binding *b,
     }
 }
 
-void get_cap_handler(struct octopus_binding *b, char *key)
+void get_cap_handler(struct octopus_binding *b, const char *key)
 {
     errval_t err, reterr = SYS_ERR_OK;
     struct capref cap;
 
-    capdb->d.get_capability(&capdb->d, key, &cap);
+    capdb->d.get_capability(&capdb->d, (CONST_CAST)key, &cap);
 
     if(capcmp(cap, NULL_CAP)) {
         reterr = OCT_ERR_CAP_NAME_UNKNOWN;
@@ -87,13 +87,13 @@ static void put_cap_reply(struct octopus_binding *b,
     }
 }
 
-void put_cap_handler(struct octopus_binding *b, char *key,
+void put_cap_handler(struct octopus_binding *b, const char *key,
                             struct capref cap)
 {
     errval_t err, reterr = SYS_ERR_OK;
     struct capref dbcap;
 
-    capdb->d.get_capability(&capdb->d, key, &dbcap);
+    capdb->d.get_capability(&capdb->d, (CONST_CAST)key, &dbcap);
     if(!capcmp(dbcap, NULL_CAP)) {
         reterr = OCT_ERR_CAP_OVERWRITE;
         err = cap_delete(cap);
@@ -101,7 +101,7 @@ void put_cap_handler(struct octopus_binding *b, char *key,
     } else {
         /* we need to make our own copy of the key */
         key = strdup(key);
-        int r = capdb->d.put_capability(&capdb->d, key, cap);
+        int r = capdb->d.put_capability(&capdb->d, (CONST_CAST)key, cap);
         assert(r == 0);
     }
 
@@ -127,12 +127,12 @@ static void remove_cap_reply(struct octopus_binding *b,
     }
 }
 
-void remove_cap_handler(struct octopus_binding *b, char *key)
+void remove_cap_handler(struct octopus_binding *b, const char *key)
 {
     errval_t err, reterr = SYS_ERR_OK;
 
     struct capref cap;
-    capdb->d.get_capability(&capdb->d, key, &cap);
+    capdb->d.get_capability(&capdb->d, (CONST_CAST)key, &cap);
     if(capcmp(cap, NULL_CAP)) {
         reterr = OCT_ERR_CAP_NAME_UNKNOWN;
     }
index d9d09e7..22a5013 100644 (file)
@@ -44,7 +44,7 @@
 
 static uint64_t current_id = 1;
 
-static inline errval_t check_query_length(char* query) {
+static inline errval_t check_query_length(const char* query) {
     if (strlen(query) >= MAX_QUERY_LENGTH) {
         return OCT_ERR_QUERY_SIZE;
     }
@@ -213,7 +213,8 @@ static void get_reply(struct octopus_binding* b, struct oct_reply_state* drt)
     }
 }
 
-void get_handler(struct octopus_binding *b, char *query, octopus_trigger_t trigger)
+void get_handler(struct octopus_binding *b, const char *query,
+                 octopus_trigger_t trigger)
 {
     errval_t err = SYS_ERR_OK;
 
@@ -262,7 +263,8 @@ static void get_names_reply(struct octopus_binding* b,
     }
 }
 
-void get_names_handler(struct octopus_binding *b, char *query, octopus_trigger_t t)
+void get_names_handler(struct octopus_binding *b, const char *query,
+                       octopus_trigger_t t)
 {
     OCT_DEBUG(" get_names_handler: %s\n", query);
 
@@ -309,7 +311,7 @@ static void set_reply(struct octopus_binding* b, struct oct_reply_state* drs)
     }
 }
 
-void set_handler(struct octopus_binding *b, char *query, uint64_t mode,
+void set_handler(struct octopus_binding *b, const char *query, uint64_t mode,
         octopus_trigger_t trigger, bool get)
 {
     OCT_DEBUG(" set_handler: %s\n", query);
@@ -350,7 +352,7 @@ out:
 }
 
 static errval_t build_query_with_idcap(char **query_p, struct capref idcap,
-                                       char *attributes)
+                                       const char *attributes)
 {
     errval_t err;
     idcap_id_t id = 0;
@@ -460,7 +462,7 @@ static void set_with_idcap_reply(struct octopus_binding *b,
 }
 
 void set_with_idcap_handler(struct octopus_binding *b, struct capref idcap,
-                            char *attributes, uint64_t mode,
+                            const char *attributes, uint64_t mode,
                             octopus_trigger_t trigger, bool get)
 {
     errval_t err;
@@ -518,7 +520,8 @@ static void del_reply(struct octopus_binding* b, struct oct_reply_state* drs)
     }
 }
 
-void del_handler(struct octopus_binding* b, char* query, octopus_trigger_t trigger)
+void del_handler(struct octopus_binding* b, const char* query,
+                 octopus_trigger_t trigger)
 {
     OCT_DEBUG(" del_handler: %s\n", query);
     errval_t err = SYS_ERR_OK;
@@ -570,7 +573,7 @@ static void exists_reply(struct octopus_binding* b, struct oct_reply_state* drs)
     }
 }
 
-void exists_handler(struct octopus_binding* b, char* query,
+void exists_handler(struct octopus_binding* b, const char* query,
         octopus_trigger_t trigger)
 {
     errval_t err = SYS_ERR_OK;
@@ -615,7 +618,7 @@ static void wait_for_reply(struct octopus_binding* b, struct oct_reply_state* dr
 }
 
 // XXX: For compatibility reasons with nameserver API
-void wait_for_handler(struct octopus_binding* b, char* query) {
+void wait_for_handler(struct octopus_binding* b, const char* query) {
     errval_t err = SYS_ERR_OK;
     errval_t set_watch_err = SYS_ERR_OK;
 
@@ -669,7 +672,7 @@ static void subscribe_reply(struct octopus_binding* b,
     }
 }
 
-void subscribe_handler(struct octopus_binding *b, char* query,
+void subscribe_handler(struct octopus_binding *b, const char* query,
         uint64_t trigger_fn, uint64_t state)
 {
     OCT_DEBUG("subscribe: query = %s\n", query);
@@ -790,7 +793,7 @@ static void publish_reply(struct octopus_binding* b, struct oct_reply_state* drs
     }
 }
 
-void publish_handler(struct octopus_binding *b, char* record)
+void publish_handler(struct octopus_binding *b, const char* record)
 {
     OCT_DEBUG("publish_handler query: %s\n", record);
     errval_t err = SYS_ERR_OK;
@@ -899,4 +902,3 @@ void identify_binding(struct octopus_binding* b, uint64_t id,
     drs->error = set_binding(type, id, b);
     drs->reply(b, drs);
 }
-
index 69b322c..107d53e 100644 (file)
@@ -460,7 +460,8 @@ int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
     return 0;
 }
 
-static void unixsock_recv(struct unixsock_binding *b, uint8_t *msg, size_t size)
+static void unixsock_recv(struct unixsock_binding *b, const uint8_t *msg,
+                          size_t size)
 {
     struct _unix_socket *us = b->st;
 
@@ -474,7 +475,7 @@ static void unixsock_recv(struct unixsock_binding *b, uint8_t *msg, size_t size)
     // Append to receive queue
     usr->next = NULL;
     usr->prev = us->recv_list_end;
-    usr->msg = msg;
+    usr->msg = (CONST_CAST)msg;
     usr->size = size;
     usr->consumed = 0;
     if(us->recv_list_end != NULL) {
index 0e7083b..22ad3b0 100644 (file)
@@ -86,12 +86,12 @@ static void message(void)
 struct msg_buf msgbuf[MAX_CPUS];
 
 static void message_request(struct rcce_binding *st, uint16_t coreid,
-                            uint8_t *msg, size_t size)
+                            const uint8_t *msg, size_t size)
 {
     assert(!msgbuf[coreid].pending);
     struct msg_buf *m = &msgbuf[coreid];
 
-    m->msg = (char *)msg;
+    m->msg = memdup(msg, size);
     m->length = size;
     m->pending = true;
     m->bulk = false;
index 10babde..7c8dccd 100644 (file)
@@ -596,7 +596,7 @@ static void handle_triggers(struct term_client *client, char *data,
     collections_list_traverse_end(client->triggers);
 }
 
-static void in_characters_handler(struct terminal_binding *b, char *data,
+static void in_characters_handler(struct terminal_binding *b, const char *data,
                                   size_t length)
 {
     struct term_client *client = b->st;
@@ -643,7 +643,7 @@ static void in_bind_cb(void *st, errval_t err, struct terminal_binding *b)
     check_connection_established(client);
 }
 
-static void out_characters_handler(struct terminal_binding *b, char *data,
+static void out_characters_handler(struct terminal_binding *b, const char *data,
                                    size_t length)
 {
     struct term_client *client = b->st;
@@ -676,7 +676,7 @@ static void out_bind_cb(void *st, errval_t err, struct terminal_binding *b)
 
 static void conf_configuration_handler(struct terminal_config_binding *b,
                                        terminal_config_option_t opt,
-                                       char *arguments)
+                                       const char *arguments)
 {
     struct term_client *client = b->st;
 
index 6fe59ff..8b143f7 100644 (file)
@@ -377,8 +377,8 @@ static void check_first_client_connected(struct term_server *server)
     server->first_client_connected = true;
 }
 
-static void in_characters_handler(struct terminal_binding *b, char *buffer,
-                                  size_t length)
+static void in_characters_handler(struct terminal_binding *b,
+                                  const char *buffer, size_t length)
 {
     struct term_server *server = b->st;
 
@@ -386,7 +386,7 @@ static void in_characters_handler(struct terminal_binding *b, char *buffer,
      * Characters arrived at the interface for incoming characters, call
      * user supplied chars_cb.
      */
-    server->chars_cb(server->st, buffer, length);
+    server->chars_cb(server->st, (CONST_CAST)buffer, length);
 }
 
 static errval_t in_connect_cb(void *st, struct terminal_binding *b)
@@ -407,8 +407,8 @@ static errval_t in_connect_cb(void *st, struct terminal_binding *b)
     return SYS_ERR_OK;
 }
 
-static void out_characters_handler(struct terminal_binding *b, char *buffer,
-                                   size_t length)
+static void out_characters_handler(struct terminal_binding *b,
+                                   const char *buffer, size_t length)
 {
     struct term_server *server = b->st;
 
@@ -449,12 +449,12 @@ static void conf_disconnect_handler(struct terminal_config_binding *b)
 
 static void conf_configuration_handler(struct terminal_config_binding *b,
                                        terminal_config_option_t opt,
-                                       char *arguments)
+                                       const char *arguments)
 {
     struct term_server *server = b->st;
 
     /* If a configuration messages arrives, call user supplied conf_cb. */
-    server->conf_cb(server->st, opt, arguments);
+    server->conf_cb(server->st, opt, (CONST_CAST)arguments);
 }
 
 static errval_t conf_connect_cb(void *st, struct terminal_config_binding *b)
index 970884b..c1193cb 100644 (file)
@@ -129,12 +129,11 @@ type_c_type ifn (Builtin Bool) = C.TypeName "bool"
 type_c_type ifn (Builtin String) = C.Ptr $ C.TypeName "char"
 type_c_type ifn t = C.TypeName $ type_c_name ifn t
 
--- TX pointers should be const
+-- pointers should be const
 type_c_type_dir :: Direction -> String -> TypeRef -> C.TypeSpec
-type_c_type_dir TX ifn tr = case type_c_type ifn tr of
+type_c_type_dir _ ifn tr = case type_c_type ifn tr of
     C.Ptr t -> C.Ptr $ C.ConstT t
     t -> t
-type_c_type_dir RX ifn tr = type_c_type ifn tr
 
 -- Array types in the msg args struct should only be pointers to the storage
 type_c_type_msgstruct :: Direction -> String -> [TypeDef] -> TypeRef -> C.TypeSpec
@@ -228,12 +227,9 @@ msg_argdecl dir ifn (Arg tr (Name n)) =
     [ C.Param (type_c_type_dir dir ifn tr) n ]
 msg_argdecl dir ifn (Arg tr (StringArray n l)) =
     [ C.Param (type_c_type_dir dir ifn tr) n ]
-msg_argdecl RX ifn (Arg tr (DynamicArray n l _)) =
-    [ C.Param (C.Ptr $ type_c_type_dir RX ifn tr) n,
+msg_argdecl dir ifn (Arg tr (DynamicArray n l _)) =
+    [ C.Param (C.Ptr $ C.ConstT $ type_c_type_dir dir ifn tr) n,
       C.Param (type_c_type_dir RX ifn size) l ]
-msg_argdecl TX ifn (Arg tr (DynamicArray n l _)) =
-    [ C.Param (C.Ptr $ C.ConstT $ type_c_type_dir TX ifn tr) n,
-      C.Param (type_c_type_dir TX ifn size) l ]
 
 
 msg_argstructdecl :: Direction -> String -> [TypeDef] -> MessageArgument -> [C.Param]
index 5945e6e..51efe46 100644 (file)
@@ -187,7 +187,7 @@ multihop_rx_handler_proto ifn = C.GVarDecl C.Extern C.NonConst
 
 multihop_rx_handler_params :: [C.Param]
 multihop_rx_handler_params = [C.Param (C.Ptr C.Void) "arg",
-                              C.Param (C.Ptr (C.TypeName "uint8_t")) "message", C.Param (C.TypeName "size_t") "message_len"]
+                              C.Param (C.Ptr (C.ConstT (C.TypeName "uint8_t"))) "message", C.Param (C.TypeName "size_t") "message_len"]
 
 multihop_connect_handler_proto :: String -> C.Unit
 multihop_connect_handler_proto ifn = C.GVarDecl C.Extern C.NonConst
@@ -837,7 +837,7 @@ rx_handler arch ifn typedefs msgdefs msgs =
       (if (contains_overflow_frags)
        then localvar m_size_type "o_frag_size" Nothing
        else C.SBlank),
-      localvar (C.Ptr $ C.TypeName "uint8_t") "msg" Nothing,
+      localvar (C.Ptr $ C.ConstT $ C.TypeName "uint8_t") "msg" Nothing,
       localvar (C.TypeName "int") "__attribute__ ((unused)) no_register" (Just $ C.NumConstant 0),
       C.SBlank,
 
index caecd9a..9d3d35f 100644 (file)
@@ -246,14 +246,14 @@ static ACPI_STATUS resource_printer(ACPI_RESOURCE *res, void *context)
 }
 #endif
 
-ACPI_STATUS acpi_eval_integer(ACPI_HANDLE handle, char *name, ACPI_INTEGER *ret)
+ACPI_STATUS acpi_eval_integer(ACPI_HANDLE handle, const char *name, ACPI_INTEGER *ret)
 {
     assert(ret != NULL);
     ACPI_STATUS as;
     char intbuf[sizeof(ACPI_OBJECT)];
     ACPI_BUFFER intbufobj = {.Length = sizeof(intbuf), .Pointer = intbuf};
 
-    as = AcpiEvaluateObjectTyped(handle, name, NULL, &intbufobj, ACPI_TYPE_INTEGER);
+    as = AcpiEvaluateObjectTyped(handle, (CONST_CAST)name, NULL, &intbufobj, ACPI_TYPE_INTEGER);
     if (ACPI_SUCCESS(as)) {
         ACPI_OBJECT *obj = intbufobj.Pointer;
         *ret = obj->Integer.Value;
index 825ef66..45e784e 100644 (file)
@@ -133,7 +133,7 @@ static void get_path_name(ACPI_HANDLE handle, char* name, size_t len)
     assert(ACPI_SUCCESS(s));
 }
 
-static void read_irq_table(struct acpi_binding* b, char* pathname,
+static void read_irq_table(struct acpi_binding* b, const char* pathname,
         acpi_pci_address_t addr, uint8_t bus)
 {
     ACPI_DEBUG("read_irq_table: (parent)%s, (%"PRIu8",%"PRIu8",%"PRIu8"), %"PRIu8"\n",
@@ -143,7 +143,7 @@ static void read_irq_table(struct acpi_binding* b, char* pathname,
     ACPI_STATUS as;
     ACPI_HANDLE handle;
 
-    as = AcpiGetHandle(NULL, pathname, &handle);
+    as = AcpiGetHandle(NULL, (CONST_CAST)pathname, &handle);
     if (ACPI_SUCCESS(as)) {
         ACPI_HANDLE child;
         err = acpi_get_irqtable_device(handle, addr, &child, bus);
@@ -171,7 +171,7 @@ static void read_irq_table(struct acpi_binding* b, char* pathname,
 
 
 
-static void set_device_irq_handler(struct acpi_binding *b, char* device, uint32_t irq)
+static void set_device_irq_handler(struct acpi_binding *b, const char* device, uint32_t irq)
 {
     errval_t err = set_device_irq(device,irq);
     err = b->tx_vtbl.set_device_irq_response(b, NOP_CONT, err);
@@ -235,7 +235,7 @@ ACPI_STATUS get_handle_handler_callback(
     return AE_OK;
 }
 
-static void get_handle_handler(struct acpi_binding *b, char *dev_id)
+static void get_handle_handler(struct acpi_binding *b, const char *dev_id)
 {
     errval_t err = SYS_ERR_OK;;
 
@@ -244,7 +244,7 @@ static void get_handle_handler(struct acpi_binding *b, char *dev_id)
     ACPI_STATUS s;
     ACPI_HANDLE handle = NULL;
 
-    s = AcpiGetDevices(NULL, get_handle_handler_callback, dev_id, &handle);
+    s = AcpiGetDevices(NULL, get_handle_handler_callback, (CONST_CAST)dev_id, &handle);
     if (ACPI_FAILURE(s)) {
         debug_printf("Looking up handle failed: %d\n", s);
         err = ACPI_ERR_INVALID_HANDLE;
@@ -255,12 +255,10 @@ static void get_handle_handler(struct acpi_binding *b, char *dev_id)
     //out uint64 handle, out errval err
     err = b->tx_vtbl.get_handle_response(b, NOP_CONT, (uint64_t)handle, err);
     assert(err_is_ok(err));
-
-    free(dev_id);
 }
 
 static void eval_integer_handler(struct acpi_binding *b,
-                                 uint64_t handle, char *path)
+                                 uint64_t handle, const char *path)
 {
     errval_t err = SYS_ERR_OK;
 
@@ -278,7 +276,6 @@ static void eval_integer_handler(struct acpi_binding *b,
 
     debug_printf("eval_integer_handler\n");
     err = b->tx_vtbl.eval_integer_response(b, NOP_CONT, val, err);
-    free(path);
 }
 
 
index b0ac22c..fffc40e 100644 (file)
@@ -30,11 +30,12 @@ errval_t find_all_apics(void);
 
 int init_all_interrupt_sources(void);
 errval_t enable_and_route_interrupt(int gsi, coreid_t dest, int vector);
-errval_t set_device_irq(char* device, uint32_t irq);
+errval_t set_device_irq(const char* device, uint32_t irq);
 
 int init_acpi(void);
 int acpi_arch_init(void);
-ACPI_STATUS acpi_eval_integer(ACPI_HANDLE handle, char *name, ACPI_INTEGER *ret);
+ACPI_STATUS acpi_eval_integer(ACPI_HANDLE handle, const char *name,
+                              ACPI_INTEGER *ret);
 errval_t acpi_get_irqtable_device(ACPI_HANDLE parent, acpi_pci_address_t device,
         ACPI_HANDLE *child, uint8_t bus);
 
index 196a274..417392a 100644 (file)
@@ -78,7 +78,7 @@ static struct ioapic *find_ioapic(uint32_t gsi)
     return NULL;
 }
 
-struct ioapic *find_ioapic_for_label(char *label)
+struct ioapic *find_ioapic_for_label(const char *label)
 {
     for(int i = 0; i < IOAPIC_MAX; i++) {
         struct ioapic *a = &ioapics[i];
@@ -223,12 +223,12 @@ int init_all_interrupt_sources(void)
                 errval_t err = oct_set(HW_PROCESSOR_X86_RECORD_FORMAT,
                                    barrelfish_id,/* hw.processor.%d */
                                    s->LapicFlags & ACPI_MADT_ENABLED, /* enabled */
-                                   barrelfish_id, /* barrelfish_id */ 
-                                   s->Id, /* hw_id */ 
-                                   CURRENT_CPU_TYPE, /* type */ 
-                                   s->ProcessorId, /* processor_id */ 
-                                   s->Id /* apic_id */ 
-                                   ); 
+                                   barrelfish_id, /* barrelfish_id */
+                                   s->Id, /* hw_id */
+                                   CURRENT_CPU_TYPE, /* type */
+                                   s->ProcessorId, /* processor_id */
+                                   s->Id /* apic_id */
+                                   );
                 assert(err_is_ok(err));
 
                 skb_add_fact("apic(%d,%d,%"PRIu32").",
index 92f5eb5..864cb4b 100644 (file)
@@ -33,6 +33,6 @@ void ioapic_setup_inti(struct ioapic *a, int inti,
 void ioapic_route_inti(struct ioapic *a, int inti, uint8_t vector,
                        uint8_t dest);
 
-struct ioapic *find_ioapic_for_label(char *label);
+struct ioapic *find_ioapic_for_label(const char *label);
 
 #endif
index 57b6374..a075796 100644 (file)
@@ -35,8 +35,8 @@
 
 
 static void add_mapping(struct int_route_controller_binding *b,
-        char *label,
-        char *class,
+        const char *label,
+        const char *class,
         int_route_controller_int_message_t from,
         int_route_controller_int_message_t to) {
 
index 2a0c7c2..cec449b 100644 (file)
  * TODO: Once everything uses the interrupt routing service,
  * this method should become static and should be called only from add_mapping
  */
-errval_t set_device_irq(char* device, uint32_t irq) {
+errval_t set_device_irq(const char* device, uint32_t irq) {
     ACPI_DEBUG("Setting link device '%s' to GSI %"PRIu32"\n", device, irq);
 
     ACPI_HANDLE source;
-    ACPI_STATUS as = AcpiGetHandle(NULL, device, &source);
+    ACPI_STATUS as = AcpiGetHandle(NULL, (CONST_CAST)device, &source);
     if (ACPI_FAILURE(as)) {
         ACPI_DEBUG("  failed lookup: %s\n", AcpiFormatException(as));
         return ACPI_ERR_INVALID_PATH_NAME;
@@ -82,8 +82,8 @@ errval_t set_device_irq(char* device, uint32_t irq) {
 }
 
 static void add_mapping(struct int_route_controller_binding *b,
-        char *label,
-        char *class,
+        const char *label,
+        const char *class,
         int_route_controller_int_message_t from,
         int_route_controller_int_message_t to) {
 
index 3b9d173..d332bba 100644 (file)
@@ -29,7 +29,7 @@ struct ps_waiter {
 
 struct ps_entry {
     char *argv[MAX_CMDLINE_ARGS];
-    char *argbuf;
+    const char *argbuf;
     size_t argbytes;
     struct capref rootcn_cap, dcb;
     struct cnoderef rootcn;
index 71f0588..60230f9 100644 (file)
@@ -30,8 +30,8 @@
 
 #define SERVICE_BASENAME    "arrakis" // the core ID is appended to this
 
-static errval_t spawn_arrakis(char *path, char *const argv[], char *argbuf,
-                             size_t argbytes, char *const envp[], 
+static errval_t spawn_arrakis(const char *path, char *const argv[], const char *argbuf,
+                             size_t argbytes, char *const envp[],
                              struct capref inheritcn_cap, struct capref argcn_cap,
                              domainid_t *domainid)
 {
@@ -55,7 +55,7 @@ static errval_t spawn_arrakis(char *path, char *const argv[], char *argbuf,
     uint8_t *image = malloc(info.size);
     if (image == NULL) {
         vfs_close(fh);
-        return err_push(err, SPAWN_ERR_LOAD);        
+        return err_push(err, SPAWN_ERR_LOAD);
     }
 
     size_t pos = 0, readlen;
@@ -80,7 +80,7 @@ static errval_t spawn_arrakis(char *path, char *const argv[], char *argbuf,
     }
 
     // find short name (last part of path)
-    char *name = strrchr(path, VFS_PATH_SEP);
+    const char *name = strrchr(path, VFS_PATH_SEP);
     if (name == NULL) {
         name = path;
     } else {
@@ -153,7 +153,7 @@ static errval_t spawn_arrakis(char *path, char *const argv[], char *argbuf,
     struct ps_entry *pe = malloc(sizeof(struct ps_entry));
     assert(pe != NULL);
     memset(pe, 0, sizeof(struct ps_entry));
-    memcpy(pe->argv, argv, MAX_CMDLINE_ARGS*sizeof(*argv));
+    memcpy(pe->argv, (CONST_CAST)argv, MAX_CMDLINE_ARGS*sizeof(*argv));
     pe->argbuf = argbuf;
     pe->argbytes = argbytes;
     /*
@@ -209,7 +209,7 @@ static void retry_spawn_domain_response(void *a)
 
     if (err_no(err) == FLOUNDER_ERR_TX_BUSY) {
         // try again
-        err = b->register_send(b, get_default_waitset(), 
+        err = b->register_send(b, get_default_waitset(),
                                MKCONT(retry_spawn_domain_response,a));
     }
     if (err_is_fail(err)) {
@@ -227,12 +227,12 @@ static errval_t spawn_reply(struct arrakis_binding *b, errval_t rerr,
  
     err = b->tx_vtbl.spawn_arrakis_domain_response(b, NOP_CONT, rerr, domainid);
 
-    if (err_is_fail(err)) { 
+    if (err_is_fail(err)) {
         DEBUG_ERR(err, "error sending spawn_domain reply\n");
 
         if (err_no(err) == FLOUNDER_ERR_TX_BUSY) {
             // this will be freed in the retry handler
-            struct pending_spawn_response *sr = 
+            struct pending_spawn_response *sr =
                 malloc(sizeof(struct pending_spawn_response));
             if (sr == NULL) {
                 return LIB_ERR_MALLOC_FAIL;
@@ -240,7 +240,7 @@ static errval_t spawn_reply(struct arrakis_binding *b, errval_t rerr,
             sr->b = b;
             sr->err = rerr;
             sr->domainid = domainid;
-            err = b->register_send(b, get_default_waitset(), 
+            err = b->register_send(b, get_default_waitset(),
                                    MKCONT(retry_spawn_domain_response, sr));
             if (err_is_fail(err)) {
                 // note that only one continuation may be registered at a time
@@ -255,9 +255,9 @@ static errval_t spawn_reply(struct arrakis_binding *b, errval_t rerr,
 }
 
 
-static void spawn_with_caps_handler(struct arrakis_binding *b, char *path,
-                                    char *argbuf, size_t argbytes,
-                                    char *envbuf, size_t envbytes,
+static void spawn_with_caps_handler(struct arrakis_binding *b, const char *path,
+                                    const char *argbuf, size_t argbytes,
+                                    const char *envbuf, size_t envbytes,
                                     struct capref inheritcn_cap,
                                     struct capref argcn_cap)
 {
@@ -267,11 +267,11 @@ static void spawn_with_caps_handler(struct arrakis_binding *b, char *path,
     /* printf("arrakismon: spawning '%s'\n", path); */
 
     /* extract arguments from buffer */
-    char *argv[MAX_CMDLINE_ARGS + 1];
+    char * argv[MAX_CMDLINE_ARGS + 1];
     int i = 0;
     size_t pos = 0;
     while (pos < argbytes && i < MAX_CMDLINE_ARGS) {
-        argv[i++] = &argbuf[pos];
+        argv[i++] = (CONST_CAST)argbuf + pos;
         char *end = memchr(&argbuf[pos], '\0', argbytes - pos);
         if (end == NULL) {
             err = SPAWN_ERR_GET_CMDLINE_ARGS;
@@ -287,7 +287,7 @@ static void spawn_with_caps_handler(struct arrakis_binding *b, char *path,
     i = 0;
     pos = 0;
     while (pos < envbytes && i < MAX_CMDLINE_ARGS) {
-        envp[i++] = &envbuf[pos];
+        envp[i++] = (CONST_CAST)envbuf + pos;
         char *end = memchr(&envbuf[pos], '\0', envbytes - pos);
         if (end == NULL) {
             err = SPAWN_ERR_GET_CMDLINE_ARGS;
@@ -298,9 +298,11 @@ static void spawn_with_caps_handler(struct arrakis_binding *b, char *path,
     assert(i <= MAX_CMDLINE_ARGS);
     envp[i] = NULL;
 
-    vfs_path_normalise(path);
+    char *npath = alloca(strlen(path));
+    strcpy(npath, path);
+    vfs_path_normalise(npath);
 
-    err = spawn_arrakis(path, argv, argbuf, argbytes, envp, inheritcn_cap,
+    err = spawn_arrakis(npath, argv, argbuf, argbytes, envp, inheritcn_cap,
                        argcn_cap, &domainid);
     if (!capref_is_null(inheritcn_cap)) {
         errval_t err2;
@@ -315,7 +317,6 @@ static void spawn_with_caps_handler(struct arrakis_binding *b, char *path,
 
  finish:
     if(err_is_fail(err)) {
-        free(argbuf);
         DEBUG_ERR(err, "spawn");
     }
 
@@ -325,14 +326,11 @@ static void spawn_with_caps_handler(struct arrakis_binding *b, char *path,
         // not much we can do about this
         DEBUG_ERR(err, "while sending reply in spawn_handler");
     }
-
-    free(envbuf);
-    free(path);
 }
 
 
-static void spawn_handler(struct arrakis_binding *b, char *path, char *argbuf,
-                          size_t argbytes, char *envbuf, size_t envbytes)
+static void spawn_handler(struct arrakis_binding *b, const char *path, const char *argbuf,
+                          size_t argbytes, const char *envbuf, size_t envbytes)
 {
     spawn_with_caps_handler(b, path, argbuf, argbytes, envbuf, envbytes,
                             NULL_CAP, NULL_CAP);
index c51b70b..1419eda 100644 (file)
@@ -37,9 +37,9 @@ typedef enum {
     KEY_MISSING,
     KEY_INTRANSIT
 } key_state_t;
-key_state_t cache_lookup(char *key, size_t key_len, uintptr_t *index, uintptr_t *length);
+key_state_t cache_lookup(const char *key, size_t key_len, uintptr_t *index, uintptr_t *length);
 
-uintptr_t cache_allocate(char *key, size_t key_len);
+uintptr_t cache_allocate(const char *key, size_t key_len);
 void cache_update(uintptr_t index, uintptr_t length);
 
 void cache_register_wait(uintptr_t index, void *b);
index 8d68ca8..8e24c83 100644 (file)
@@ -121,7 +121,7 @@ uint64_t cache_get_block_length(uintptr_t idx)
     return l->block_length;
 }
 
-key_state_t cache_lookup(char *key, size_t key_len,
+key_state_t cache_lookup(const char *key, size_t key_len,
                          uintptr_t *idx, uintptr_t *length)
 {
     ENTRY_TYPE et;
@@ -201,7 +201,7 @@ cache_get_next_waiter(uintptr_t idx)
     return ret;
 }
 
-uintptr_t cache_allocate(char *key, size_t key_len)
+uintptr_t cache_allocate(const char *key, size_t key_len)
 {
     struct lru_queue *e = lru_get();
 
@@ -224,7 +224,8 @@ uintptr_t cache_allocate(char *key, size_t key_len)
 
     e->in_use = true;
     e->in_transit = true;
-    e->key = key;
+    e->key = strdup(key);
+    assert(e->key);
     e->key_len = key_len;
     e->block_length = 0;
     e->waiters.start = e->waiters.end = NULL;
index f4995cc..e9fe968 100644 (file)
@@ -33,7 +33,8 @@ static bool inwrite[NUM_BLOCKS];
 static struct bcache_binding *waiting[NUM_BLOCKS];
 #endif
 
-static void get_start_handler(struct bcache_binding *b, char *key, size_t key_len)
+static void get_start_handler(struct bcache_binding *b, const char *key,
+                              size_t key_len)
 {
     errval_t err;
     key_state_t ks;
@@ -44,13 +45,11 @@ static void get_start_handler(struct bcache_binding *b, char *key, size_t key_le
     ks = cache_lookup(key, key_len, &idx, &length);
 
     if (ks == KEY_INTRANSIT) { // key is in transit: wait for it!
-        free(key);
         cache_register_wait(idx, b);
         return; // get_start_response() will be called when key arrives
     } else if (ks == KEY_MISSING) {
         idx = cache_allocate(key, key_len);
     } else if (ks == KEY_EXISTS) {
-        free(key);
     } else {
         assert(0);
     }
index 3d170d6..5b2e703 100644 (file)
@@ -791,7 +791,7 @@ static void exit_help(const char *program)
 }
 
 
-static void check_possible_e1000_card(octopus_mode_t mode, char *record, void *st)
+static void check_possible_e1000_card(octopus_mode_t mode, const char *record, void *st)
 {
     errval_t err;
     if (mode & OCT_ON_SET) {
@@ -826,8 +826,6 @@ static void check_possible_e1000_card(octopus_mode_t mode, char *record, void *s
         }
 
     }
-
-    free(record);
 }
 
 
@@ -1048,7 +1046,7 @@ int e1000n_driver_init(int argc, char **argv)
             // nonblocking. Need to call test_instr_periodic
             // for testing. Maybe a dedicated thread
             // would be nicer.
-            err = event_dispatch_non_block(ws); 
+            err = event_dispatch_non_block(ws);
             test_instr_periodic(&e1000_device);
 #else
             err = event_dispatch(ws);
index 14fee94..ee7d3cc 100644 (file)
@@ -81,7 +81,7 @@ static void basic_serial_input(char *data, size_t length)
     }
 }
 
-static void output_handler(struct serial_binding *b, char *c, size_t len)
+static void output_handler(struct serial_binding *b, const char *c, size_t len)
 {
     serial_write(c, len);
 }
index f6476bc..8e4e0a8 100644 (file)
@@ -35,7 +35,7 @@ struct serial_params {
 
 typedef void serial_input_fn_t(char *data, size_t length);
 
-void serial_write(char *c, size_t len);
+void serial_write(const char *c, size_t len);
 errval_t serial_init(struct serial_params *params);
 void start_service(void);
 void start_basic_service(char *driver_name);
index ab59c0a..04d2cf5 100644 (file)
@@ -48,7 +48,7 @@ errval_t serial_init(struct serial_params *params)
 }
 
 
-void serial_write(char *c, size_t len)
+void serial_write(const char *c, size_t len)
 {
     sys_print(c, len);
 }
index 75ad184..70bd2cf 100644 (file)
@@ -254,7 +254,7 @@ static void serial_putchar(char c)
 }
 
 /** write string to serial port */
-void serial_write(char *c, size_t len)
+void serial_write(const char *c, size_t len)
 {
     for (int i = 0; i < len; i++) {
         serial_putchar(c[i]);
index add619a..defc388 100644 (file)
@@ -115,7 +115,7 @@ static void serial_putc(char c)
     pc16550d_thr_wr(&uart, c);
 }
 
-void serial_write(char *c, size_t len)
+void serial_write(const char *c, size_t len)
 {
     for (int i = 0; i < len; i++) {
         serial_putc(c[i]);
index 3512f84..6b1159b 100644 (file)
@@ -121,7 +121,7 @@ serial_putc(char c) {
 }
 
 void
-serial_write(char *c, size_t len) {
+serial_write(const char *c, size_t len) {
     for (int i = 0; i < len; i++) {
         serial_putc(c[i]);
     }
index f9186d9..6a6a444 100644 (file)
@@ -33,7 +33,7 @@ struct wait_state
 };
 
 static void domain_wait_trigger_handler(octopus_mode_t mode,
-                                        char* record,
+                                        const char* record,
                                         void* state)
 {
     errval_t err;
@@ -196,4 +196,3 @@ errval_t domain_register(const char *iface,
 
     return err;
 }
-
index 4be9a98..aaf3930 100644 (file)
@@ -410,7 +410,7 @@ static errval_t chan_open_response_tx(struct txq_msg_st *msg_st)
  */
 
 static void domain_wait_call_rx(struct interphi_binding *_binding,
-                                char *name,
+                                const char *name,
                                 size_t length,
                                 uintptr_t state)
 {
@@ -451,7 +451,6 @@ static void domain_wait_call_rx(struct interphi_binding *_binding,
             txq_send(msg_st);
         break;
     }
-    free(name);
 #endif
 }
 
@@ -473,7 +472,7 @@ static void domain_wait_response_rx(struct interphi_binding *_binding,
 }
 
 static void domain_lookup_call_rx(struct interphi_binding *_binding,
-                                  char *name,
+                                  const char *name,
                                   size_t length)
 {
 #ifdef __k1om__
@@ -498,8 +497,6 @@ static void domain_lookup_call_rx(struct interphi_binding *_binding,
 
     msg_st->err = domain_lookup(name, &st->args.domain.domid);
 
-    free(name);
-
     txq_send(msg_st);
 #endif
 }
@@ -522,7 +519,7 @@ static void domain_lookup_response_rx(struct interphi_binding *_binding,
 }
 
 static void domain_register_call_rx(struct interphi_binding *_binding,
-                                    char *name,
+                                    const char *name,
                                     size_t length,
                                     xphi_dom_id_t domid)
 {
@@ -548,8 +545,6 @@ static void domain_register_call_rx(struct interphi_binding *_binding,
 
     msg_st->err = domain_register(name, domid);
 
-    free(name);
-
     txq_send(msg_st);
 #endif
 }
@@ -571,7 +566,7 @@ static void domain_register_response_rx(struct interphi_binding *_binding,
 
 static void spawn_call_rx(struct interphi_binding *_binding,
                           uint8_t core,
-                          char *cmdline,
+                          const char *cmdline,
                           size_t length,
                           uint8_t flags)
 {
@@ -592,7 +587,7 @@ static void spawn_call_rx(struct interphi_binding *_binding,
     msg_st->cleanup = NULL;
 
     char *argv[MAX_CMDLINE_ARGS+1];
-    msg_st->err = spawn_cmdline_extract_argv(cmdline, length, argv, MAX_CMDLINE_ARGS);
+    msg_st->err = spawn_cmdline_extract_argv((CONST_CAST)cmdline, length, argv, MAX_CMDLINE_ARGS);
     if (err_is_fail(msg_st->err)) {
         txq_send(msg_st);
         return;
@@ -617,9 +612,6 @@ static void spawn_call_rx(struct interphi_binding *_binding,
         st->args.spawn_reply.domainid = xeon_phi_domain_build_id(phi->id, core,
                                                                  is_host, domid);
     }
-
-    free(cmdline);
-
     txq_send(msg_st);
 }
 
@@ -638,7 +630,7 @@ static void spawn_response_rx(struct interphi_binding *_binding,
 
 static void spawn_with_cap_call_rx(struct interphi_binding *_binding,
                                    uint8_t core,
-                                   char *cmdline,
+                                   const char *cmdline,
                                    size_t length,
                                    uint8_t flags,
                                    uint64_t cap_base,
@@ -661,7 +653,7 @@ static void spawn_with_cap_call_rx(struct interphi_binding *_binding,
     msg_st->cleanup = NULL;
 
     char *argv[MAX_CMDLINE_ARGS+1];
-    msg_st->err = spawn_cmdline_extract_argv(cmdline, length, argv, MAX_CMDLINE_ARGS);
+    msg_st->err = spawn_cmdline_extract_argv((CONST_CAST)cmdline, length, argv, MAX_CMDLINE_ARGS);
     if (err_is_fail(msg_st->err)) {
         txq_send(msg_st);
         return;
@@ -689,9 +681,6 @@ static void spawn_with_cap_call_rx(struct interphi_binding *_binding,
                         XEON_PHI_DOMAIN_HOST, core, 1, domid);
 #endif
     }
-
-    free(cmdline);
-
     txq_send(msg_st);
 }
 
index 2a4d075..6c8adfe 100644 (file)
@@ -194,7 +194,7 @@ static errval_t domain_wait_response_tx(struct txq_msg_st* msg_st)
  */
 
 static void domain_lookup_call_rx(struct xeon_phi_binding *binding,
-                                  char *name,
+                                  const char *name,
                                   size_t length)
 {
     XSERVICE_DEBUG("domain_lookup_call_rx: %s\n", name);
@@ -212,15 +212,13 @@ static void domain_lookup_call_rx(struct xeon_phi_binding *binding,
 
     struct xphi_svc_msg_st *st = (struct xphi_svc_msg_st *) msg_st;
 
-    msg_st->err = interphi_domain_lookup(&phi->topology[phi->id], name,
+    msg_st->err = interphi_domain_lookup(&phi->topology[phi->id], (CONST_CAST)name,
                                          &st->args.domain.domid);
-    free(name);
-
     txq_send(msg_st);
 }
 
 static void domain_wait_call_rx(struct xeon_phi_binding *binding,
-                                char *name,
+                                const char *name,
                                 size_t length)
 {
     XSERVICE_DEBUG("domain_wait_call_rx: %s\n", name);
@@ -235,17 +233,14 @@ static void domain_wait_call_rx(struct xeon_phi_binding *binding,
 
     /* TODO: allocate reply state */
 
-    msg_st->err = interphi_domain_wait(&phi->topology[phi->id], name, svc_st);
+    msg_st->err = interphi_domain_wait(&phi->topology[phi->id], (CONST_CAST)name, svc_st);
     if (err_is_fail(msg_st->err)) {
         txq_send(msg_st);
     }
-
-    free(name);
-
 }
 
 static void domain_register_call_rx(struct xeon_phi_binding *binding,
-                                    char *name,
+                                    const char *name,
                                     size_t length,
                                     xphi_dom_id_t domid)
 {
@@ -262,7 +257,7 @@ static void domain_register_call_rx(struct xeon_phi_binding *binding,
     msg_st->cleanup = NULL;
 
     svc_st->domainid = domid;
-    svc_st->name = name;
+    svc_st->name = (CONST_CAST)name;
 
 #ifdef __k1om__
     struct xeon_phi *phi = svc_st->phi;
@@ -270,16 +265,13 @@ static void domain_register_call_rx(struct xeon_phi_binding *binding,
 #else
     msg_st->err = domain_register(name, domid);
 #endif
-
-    free(name);
-
     txq_send(msg_st);
 }
 
 static void domain_init_call_rx(struct xeon_phi_binding *binding,
                                 domainid_t domain,
                                 coreid_t core,
-                                char *name,
+                                const char *name,
                                 size_t length)
 {
     XSERVICE_DEBUG("domain_init_call_rx: %s @ domainid:%"PRIuDOMAINID"\n", name,
@@ -317,9 +309,6 @@ static void domain_init_call_rx(struct xeon_phi_binding *binding,
     msg_st->err = domain_register(svc_st->name, svc_st->domainid);
 #endif
     xphi_svc_clients_insert(svc_st);
-
-    free(name);
-
     txq_send(msg_st);
 }
 
@@ -393,7 +382,7 @@ static void kill_call_rx(struct xeon_phi_binding *binding,
 static void spawn_with_cap_call_rx(struct xeon_phi_binding *binding,
                                    uint8_t xid,
                                    uint8_t core,
-                                   char *cmdline,
+                                   const char *cmdline,
                                    size_t length,
                                    uint8_t flags,
                                    struct capref cap)
@@ -417,18 +406,16 @@ static void spawn_with_cap_call_rx(struct xeon_phi_binding *binding,
 #else
     struct xnode *node = &svc_st->phi->topology[svc_st->phi->id];
 #endif
-    msg_st->err = interphi_spawn_with_cap(node, core, cmdline, length, flags, cap,
+    msg_st->err = interphi_spawn_with_cap(node, core, (CONST_CAST)cmdline, length,
+                                          flags, cap,
                                           &xphi_st->args.spawn.domainid);
-
-    free(cmdline);
-
     txq_send(msg_st);
 }
 
 static void spawn_call_rx(struct xeon_phi_binding *binding,
                           uint8_t xid,
                           uint8_t core,
-                          char *cmdline,
+                          const char *cmdline,
                           size_t length,
                           uint8_t flags)
 {
@@ -451,11 +438,8 @@ static void spawn_call_rx(struct xeon_phi_binding *binding,
 #else
     struct xnode *node = &svc_st->phi->topology[svc_st->phi->id];
 #endif
-    msg_st->err = interphi_spawn(node, core, cmdline, length, flags,
+    msg_st->err = interphi_spawn(node, core, (CONST_CAST)cmdline, length, flags,
                                  &xphi_st->args.spawn.domainid);
-
-    free(cmdline);
-
     txq_send(msg_st);
 }
 
index 013e6eb..cfa2a29 100644 (file)
@@ -33,7 +33,7 @@
 
 static const char *processor_regex = HW_PROCESSOR_GENERIC_REGEX;
 
-static void cpu_change_event(octopus_mode_t mode, char* record, void* state)
+static void cpu_change_event(octopus_mode_t mode, const char* record, void* state)
 {
     if (mode & OCT_ON_SET) {
         KALUGA_DEBUG("CPU found: %s\n", record);
@@ -52,7 +52,7 @@ static void cpu_change_event(octopus_mode_t mode, char* record, void* state)
         /* find the corectrl module for the given cpu type */
         struct module_info* mi = find_corectrl_for_cpu_type((enum cpu_type)type);
         if (mi != NULL) {
-            err = mi->start_function(0, mi, record, NULL);
+            err = mi->start_function(0, mi, (CONST_CAST)record, NULL);
             if (err_is_fail(err)) {
                 printf("Boot driver not found. Do not boot discovered CPU %"PRIu64".\n",
                        barrelfish_id);
@@ -85,7 +85,7 @@ struct inheritcn_del_st {
 
 // Trigger function: gets called when spanwd on core n is up to delete
 // associated inherit cnode that was given to `corectrl boot n`.
-static void delete_inheritcn(octopus_mode_t mode, char *record, void *state)
+static void delete_inheritcn(octopus_mode_t mode, const char *record, void *state)
 {
     errval_t err;
     struct inheritcn_del_st *st = state;
@@ -229,7 +229,8 @@ errval_t start_boot_driver(coreid_t where, struct module_info* mi,
 }
 
 
-static void spawnd_change_event(octopus_mode_t mode, char* record, void* state)
+static void spawnd_change_event(octopus_mode_t mode, const char* record,
+                                void* state)
 {
     size_t count = (size_t) state;
     static coreid_t spawnd_counter = 0;
index 26241db..d9a4ea6 100644 (file)
@@ -57,7 +57,8 @@ static void csv_to_argv(char * in, int * argc, char *** argv) {
     argv_out[argv_idx] = NULL;
 }
 
-static void int_controller_change_event(octopus_mode_t mode, char* device_record, void* st)
+static void int_controller_change_event(octopus_mode_t mode,
+                                        const char* device_record, void* st)
 {
     KALUGA_DEBUG("int_controller_change_event!\n");
 
index 851b9e3..43bfcb8 100644 (file)
 
 static struct capref all_irq_cap;
 
-static void pci_change_event(octopus_mode_t mode, char* device_record, void* st);
+static void pci_change_event(octopus_mode_t mode, const char* device_record,
+                             void* st);
 
-static void spawnd_up_event(octopus_mode_t mode, char* spawnd_record, void* st)
+static void spawnd_up_event(octopus_mode_t mode, const char* spawnd_record,
+                            void* st)
 {
     assert(mode & OCT_ON_SET);
     uint64_t iref;
@@ -43,7 +45,6 @@ static void spawnd_up_event(octopus_mode_t mode, char* spawnd_record, void* st)
     // don't need to look again for the spawnd iref
     // XXX: Pointer
     pci_change_event(OCT_ON_SET, st, (void*)(uintptr_t)iref);
-    free(spawnd_record);
 }
 
 static errval_t wait_for_spawnd(coreid_t core, void* state)
@@ -70,7 +71,8 @@ static errval_t wait_for_spawnd(coreid_t core, void* state)
     return error_code;
 }
 
-static void pci_change_event(octopus_mode_t mode, char* device_record, void* st)
+static void pci_change_event(octopus_mode_t mode, const char* device_record,
+                             void* st)
 {
     errval_t err;
     char intcaps_debug_msg[100];
@@ -159,7 +161,7 @@ static void pci_change_event(octopus_mode_t mode, char* device_record, void* st)
             cap.cnode = argnode_ref;
             cap.slot = 0;
             //err = sys_debug_create_irq_src_cap(cap, start, end);
-            err = cap_retype(cap, all_irq_cap, start, ObjType_IRQSrc, 
+            err = cap_retype(cap, all_irq_cap, start, ObjType_IRQSrc,
                     end, 1);
             if(err_is_fail(err)){
                 USER_PANIC_ERR(err, "Could not create int_src cap");
@@ -187,7 +189,7 @@ static void pci_change_event(octopus_mode_t mode, char* device_record, void* st)
         // Wait until the core where we start the driver
         // is ready
         if (st == NULL && core != my_core_id) {
-            err = wait_for_spawnd(core, device_record);
+            err = wait_for_spawnd(core, (CONST_CAST)device_record);
             if (err_no(err) == OCT_ERR_NO_RECORD) {
                 KALUGA_DEBUG("Core where driver %s runs is not up yet.\n",
                         mi->binary);
@@ -206,7 +208,7 @@ static void pci_change_event(octopus_mode_t mode, char* device_record, void* st)
                ", intcaps: %s, on core %"PRIuCOREID"\n",
                binary_name, bus, dev, fun, intcaps_debug_msg, core);
 
-        err = mi->start_function(core, mi, device_record, &driver_arg);
+        err = mi->start_function(core, mi, (CONST_CAST)device_record, &driver_arg);
         switch (err_no(err)) {
         case SYS_ERR_OK:
             KALUGA_DEBUG("Spawned PCI driver: %s\n", mi->binary);
@@ -228,7 +230,6 @@ static void pci_change_event(octopus_mode_t mode, char* device_record, void* st)
     }
 
 out:
-    free(device_record);
     free(binary_name);
 }
 
@@ -242,7 +243,8 @@ errval_t watch_for_pci_devices(void)
     return oct_trigger_existing_and_watch(pci_device, pci_change_event, NULL, &tid);
 }
 
-static void bridge_change_event(octopus_mode_t mode, char* bridge_record, void* st)
+static void bridge_change_event(octopus_mode_t mode, const char* bridge_record,
+                                void* st)
 {
     if (mode & OCT_ON_SET) {
         // No need to ask the SKB as we always start pci for
@@ -255,7 +257,7 @@ static void bridge_change_event(octopus_mode_t mode, char* bridge_record, void*
 
         // XXX: always spawn on my_core_id; otherwise we need to check that
         // the other core is already up
-        errval_t err = mi->start_function(my_core_id, mi, bridge_record, NULL);
+        errval_t err = mi->start_function(my_core_id, mi, (CONST_CAST)bridge_record, NULL);
         switch (err_no(err)) {
         case SYS_ERR_OK:
             KALUGA_DEBUG("Spawned PCI bus driver: %s\n", mi->binary);
index a425f14..2672c23 100644 (file)
@@ -600,9 +600,9 @@ static void inter_rsrc_phase(struct intermon_binding *b, rsrcid_t id,
 }
 
 static void inter_rsrc_phase_data(struct intermon_binding *b, rsrcid_t id,
-                                  uint32_t phase, uint8_t *data, size_t len)
+                                  uint32_t phase, const uint8_t *data, size_t len)
 {
-    errval_t err = rsrc_set_phase_data(id, phase, data, len);
+    errval_t err = rsrc_set_phase_data(id, phase, (CONST_CAST)data, len);
     assert(err_is_ok(err));
 }
 
index f5d9a02..2a7b7ad 100644 (file)
@@ -73,7 +73,7 @@ static void remote_cap_revoke(struct monitor_blocking_binding *b,
 }
 
 static void rsrc_manifest(struct monitor_blocking_binding *b,
-                          struct capref dispcap, char *str)
+                          struct capref dispcap, const char *str)
 {
     errval_t err, err2;
     rsrcid_t id;
@@ -87,7 +87,7 @@ static void rsrc_manifest(struct monitor_blocking_binding *b,
         // TODO: Cleanup
         goto out;
     }
-    err = rsrc_submit_manifest(id, str);
+    err = rsrc_submit_manifest(id, (CONST_CAST)str);
 
  out:
     err2 = b->tx_vtbl.rsrc_manifest_response(b, NOP_CONT, id, err);
@@ -237,7 +237,7 @@ static void irq_handle_call(struct monitor_blocking_binding *b, struct capref ep
     /* set it and reply */
     err = invoke_irqtable_set(cap_irq, vec, ep);
     if (err_is_fail(err)) {
-        err = err_push(err, MON_ERR_INVOKE_IRQ_SET);        
+        err = err_push(err, MON_ERR_INVOKE_IRQ_SET);
     }
     err2 = b->tx_vtbl.irq_handle_response(b, NOP_CONT, err, vec);
     assert(err_is_ok(err2));
index b1a2488..6ef27fc 100644 (file)
@@ -117,7 +117,8 @@ static void multihop_routing_table_new(struct monitor_binding *b,
 
 // receive a part of the routing table from RTS (routing table set-up dispatcher)
 static void multihop_routing_table_set(struct monitor_binding *b,
-                                       coreid_t from, coreid_t *to, size_t len)
+                                       coreid_t from, const coreid_t *to,
+                                       size_t len)
 {
     // sanity-check input (FIXME: report errors!)
     // FIXME: we don't yet support changes to the existing routing table
@@ -184,7 +185,7 @@ static void multihop_handle_routing_table_response(struct intermon_binding *b,
                                                    errval_t err,
                                                    coreid_t source_coreid,
                                                    coreid_t max_coreid,
-                                                   coreid_t *to, size_t len)
+                                                   const coreid_t *to, size_t len)
 {
     assert(routing_table == NULL);
     assert(source_coreid == my_core_id);
@@ -210,7 +211,8 @@ static void multihop_handle_routing_table_response(struct intermon_binding *b,
 // grow the routing table to a set of desination cores, via a given forwarder
 static void multihop_routing_table_grow(struct intermon_binding *b,
                                         coreid_t forwarder,
-                                        coreid_t *destinations, size_t ndests)
+                                        const coreid_t *destinations,
+                                        size_t ndests)
 {
     assert(ndests > 0);
 
@@ -934,14 +936,14 @@ static inline void multihop_monitor_request_error(
 
 static inline void multihop_message_monitor_forward(struct monitor_binding *b,
         multihop_vci_t vci, uint8_t direction, uint8_t flags, uint32_t ack,
-        uint8_t *payload, size_t size, bool first_try);
+        const uint8_t *payload, size_t size, bool first_try);
 
 static void multihop_message_forward_continue(struct monitor_binding *b,
         struct monitor_msg_queue_elem *e);
 
 static inline void multihop_message_intermon_forward(struct intermon_binding *b,
         multihop_vci_t vci, uint8_t direction, uint8_t flags, uint32_t ack,
-        uint8_t *payload, size_t size, bool first_try);
+        const uint8_t *payload, size_t size, bool first_try);
 
 static void multihop_message_intermon_forward_cont(struct intermon_binding *b,
         struct intermon_msg_queue_elem *e);
@@ -973,7 +975,7 @@ struct intermon_message_forwarding_state {
  */
 static void multihop_message_handler(struct monitor_binding *mon_binding,
         multihop_vci_t vci, uint8_t direction, uint8_t flags, uint32_t ack,
-        uint8_t *payload, size_t size)
+        const uint8_t *payload, size_t size)
 {
 
     MULTIHOP_DEBUG(
@@ -1034,7 +1036,7 @@ static void multihop_message_intermon_forward_cont(struct intermon_binding *b,
  */
 static inline void multihop_message_intermon_forward(struct intermon_binding *b,
         multihop_vci_t vci, uint8_t direction, uint8_t flags, uint32_t ack,
-        uint8_t *payload, size_t size, bool first_try)
+        const uint8_t *payload, size_t size, bool first_try)
 {
 
     errval_t err;
@@ -1093,7 +1095,7 @@ static inline void multihop_message_intermon_forward(struct intermon_binding *b,
  */
 static void intermon_multihop_message_handler(struct intermon_binding *binding,
         multihop_vci_t vci, uint8_t direction, uint8_t flags, uint32_t ack,
-        uint8_t *payload, size_t size)
+        const uint8_t *payload, size_t size)
 {
 
     MULTIHOP_DEBUG(
@@ -1184,7 +1186,7 @@ static void multihop_message_forward_continue(struct monitor_binding *b,
  */
 static inline void multihop_message_monitor_forward(struct monitor_binding *b,
         multihop_vci_t vci, uint8_t direction, uint8_t flags, uint32_t ack,
-        uint8_t *payload, size_t size, bool first_try)
+        const uint8_t *payload, size_t size, bool first_try)
 {
 
     errval_t err;
index 6428802..387f110 100644 (file)
@@ -194,7 +194,7 @@ static errval_t readdir(struct trivfs_binding *b, trivfs_fh_t dir, uint32_t idx,
     return SYS_ERR_OK;
 }
 
-static errval_t lookup(struct trivfs_binding *b, trivfs_fh_t dir, char *name,
+static errval_t lookup(struct trivfs_binding *b, trivfs_fh_t dir, const char *name,
                        errval_t *reterr, trivfs_fh_t *retfh, bool *isdir)
 {
     errval_t err;
@@ -279,7 +279,7 @@ static errval_t read(struct trivfs_binding *b, trivfs_fh_t fh,
 }
 
 static errval_t write(struct trivfs_binding *b, trivfs_fh_t fh,
-                      trivfs_offset_t offset, uint8_t *data, size_t len,
+                      trivfs_offset_t offset, const uint8_t *data, size_t len,
                       errval_t *reterr)
 {
     errval_t err;
@@ -410,7 +410,7 @@ static errval_t truncate(struct trivfs_binding *b, trivfs_fh_t fh,
     return SYS_ERR_OK;
 }
 
-static errval_t create(struct trivfs_binding *b, trivfs_fh_t dir, char *name,
+static errval_t create(struct trivfs_binding *b, trivfs_fh_t dir, const char *name,
                        errval_t *reterr, trivfs_fh_t *fh)
 {
     errval_t err;
@@ -429,16 +429,9 @@ static errval_t create(struct trivfs_binding *b, trivfs_fh_t dir, char *name,
         return SYS_ERR_OK;
     }
 
-
-    name = strdup(name);
-    if (name == NULL) {
-        *reterr = LIB_ERR_MALLOC_FAIL;
-        return SYS_ERR_OK;
-    }
     struct dirent *newf;
     err = ramfs_create(d, name, &newf);
     if (err_is_fail(err)) {
-        free(name);
         *reterr = err;
         return SYS_ERR_OK;
     }
@@ -447,7 +440,7 @@ static errval_t create(struct trivfs_binding *b, trivfs_fh_t dir, char *name,
     return SYS_ERR_OK;
 }
 
-static errval_t mkdir(struct trivfs_binding *b, trivfs_fh_t dir, char *name,
+static errval_t mkdir(struct trivfs_binding *b, trivfs_fh_t dir, const char *name,
                       errval_t *reterr, trivfs_fh_t *fh)
 {
     errval_t err;
@@ -466,16 +459,9 @@ static errval_t mkdir(struct trivfs_binding *b, trivfs_fh_t dir, char *name,
         return SYS_ERR_OK;
     }
 
-    name = strdup(name);
-    if (name == NULL) {
-        *reterr = LIB_ERR_MALLOC_FAIL;
-        return SYS_ERR_OK;
-    }
-
     struct dirent *newd;
     err = ramfs_mkdir(d, name, &newd);
     if (err_is_fail(err)) {
-        free(name);
         *reterr = err;
         return SYS_ERR_OK;
     }
index 4328462..e022fdc 100644 (file)
@@ -48,6 +48,6 @@ struct skb_reply_state {
 
 errval_t new_reply_state(struct skb_reply_state**, rpc_reply_handler_fn);
 void free_reply_state(void*);
-errval_t execute_query(char*, struct skb_query_state*);
+errval_t execute_query(const char*, struct skb_query_state*);
 
 #endif
index 4874ce6..88fb5e1 100644 (file)
@@ -105,7 +105,7 @@ static errval_t do_listing_on_stdout(struct skb_query_state* st)
 }
 
 
-errval_t execute_query(char* query, struct skb_query_state* st)
+errval_t execute_query(const char* query, struct skb_query_state* st)
 {
     SKB_DEBUG("Executing query: %s\n", query);
     assert(query != NULL);
@@ -146,7 +146,7 @@ errval_t execute_query(char* query, struct skb_query_state* st)
         } while ((res != 0) && (st->output_length < sizeof(st->output_buffer)));
 
         // Check for overflow
-        if(st->output_length == sizeof(st->output_buffer) && 
+        if(st->output_length == sizeof(st->output_buffer) &&
                 !output_overflow){
             debug_printf("st->output_buffer overflow. Query: %s\n", query);
             output_overflow = 1;
@@ -193,7 +193,7 @@ errval_t execute_query(char* query, struct skb_query_state* st)
     
     if((error_overflow || output_overflow) && st->exec_res == PSUCCEED){
         st->exec_res = PBUFFER_OVERLFLOW;
-    } 
+    }
 
     return SYS_ERR_OK;
 }
@@ -215,7 +215,7 @@ static void run_reply(struct skb_binding* b, struct skb_reply_state* srt) {
 }
 
 
-static void run(struct skb_binding *b, char *query)
+static void run(struct skb_binding *b, const char *query)
 {
     struct skb_reply_state* srt = NULL;
     errval_t err = new_reply_state(&srt, run_reply);
index 132091c..e73ef39 100644 (file)
@@ -30,7 +30,7 @@
 #include "ps.h"
 
 
-static errval_t spawn(char *path, char *const argv[], char *argbuf,
+static errval_t spawn(const char *path, char *const argv[], const char *argbuf,
                       size_t argbytes, char *const envp[],
                       struct capref inheritcn_cap, struct capref argcn_cap,
                       uint8_t flags, domainid_t *domainid)
@@ -80,7 +80,7 @@ static errval_t spawn(char *path, char *const argv[], char *argbuf,
     }
 
     // find short name (last part of path)
-    char *name = strrchr(path, VFS_PATH_SEP);
+    const char *name = strrchr(path, VFS_PATH_SEP);
     if (name == NULL) {
         name = path;
     } else {
@@ -239,11 +239,11 @@ struct pending_spawn_response {
     domainid_t domainid;
 };
 
-static errval_t spawn_with_caps_common(char *path, char *argbuf, size_t argbytes,
-                                       char *envbuf, size_t envbytes,
+static errval_t spawn_with_caps_common(const char *path, const char *argbuf,
+                                       size_t argbytes, const char *envbuf,
+                                       size_t envbytes,
                                        struct capref inheritcn_cap,
-                                       struct capref argcn_cap,
-                                       uint8_t flags,
+                                       struct capref argcn_cap, uint8_t flags,
                                        domainid_t *domainid)
 {
     errval_t err;
@@ -255,7 +255,7 @@ static errval_t spawn_with_caps_common(char *path, char *argbuf, size_t argbytes
     int i = 0;
     size_t pos = 0;
     while (pos < argbytes && i < MAX_CMDLINE_ARGS) {
-        argv[i++] = &argbuf[pos];
+        argv[i++] = (CONST_CAST)argbuf + pos;
         char *end = memchr(&argbuf[pos], '\0', argbytes - pos);
         if (end == NULL) {
             err = SPAWN_ERR_GET_CMDLINE_ARGS;
@@ -271,7 +271,7 @@ static errval_t spawn_with_caps_common(char *path, char *argbuf, size_t argbytes
     i = 0;
     pos = 0;
     while (pos < envbytes && i < MAX_CMDLINE_ARGS) {
-        envp[i++] = &envbuf[pos];
+        envp[i++] = (CONST_CAST)envbuf + pos;
         char *end = memchr(&envbuf[pos], '\0', envbytes - pos);
         if (end == NULL) {
             err = SPAWN_ERR_GET_CMDLINE_ARGS;
@@ -282,9 +282,12 @@ static errval_t spawn_with_caps_common(char *path, char *argbuf, size_t argbytes
     assert(i <= MAX_CMDLINE_ARGS);
     envp[i] = NULL;
 
-    vfs_path_normalise(path);
+    char *npath;
+    npath = alloca(strlen(path));
+    strcpy(npath, path);
+    vfs_path_normalise(npath);
 
-    err = spawn(path, argv, argbuf, argbytes, envp, inheritcn_cap, argcn_cap,
+    err = spawn(npath, argv, argbuf, argbytes, envp, inheritcn_cap, argcn_cap,
                 flags, domainid);
     // XXX: do we really want to delete the inheritcn and the argcn here? iaw:
     // do we copy these somewhere? -SG
@@ -307,8 +310,8 @@ static errval_t spawn_with_caps_common(char *path, char *argbuf, size_t argbytes
     return err;
 }
 
-static errval_t spawn_with_caps_handler(struct spawn_binding *b, char *path,
-    char *argvbuf, size_t argvbytes, char *envbuf, size_t envbytes,
+static errval_t spawn_with_caps_handler(struct spawn_binding *b, const char *path,
+    const char *argvbuf, size_t argvbytes, const char *envbuf, size_t envbytes,
     struct capref inheritcn_cap, struct capref argcn_cap, uint8_t flags,
     errval_t *err, spawn_domainid_t *domain_id)
 {
@@ -317,8 +320,8 @@ static errval_t spawn_with_caps_handler(struct spawn_binding *b, char *path,
     return SYS_ERR_OK;
 }
 
-static errval_t spawn_handler(struct spawn_binding *b, char *path,
-    char *argvbuf, size_t argvbytes, char *envbuf, size_t envbytes,
+static errval_t spawn_handler(struct spawn_binding *b, const char *path,
+    const char *argvbuf, size_t argvbytes, const char *envbuf, size_t envbytes,
     uint8_t flags, errval_t *err, spawn_domainid_t *domain_id)
 {
     *err = spawn_with_caps_common(path, argvbuf, argvbytes, envbuf, envbytes,
index 1ac242d..3e0fb3c 100644 (file)
@@ -61,16 +61,14 @@ void test_retype(struct capref src, struct capref *dest, gensize_t offset,
 }
 
 //{{{1 Unused message handlers
-static void rx_str(struct test_binding *b, uint32_t arg, char *s)
+static void rx_str(struct test_binding *b, uint32_t arg, const char *s)
 {
     printf("rx_str %"PRIu32" '%s'\n", arg, s);
-    free(s);
 }
 
-static void rx_buf(struct test_binding *b, uint8_t *buf, size_t buflen)
+static void rx_buf(struct test_binding *b, const uint8_t *buf, size_t buflen)
 {
     printf("rx_buf buflen=%zu\n", buflen);
-    free(buf);
 }
 
 //{{{1 Server
index 6d0452a..4ac925a 100644 (file)
@@ -68,7 +68,7 @@ static void rx_basic(struct test_binding *b, uint32_t arg)
     assert(arg == 7);
 }
 
-static void rx_str(struct test_binding *b, uint32_t arg, char *s)
+static void rx_str(struct test_binding *b, uint32_t arg, const char *s)
 {
     debug_printf("rx_str %"PRIu32" Str[:5]:'%.5s'\n", arg, s);
     switch(arg){
@@ -104,10 +104,9 @@ static void rx_caps(struct test_binding *b, uint32_t arg,
     debug_printf("rx_caps %"PRIu32" [%s] [%s]\n", arg, buf1, buf2);
 }
 
-static void rx_buf(struct test_binding *b, uint8_t *buf, size_t buflen)
+static void rx_buf(struct test_binding *b, const uint8_t *buf, size_t buflen)
 {
     debug_printf("rx_buf (%zu bytes)\n", buflen);
-    free(buf);
 }
 
 static struct test_rx_vtbl rx_vtbl = {
index 59eebbc..e10a2e2 100644 (file)
@@ -529,14 +529,13 @@ static void fsb_payload64_16_request(struct bench_binding *b, int64_t payload0,
     }
 }
 
-static void fsb_buffer_reply(struct bench_binding *b, uint8_t *payload,
+static void fsb_buffer_reply(struct bench_binding *b, const uint8_t *payload,
         size_t size)
 {
     message_received();
-    free(payload);
 }
 
-static void fsb_buffer_request(struct bench_binding *b, uint8_t *payload,
+static void fsb_buffer_request(struct bench_binding *b, const uint8_t *payload,
         size_t size)
 {
     errval_t err;
@@ -551,7 +550,6 @@ static void fsb_buffer_request(struct bench_binding *b, uint8_t *payload,
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "error while sending reply message in client\n");
     }
-    free(payload);
 }
 
 // receive virtual table
index 615dc9c..ec0f793 100644 (file)
@@ -186,7 +186,7 @@ static void rx_basic(struct test_binding *b, uint32_t arg)
     printf("%s rx_basic %"PRIu32"\n", get_role_name(), arg);
 }
 
-static void rx_str(struct test_binding *b, uint32_t arg, char *s)
+static void rx_str(struct test_binding *b, uint32_t arg, const char *s)
 {
 
     // make sure we received the correct argument(s)
@@ -218,7 +218,7 @@ static void rx_caps(struct test_binding *b, uint32_t arg, struct capref cap1,
     printf("%s rx_caps %"PRIu32" [%s] [%s]\n", get_role_name(), arg, buf1, buf2);
 }
 
-static void rx_buf(struct test_binding *b, uint8_t *buf, size_t buflen)
+static void rx_buf(struct test_binding *b, const uint8_t *buf, size_t buflen)
 {
 
     // make sure we received the correct argument(s)
index 99ae18b..a3bc47d 100644 (file)
@@ -370,7 +370,7 @@ input_handler (void *user_data, const char *str, size_t size)
     process_interrupt_conditions(u);
 }
 
-static void serial_input_handler(struct serial_binding *b, char *data,
+static void serial_input_handler(struct serial_binding *b, const char *data,
                                  size_t size)
 {
     struct pc16550d *state = b->st;