/** Add new Wake-On-LAN virtue. * * @param[in] dev_sess * @param[in] type Type of the virtue * @param[in] data Data required for this virtue * (depends on type) * @param[in] length Length of the data * @param[out] id Identifier of the new virtue * * @return EOK If the operation was successfully completed * */ int nic_wol_virtue_add(async_sess_t *dev_sess, nic_wv_type_t type, const void *data, size_t length, nic_wv_id_t *id) { assert(id); bool send_data = ((data != NULL) && (length != 0)); async_exch_t *exch = async_exchange_begin(dev_sess); ipc_call_t result; aid_t message_id = async_send_3(exch, DEV_IFACE_ID(NIC_DEV_IFACE), NIC_WOL_VIRTUE_ADD, (sysarg_t) type, send_data, &result); sysarg_t res; if (send_data) { int rc = async_data_write_start(exch, data, length); if (rc != EOK) { async_exchange_end(exch); async_wait_for(message_id, &res); return rc; } } async_exchange_end(exch); async_wait_for(message_id, &res); *id = IPC_GET_ARG1(result); return (int) res; }
/** Copy string to clipboard. * * Sets the clipboard contents to @a str. Passing an empty string or NULL * makes the clipboard empty. * * @param str String to put to clipboard or NULL. * * @return Zero on success or negative error code. * */ int clipboard_put_str(const char *str) { size_t size = str_size(str); if (size == 0) { async_exch_t *exch = clip_exchange_begin(); sysarg_t rc = async_req_1_0(exch, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_NONE); clip_exchange_end(exch); return (int) rc; } else { async_exch_t *exch = clip_exchange_begin(); aid_t req = async_send_1(exch, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_DATA, NULL); sysarg_t rc = async_data_write_start(exch, (void *) str, size); clip_exchange_end(exch); if (rc != EOK) { sysarg_t rc_orig; async_wait_for(req, &rc_orig); if (rc_orig == EOK) return (int) rc; else return (int) rc_orig; } async_wait_for(req, &rc); return (int) rc; } }
/** Connect to specified network. * * @param[in] dev_sess Device session. * @param[in] ssid_start Network SSID prefix. * @param[in] password Network password (pass empty string if not needed). * * @return EOK If the operation was successfully completed, * negative error code otherwise. * */ int ieee80211_connect(async_sess_t *dev_sess, char *ssid_start, char *password) { assert(ssid_start); sysarg_t rc_orig; async_exch_t *exch = async_exchange_begin(dev_sess); aid_t aid = async_send_1(exch, DEV_IFACE_ID(IEEE80211_DEV_IFACE), IEEE80211_CONNECT, NULL); sysarg_t rc = async_data_write_start(exch, ssid_start, str_size(ssid_start) + 1); if (rc != EOK) { async_exchange_end(exch); async_wait_for(aid, &rc_orig); if (rc_orig == EOK) return (int) rc; return (int) rc_orig; } // FIXME: Typecasting string literal if (password == NULL) password = (char *) ""; rc = async_data_write_start(exch, password, str_size(password) + 1); if (rc != EOK) { async_exchange_end(exch); async_wait_for(aid, &rc_orig); if (rc_orig == EOK) return (int) rc; return (int) rc_orig; } async_exchange_end(exch); async_wait_for(aid, &rc); if (rc != EOK) return rc; /* Send DHCP discover. */ nic_address_t wifi_mac; rc = nic_get_address(dev_sess, &wifi_mac); if (rc != EOK) return rc; sysarg_t link_id = get_link_id(wifi_mac.address); if (link_id == ((sysarg_t) -1)) return EINVAL; rc = dhcp_discover(link_id); return (int) rc; }
/** Register new service. * * The @p interface is used when forwarding connection to the server. * If not 0, the first argument is the interface and the second argument * is the service ID. * * When the interface is zero (default), the first argument is directly * the handle (to ensure backward compatibility). * * @param fqsn Fully qualified service name * @param[out] sid Service ID of new service * @param interface Interface when forwarding * */ int loc_service_register_with_iface(const char *fqsn, service_id_t *sid, sysarg_t interface) { async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER); ipc_call_t answer; aid_t req = async_send_2(exch, LOC_SERVICE_REGISTER, interface, 0, &answer); sysarg_t retval = async_data_write_start(exch, fqsn, str_size(fqsn)); loc_exchange_end(exch); if (retval != EOK) { async_forget(req); return retval; } async_wait_for(req, &retval); if (retval != EOK) { if (sid != NULL) *sid = -1; return retval; } if (sid != NULL) *sid = (service_id_t) IPC_GET_ARG1(answer); return retval; }
int iplink_ev_recv(iplink_srv_t *srv, iplink_srv_sdu_t *sdu) { if (srv->client_sess == NULL) return EIO; async_exch_t *exch = async_exchange_begin(srv->client_sess); ipc_call_t answer; aid_t req = async_send_2(exch, IPLINK_EV_RECV, sdu->lsrc.ipv4, sdu->ldest.ipv4, &answer); int rc = async_data_write_start(exch, sdu->data, sdu->size); async_exchange_end(exch); if (rc != EOK) { async_forget(req); return rc; } sysarg_t retval; async_wait_for(req, &retval); if (retval != EOK) return retval; return EOK; }
static int loc_category_get_ids_once(sysarg_t method, sysarg_t arg1, sysarg_t *id_buf, size_t buf_size, size_t *act_size) { async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); ipc_call_t answer; aid_t req = async_send_1(exch, method, arg1, &answer); int rc = async_data_read_start(exch, id_buf, buf_size); loc_exchange_end(exch); if (rc != EOK) { async_forget(req); return rc; } sysarg_t retval; async_wait_for(req, &retval); if (retval != EOK) { return retval; } *act_size = IPC_GET_ARG1(answer); return EOK; }
/** Send formatted message to the logger service. * * @param session Initialized IPC session with the logger. * @param log Log to use. * @param level Verbosity level of the message. * @param message The actual message. * @return Error code of the conversion or EOK on success. */ static int logger_message(async_sess_t *session, log_t log, log_level_t level, char *message) { async_exch_t *exchange = async_exchange_begin(session); if (exchange == NULL) { return ENOMEM; } if (log == LOG_DEFAULT) log = default_log_id; // FIXME: remove when all USB drivers use libc logging explicitly str_rtrim(message, '\n'); aid_t reg_msg = async_send_2(exchange, LOGGER_WRITER_MESSAGE, log, level, NULL); int rc = async_data_write_start(exchange, message, str_size(message)); sysarg_t reg_msg_rc; async_wait_for(reg_msg, ®_msg_rc); async_exchange_end(exchange); /* * Getting ENAK means no-one wants our message. That is not an * error at all. */ if (rc == ENAK) rc = EOK; if (rc != EOK) { return rc; } return reg_msg_rc; }
/** Send message via UDP association. * * @param assoc Association * @param dest Destination endpoint or @c NULL to use association's remote ep. * @param data Message data * @param bytes Message size in bytes * * @return EOK on success or negative error code */ int udp_assoc_send_msg(udp_assoc_t *assoc, inet_ep_t *dest, void *data, size_t bytes) { async_exch_t *exch; exch = async_exchange_begin(assoc->udp->sess); aid_t req = async_send_1(exch, UDP_ASSOC_SEND_MSG, assoc->id, NULL); sysarg_t rc = async_data_write_start(exch, (void *)dest, sizeof(inet_ep_t)); if (rc != EOK) { async_exchange_end(exch); async_forget(req); return rc; } rc = async_data_write_start(exch, data, bytes); if (rc != EOK) { async_forget(req); return rc; } async_exchange_end(exch); if (rc != EOK) { async_forget(req); return rc; } async_wait_for(req, &rc); return rc; }
/** Get list of IDs into a buffer of fixed size. * * @param vbd Virtual Block Device * @param method IPC method * @param arg1 First argument * @param id_buf Buffer to store IDs * @param buf_size Buffer size * @param act_size Place to store actual size of complete data. * * @return EOK on success or negative error code. */ static int vbd_get_ids_once(vbd_t *vbd, sysarg_t method, sysarg_t arg1, sysarg_t *id_buf, size_t buf_size, size_t *act_size) { async_exch_t *exch = async_exchange_begin(vbd->sess); ipc_call_t answer; aid_t req = async_send_1(exch, method, arg1, &answer); int rc = async_data_read_start(exch, id_buf, buf_size); async_exchange_end(exch); if (rc != EOK) { async_forget(req); return rc; } sysarg_t retval; async_wait_for(req, &retval); if (retval != EOK) { return retval; } *act_size = IPC_GET_ARG1(answer); return EOK; }
int vbd_part_create(vbd_t *vbd, service_id_t disk, vbd_part_spec_t *pspec, vbd_part_id_t *rpart) { async_exch_t *exch; sysarg_t retval; ipc_call_t answer; exch = async_exchange_begin(vbd->sess); aid_t req = async_send_1(exch, VBD_PART_CREATE, disk, &answer); int rc = async_data_write_start(exch, pspec, sizeof(vbd_part_spec_t)); async_exchange_end(exch); if (rc != EOK) { async_forget(req); return EIO; } async_wait_for(req, &retval); if (retval != EOK) return EIO; *rpart = (vbd_part_id_t)IPC_GET_ARG1(answer); return EOK; }
/** Set preset files for the program. * * Sets the vector of preset files to be passed to the loaded * program. By convention, the first three files represent stdin, * stdout and stderr respectively. * * @param ldr Loader connection structure. * @param files NULL-terminated array of pointers to files. * * @return Zero on success or negative error code. * */ int loader_set_files(loader_t *ldr, int * const files[]) { /* Send serialized files to the loader */ async_exch_t *exch = async_exchange_begin(ldr->sess); async_exch_t *vfs_exch = vfs_exchange_begin(); int i; for (i = 0; files[i]; i++); ipc_call_t answer; aid_t req = async_send_1(exch, LOADER_SET_FILES, i, &answer); sysarg_t rc = EOK; for (i = 0; files[i]; i++) { rc = async_state_change_start(exch, VFS_PASS_HANDLE, *files[i], 0, vfs_exch); if (rc != EOK) break; } vfs_exchange_end(vfs_exch); async_exchange_end(exch); if (rc != EOK) { async_forget(req); return (int) rc; } async_wait_for(req, &rc); return (int) rc; }
/** Set pathname of the program to load. * * Sets the name of the program file to load. The name can be relative * to the current working directory (it will be absolutized before * sending to the loader). * * @param ldr Loader connection structure. * @param path Pathname of the program file. * * @return Zero on success or negative error code. * */ int loader_set_pathname(loader_t *ldr, const char *path) { size_t pa_len; char *pa = absolutize(path, &pa_len); if (!pa) return ENOMEM; /* Send program pathname */ async_exch_t *exch = async_exchange_begin(ldr->sess); ipc_call_t answer; aid_t req = async_send_0(exch, LOADER_SET_PATHNAME, &answer); sysarg_t rc = async_data_write_start(exch, (void *) pa, pa_len); async_exchange_end(exch); free(pa); if (rc != EOK) { async_forget(req); return (int) rc; } async_wait_for(req, &rc); return (int) rc; }
/** Set which multicast frames are received. * * @param[in] dev_sess * @param[in] mode Current operation mode * @param[in] address_list The list of addresses. Can be NULL. * @param[in] address_count Number of addresses in the list. * * @return EOK If the operation was successfully completed * */ int nic_multicast_set_mode(async_sess_t *dev_sess, nic_multicast_mode_t mode, const nic_address_t *address_list, size_t address_count) { if (address_list == NULL) address_count = 0; async_exch_t *exch = async_exchange_begin(dev_sess); aid_t message_id = async_send_3(exch, DEV_IFACE_ID(NIC_DEV_IFACE), NIC_MULTICAST_SET_MODE, (sysarg_t) mode, address_count, NULL); int rc; if (address_count) rc = async_data_write_start(exch, address_list, address_count * sizeof(nic_address_t)); else rc = EOK; async_exchange_end(exch); sysarg_t res; async_wait_for(message_id, &res); if (rc != EOK) return rc; return (int) res; }
/** Set current working directory for the loaded task. * * Sets the current working directory for the loaded task. * * @param ldr Loader connection structure. * * @return Zero on success or negative error code. * */ int loader_set_cwd(loader_t *ldr) { char *cwd = (char *) malloc(MAX_PATH_LEN + 1); if (!cwd) return ENOMEM; if (!getcwd(cwd, MAX_PATH_LEN + 1)) str_cpy(cwd, MAX_PATH_LEN + 1, "/"); size_t len = str_length(cwd); async_exch_t *exch = async_exchange_begin(ldr->sess); ipc_call_t answer; aid_t req = async_send_0(exch, LOADER_SET_CWD, &answer); sysarg_t rc = async_data_write_start(exch, cwd, len); async_exchange_end(exch); free(cwd); if (rc != EOK) { async_forget(req); return (int) rc; } async_wait_for(req, &rc); return (int) rc; }
/** Set which source MACs are blocked * * @param[in] dev_sess * @param[in] address_list The list of addresses. Can be NULL. * @param[in] address_count Number of addresses in the list. * * @return EOK If the operation was successfully completed * */ int nic_blocked_sources_set(async_sess_t *dev_sess, const nic_address_t *address_list, size_t address_count) { if (address_list == NULL) address_count = 0; async_exch_t *exch = async_exchange_begin(dev_sess); aid_t message_id = async_send_2(exch, DEV_IFACE_ID(NIC_DEV_IFACE), NIC_BLOCKED_SOURCES_SET, address_count, NULL); int rc; if (address_count) rc = async_data_write_start(exch, address_list, address_count * sizeof(nic_address_t)); else rc = EOK; async_exchange_end(exch); sysarg_t res; async_wait_for(message_id, &res); if (rc != EOK) return rc; return (int) res; }
/** Get information about the next received message from UDP service. * * @param udp UDP client * @param rmsg Place to store message information * * @return EOK on success or negative error code */ static int udp_rmsg_info(udp_t *udp, udp_rmsg_t *rmsg) { async_exch_t *exch; inet_ep_t ep; ipc_call_t answer; exch = async_exchange_begin(udp->sess); aid_t req = async_send_0(exch, UDP_RMSG_INFO, &answer); int rc = async_data_read_start(exch, &ep, sizeof(inet_ep_t)); async_exchange_end(exch); if (rc != EOK) { async_forget(req); return rc; } sysarg_t retval; async_wait_for(req, &retval); if (retval != EOK) return retval; rmsg->udp = udp; rmsg->assoc_id = IPC_GET_ARG1(answer); rmsg->size = IPC_GET_ARG2(answer); rmsg->remote_ep = ep; return EOK; }
/** Create new UDP association. * * Create a UDP association that allows sending and receiving messages. * * @a epp may specify remote address and port, in which case only messages * from that remote endpoint will be received. Also, that remote endpoint * is used as default when @c NULL is passed as destination to * udp_assoc_send_msg. * * @a epp may specify a local link or address. If it does not, the association * will listen on all local links/addresses. If @a epp does not specify * a local port number, a free dynamic port number will be allocated. * * The caller is informed about incoming data by invoking @a cb->recv_msg * * @param udp UDP client * @param epp Internet endpoint pair * @param cb Callbacks * @param arg Argument to callbacks * @param rassoc Place to store pointer to new association * * @return EOK on success or negative error code. */ int udp_assoc_create(udp_t *udp, inet_ep2_t *epp, udp_cb_t *cb, void *arg, udp_assoc_t **rassoc) { async_exch_t *exch; udp_assoc_t *assoc; ipc_call_t answer; assoc = calloc(1, sizeof(udp_assoc_t)); if (assoc == NULL) return ENOMEM; exch = async_exchange_begin(udp->sess); aid_t req = async_send_0(exch, UDP_ASSOC_CREATE, &answer); sysarg_t rc = async_data_write_start(exch, (void *)epp, sizeof(inet_ep2_t)); async_exchange_end(exch); if (rc != EOK) { sysarg_t rc_orig; async_wait_for(req, &rc_orig); if (rc_orig != EOK) rc = rc_orig; goto error; } async_wait_for(req, &rc); if (rc != EOK) goto error; assoc->udp = udp; assoc->id = IPC_GET_ARG1(answer); assoc->cb = cb; assoc->cb_arg = arg; list_append(&assoc->ludp, &udp->assoc); *rassoc = assoc; return EOK; error: free(assoc); return (int) rc; }
/** Get object name. * * Provided ID of an object, return its name. * * @param method IPC method * @param id Object ID * @param name Place to store pointer to new string. Caller should * free it using free(). * @return EOK on success or negative error code */ static int loc_get_name_internal(sysarg_t method, sysarg_t id, char **name) { async_exch_t *exch; char name_buf[LOC_NAME_MAXLEN + 1]; ipc_call_t dreply; size_t act_size; sysarg_t dretval; *name = NULL; exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); ipc_call_t answer; aid_t req = async_send_1(exch, method, id, &answer); aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply); async_wait_for(dreq, &dretval); loc_exchange_end(exch); if (dretval != EOK) { async_forget(req); return dretval; } sysarg_t retval; async_wait_for(req, &retval); if (retval != EOK) return retval; act_size = IPC_GET_ARG2(dreply); assert(act_size <= LOC_NAME_MAXLEN); name_buf[act_size] = '\0'; *name = str_dup(name_buf); if (*name == NULL) return ENOMEM; return EOK; }
int led_dev_color_set(async_sess_t *sess, pixel_t pixel) { async_exch_t *exch = async_exchange_begin(sess); aid_t req = async_send_2(exch, DEV_IFACE_ID(LED_DEV_IFACE), LED_DEV_COLOR_SET, (sysarg_t) pixel, NULL); async_exchange_end(exch); sysarg_t rc; async_wait_for(req, &rc); return (int) rc; }
/** Read to or write from device. * * Helper function to read to or write from a device * using its character interface. * * @param sess Session to the device. * @param buf Buffer for the data read from or written to the device. * @param size Maximum size of data (in bytes) to be read or written. * @param read Read from the device if true, write to it otherwise. * * @return Non-negative number of bytes actually read from or * written to the device on success, negative error number * otherwise. * */ static ssize_t char_dev_rw(async_sess_t *sess, void *buf, size_t size, bool read) { ipc_call_t answer; aid_t req; int ret; async_exch_t *exch = async_exchange_begin(sess); if (read) { req = async_send_1(exch, DEV_IFACE_ID(CHAR_DEV_IFACE), CHAR_DEV_READ, &answer); ret = async_data_read_start(exch, buf, size); } else { req = async_send_1(exch, DEV_IFACE_ID(CHAR_DEV_IFACE), CHAR_DEV_WRITE, &answer); ret = async_data_write_start(exch, buf, size); } async_exchange_end(exch); sysarg_t rc; if (ret != EOK) { async_wait_for(req, &rc); if (rc == EOK) return (ssize_t) ret; return (ssize_t) rc; } async_wait_for(req, &rc); ret = (int) rc; if (ret != EOK) return (ssize_t) ret; return (ssize_t) IPC_GET_ARG1(answer); }
size_t loc_get_services(service_id_t ns_handle, loc_sdesc_t **data) { /* Loop until read is succesful */ while (true) { async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); size_t count = loc_count_services_internal(exch, ns_handle); loc_exchange_end(exch); if (count == 0) return 0; loc_sdesc_t *devs = (loc_sdesc_t *) calloc(count, sizeof(loc_sdesc_t)); if (devs == NULL) return 0; exch = loc_exchange_begin(LOC_PORT_CONSUMER); ipc_call_t answer; aid_t req = async_send_1(exch, LOC_GET_SERVICES, ns_handle, &answer); int rc = async_data_read_start(exch, devs, count * sizeof(loc_sdesc_t)); loc_exchange_end(exch); if (rc == EOVERFLOW) { /* * Number of services has changed since * the last call of LOC_GET_SERVICE_COUNT */ free(devs); continue; } if (rc != EOK) { async_forget(req); free(devs); return 0; } sysarg_t retval; async_wait_for(req, &retval); if (retval != EOK) return 0; *data = devs; return count; } }
int ahci_get_sata_device_name(async_sess_t *sess, size_t sata_dev_name_length, char *sata_dev_name) { async_exch_t *exch = async_exchange_begin(sess); if (!exch) return EINVAL; aid_t req = async_send_2(exch, DEV_IFACE_ID(AHCI_DEV_IFACE), IPC_M_AHCI_GET_SATA_DEVICE_NAME, sata_dev_name_length, NULL); async_data_read_start(exch, sata_dev_name, sata_dev_name_length); sysarg_t rc; async_wait_for(req, &rc); return rc; }
/** Close the file in the endpoint FS server. */ static int vfs_file_close_remote(vfs_file_t *file) { assert(!file->refcnt); async_exch_t *exch = vfs_exchange_grab(file->node->fs_handle); ipc_call_t answer; aid_t msg = async_send_2(exch, VFS_OUT_CLOSE, file->node->service_id, file->node->index, &answer); vfs_exchange_release(exch); sysarg_t rc; async_wait_for(msg, &rc); return IPC_GET_ARG1(answer); }
/** Set command-line arguments for the program. * * Sets the vector of command-line arguments to be passed to the loaded * program. By convention, the very first argument is typically the same as * the command used to execute the program. * * @param ldr Loader connection structure. * @param argv NULL-terminated array of pointers to arguments. * * @return Zero on success or negative error code. * */ int loader_set_args(loader_t *ldr, const char *const argv[]) { /* * Serialize the arguments into a single array. First * compute size of the buffer needed. */ const char *const *ap = argv; size_t buffer_size = 0; while (*ap != NULL) { buffer_size += str_size(*ap) + 1; ap++; } char *arg_buf = malloc(buffer_size); if (arg_buf == NULL) return ENOMEM; /* Now fill the buffer with null-terminated argument strings */ ap = argv; char *dp = arg_buf; while (*ap != NULL) { str_cpy(dp, buffer_size - (dp - arg_buf), *ap); dp += str_size(*ap) + 1; ap++; } /* Send serialized arguments to the loader */ async_exch_t *exch = async_exchange_begin(ldr->sess); ipc_call_t answer; aid_t req = async_send_0(exch, LOADER_SET_ARGS, &answer); sysarg_t rc = async_data_write_start(exch, (void *) arg_buf, buffer_size); async_exchange_end(exch); free(arg_buf); if (rc != EOK) { async_forget(req); return (int) rc; } async_wait_for(req, &rc); return (int) rc; }
static int inet_callback_create(void) { async_exch_t *exch = async_exchange_begin(inet_sess); ipc_call_t answer; aid_t req = async_send_0(exch, INET_CALLBACK_CREATE, &answer); int rc = async_connect_to_me(exch, 0, 0, 0, inet_cb_conn, NULL); async_exchange_end(exch); if (rc != EOK) return rc; sysarg_t retval; async_wait_for(req, &retval); return retval; }
/** Set the address of the device (e.g. MAC on Ethernet) * * @param[in] dev_sess * @param[in] address Pointer to the address * * @return EOK If the operation was successfully completed * */ int nic_set_address(async_sess_t *dev_sess, const nic_address_t *address) { assert(address); async_exch_t *exch = async_exchange_begin(dev_sess); aid_t aid = async_send_1(exch, DEV_IFACE_ID(NIC_DEV_IFACE), NIC_SET_ADDRESS, NULL); int rc = async_data_write_start(exch, address, sizeof(nic_address_t)); async_exchange_end(exch); sysarg_t res; async_wait_for(aid, &res); if (rc != EOK) return rc; return (int) res; }
/** * Destroy an existing connection between a source and a sink. * @param sess Valid audio session. * @param source Source name, valid string. * @param sink Sink name, valid string. * @return Error code. */ int hound_service_disconnect_source_sink(hound_sess_t *sess, const char *source, const char *sink) { assert(sess); async_exch_t *exch = async_exchange_begin(sess); if (!exch) return ENOMEM; ipc_call_t call; aid_t id = async_send_0(exch, IPC_M_HOUND_DISCONNECT, &call); int ret = id ? EOK : EPARTY; if (ret == EOK) ret = async_data_write_start(exch, source, str_size(source)); if (ret == EOK) ret = async_data_write_start(exch, sink, str_size(sink)); async_wait_for(id, (sysarg_t*)&ret); async_exchange_end(exch); return ENOTSUP; }
/** Get ID of the new task. * * Retrieves the ID of the new task from the loader. * * @param ldr Loader connection structure. * @param task_id Points to a variable where the ID should be stored. * * @return Zero on success or negative error code. * */ int loader_get_task_id(loader_t *ldr, task_id_t *task_id) { /* Get task ID. */ async_exch_t *exch = async_exchange_begin(ldr->sess); ipc_call_t answer; aid_t req = async_send_0(exch, LOADER_GET_TASKID, &answer); sysarg_t rc = async_data_read_start(exch, task_id, sizeof(task_id_t)); async_exchange_end(exch); if (rc != EOK) { async_forget(req); return (int) rc; } async_wait_for(req, &rc); return (int) rc; }
imagemap_handle_t fb_imagemap_create(async_sess_t *sess, imgmap_t *imgmap) { async_exch_t *exch = async_exchange_begin(sess); ipc_call_t answer; aid_t req = async_send_0(exch, FB_IMAGEMAP_CREATE, &answer); int rc = async_share_out_start(exch, imgmap, AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE); async_exchange_end(exch); sysarg_t ret; async_wait_for(req, &ret); if ((rc != EOK) || (ret != EOK)) return 0; return (imagemap_handle_t) IPC_GET_ARG1(answer); }
/** Send frame from NIC * * @param[in] dev_sess * @param[in] data Frame data * @param[in] size Frame size in bytes * * @return EOK If the operation was successfully completed * */ int nic_send_frame(async_sess_t *dev_sess, void *data, size_t size) { async_exch_t *exch = async_exchange_begin(dev_sess); ipc_call_t answer; aid_t req = async_send_1(exch, DEV_IFACE_ID(NIC_DEV_IFACE), NIC_SEND_MESSAGE, &answer); sysarg_t retval = async_data_write_start(exch, data, size); async_exchange_end(exch); if (retval != EOK) { async_forget(req); return retval; } async_wait_for(req, &retval); return retval; }