void messages_wait_and_handle_next(void);
void __attribute__((noreturn)) messages_handler_loop(void);
+typedef void *CONST_CAST;
+
#endif
// 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;
};
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_*/
#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);
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_ */
};
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];
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);
*/
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);
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;
//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,
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
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;
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,
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
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");
//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,
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
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(
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(
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(
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(
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(
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(
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;
}
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);
#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_ */
#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)
{
#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);
}
}
-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;
}
}
-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);
} 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);
}
}
}
-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;
}
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;
}
}
}
-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;
}
}
-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);
}
}
-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);
}
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;
}
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;
}
}
-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;
}
}
-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;
}
// 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;
}
}
-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);
}
}
-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;
drs->error = set_binding(type, id, b);
drs->reply(b, drs);
}
-
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;
// 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) {
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;
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;
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;
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;
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;
* 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)
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;
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)
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
[ 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]
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
(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,
}
#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;
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",
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);
-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);
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;;
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;
//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;
debug_printf("eval_integer_handler\n");
err = b->tx_vtbl.eval_integer_response(b, NOP_CONT, val, err);
- free(path);
}
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);
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];
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").",
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
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) {
* 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;
}
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) {
struct ps_entry {
char *argv[MAX_CMDLINE_ARGS];
- char *argbuf;
+ const char *argbuf;
size_t argbytes;
struct capref rootcn_cap, dcb;
struct cnoderef rootcn;
#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)
{
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;
}
// 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 {
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;
/*
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)) {
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;
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
}
-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)
{
/* 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;
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;
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;
finish:
if(err_is_fail(err)) {
- free(argbuf);
DEBUG_ERR(err, "spawn");
}
// 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);
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);
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;
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();
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;
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;
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);
}
}
-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) {
}
}
-
- free(record);
}
// 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);
}
}
-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);
}
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);
}
-void serial_write(char *c, size_t len)
+void serial_write(const char *c, size_t len)
{
sys_print(c, len);
}
}
/** 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]);
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]);
}
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]);
}
};
static void domain_wait_trigger_handler(octopus_mode_t mode,
- char* record,
+ const char* record,
void* state)
{
errval_t err;
return err;
}
-
*/
static void domain_wait_call_rx(struct interphi_binding *_binding,
- char *name,
+ const char *name,
size_t length,
uintptr_t state)
{
txq_send(msg_st);
break;
}
- free(name);
#endif
}
}
static void domain_lookup_call_rx(struct interphi_binding *_binding,
- char *name,
+ const char *name,
size_t length)
{
#ifdef __k1om__
msg_st->err = domain_lookup(name, &st->args.domain.domid);
- free(name);
-
txq_send(msg_st);
#endif
}
}
static void domain_register_call_rx(struct interphi_binding *_binding,
- char *name,
+ const char *name,
size_t length,
xphi_dom_id_t domid)
{
msg_st->err = domain_register(name, domid);
- free(name);
-
txq_send(msg_st);
#endif
}
static void spawn_call_rx(struct interphi_binding *_binding,
uint8_t core,
- char *cmdline,
+ const char *cmdline,
size_t length,
uint8_t flags)
{
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;
st->args.spawn_reply.domainid = xeon_phi_domain_build_id(phi->id, core,
is_host, domid);
}
-
- free(cmdline);
-
txq_send(msg_st);
}
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,
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;
XEON_PHI_DOMAIN_HOST, core, 1, domid);
#endif
}
-
- free(cmdline);
-
txq_send(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);
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);
/* 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)
{
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;
#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,
msg_st->err = domain_register(svc_st->name, svc_st->domainid);
#endif
xphi_svc_clients_insert(svc_st);
-
- free(name);
-
txq_send(msg_st);
}
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)
#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)
{
#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);
}
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);
/* 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);
// 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;
}
-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;
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");
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;
// 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)
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];
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");
// 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);
", 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);
}
out:
- free(device_record);
free(binary_name);
}
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
// 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);
}
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));
}
}
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;
// 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);
/* 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));
// 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
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);
// 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);
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);
*/
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(
*/
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;
*/
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(
*/
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;
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;
}
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;
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;
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;
}
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;
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;
}
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
}
-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);
} 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;
if((error_overflow || output_overflow) && st->exec_res == PSUCCEED){
st->exec_res = PBUFFER_OVERLFLOW;
- }
+ }
return SYS_ERR_OK;
}
}
-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);
#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)
}
// 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 {
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;
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;
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;
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
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)
{
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,
}
//{{{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
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){
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 = {
}
}
-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;
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "error while sending reply message in client\n");
}
- free(payload);
}
// receive virtual table
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)
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)
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;
projects / barrelfish / commitdiff