/** Start an async exchange on the loc session (blocking). * * @param iface Location service interface to choose * * @return New exchange. * */ async_exch_t *loc_exchange_begin_blocking(loc_interface_t iface) { switch (iface) { case LOC_PORT_SUPPLIER: fibril_mutex_lock(&loc_supp_block_mutex); while (loc_supp_block_sess == NULL) { clone_session(&loc_supplier_mutex, loc_supplier_sess, &loc_supp_block_sess); if (loc_supp_block_sess == NULL) loc_supp_block_sess = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOC, LOC_PORT_SUPPLIER, 0); } fibril_mutex_unlock(&loc_supp_block_mutex); clone_session(&loc_supplier_mutex, loc_supp_block_sess, &loc_supplier_sess); return async_exchange_begin(loc_supp_block_sess); case LOC_PORT_CONSUMER: fibril_mutex_lock(&loc_cons_block_mutex); while (loc_cons_block_sess == NULL) { clone_session(&loc_consumer_mutex, loc_consumer_sess, &loc_cons_block_sess); if (loc_cons_block_sess == NULL) loc_cons_block_sess = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOC, LOC_PORT_CONSUMER, 0); } fibril_mutex_unlock(&loc_cons_block_mutex); clone_session(&loc_consumer_mutex, loc_cons_block_sess, &loc_consumer_sess); return async_exchange_begin(loc_cons_block_sess); default: return NULL; } }
/** Start an async exchange on the clipboard session. * * @return New exchange. * */ static async_exch_t *clip_exchange_begin(void) { fibril_mutex_lock(&clip_mutex); while (clip_sess == NULL) clip_sess = service_connect_blocking(SERVICE_CLIPBOARD, INTERFACE_CLIPBOARD, 0); fibril_mutex_unlock(&clip_mutex); return async_exchange_begin(clip_sess); }
async_sess_t *loc_service_connect(exch_mgmt_t mgmt, service_id_t handle, unsigned int flags) { async_sess_t *sess; if (flags & IPC_FLAG_BLOCKING) sess = service_connect_blocking(mgmt, SERVICE_LOC, LOC_CONNECT_TO_SERVICE, handle); else sess = service_connect(mgmt, SERVICE_LOC, LOC_CONNECT_TO_SERVICE, handle); return sess; }
loader_t *loader_connect(void) { loader_t *ldr = malloc(sizeof(loader_t)); if (ldr == NULL) return NULL; async_sess_t *sess = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOAD, 0, 0); if (sess == NULL) { free(ldr); return NULL; } ldr->sess = sess; return ldr; }
/** Initialize the logging system. * * @param prog_name Program name, will be printed as part of message */ int log_init(const char *prog_name) { log_prog_name = str_dup(prog_name); if (log_prog_name == NULL) return ENOMEM; logger_session = service_connect_blocking(SERVICE_LOGGER, INTERFACE_LOGGER_WRITER, 0); if (logger_session == NULL) { return ENOMEM; } default_log_id = log_create(prog_name, LOG_NO_PARENT); return EOK; }
/** * Connect to IRC service. This function should be called only from * the add_device handler, thus no locking is required. * * @param nic_data * * @return EOK If connection was successful. * @return EINVAL If the IRC service cannot be determined. * @return EREFUSED If IRC service cannot be connected. */ int nic_connect_to_services(nic_t *nic_data) { /* IRC service */ sysarg_t apic; sysarg_t i8259; services_t irc_service = -1; if (((sysinfo_get_value("apic", &apic) == EOK) && (apic)) || ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259))) irc_service = SERVICE_IRC; else return EINVAL; nic_data->irc_session = service_connect_blocking(EXCHANGE_SERIALIZE, irc_service, 0, 0); if (nic_data->irc_session == NULL) return errno; return EOK; }
int main(int argc, char *argv[]) { log_init(NAME); log_msg(LOG_DEFAULT, LVL_NOTE, "HelenOS UDF 1.02 file system server"); if (argc == 3) { if (!str_cmp(argv[1], "--instance")) udf_vfs_info.instance = strtol(argv[2], NULL, 10); else { log_msg(LOG_DEFAULT, LVL_FATAL, "Unrecognized parameters"); return 1; } } async_sess_t *vfs_sess = service_connect_blocking(SERVICE_VFS, INTERFACE_VFS_DRIVER, 0); if (!vfs_sess) { log_msg(LOG_DEFAULT, LVL_FATAL, "Failed to connect to VFS"); return 2; } int rc = fs_register(vfs_sess, &udf_vfs_info, &udf_ops, &udf_libfs_ops); if (rc != EOK) goto err; rc = udf_idx_init(); if (rc != EOK) goto err; log_msg(LOG_DEFAULT, LVL_NOTE, "Accepting connections"); task_retval(0); async_manager(); /* Not reached */ return 0; err: log_msg(LOG_DEFAULT, LVL_FATAL, "Failed to register file system (%d)", rc); return rc; }
int main(int argc, char **argv) { printf(NAME ": HelenOS FAT file system server\n"); if (argc == 3) { if (!str_cmp(argv[1], "--instance")) fat_vfs_info.instance = strtol(argv[2], NULL, 10); else { printf(NAME " Unrecognized parameters"); return -1; } } int rc = fat_idx_init(); if (rc != EOK) goto err; async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_VFS, 0, 0); if (!vfs_sess) { printf(NAME ": failed to connect to VFS\n"); return -1; } rc = fs_register(vfs_sess, &fat_vfs_info, &fat_ops, &fat_libfs_ops); if (rc != EOK) { fat_idx_fini(); goto err; } printf(NAME ": Accepting connections\n"); task_retval(0); async_manager(); /* Not reached */ return 0; err: printf(NAME ": Failed to register file system (%d)\n", rc); return rc; }
int main(int argc, char **argv) { printf("%s: HelenOS ext4 file system server\n", NAME); if (argc == 3) { if (!str_cmp(argv[1], "--instance")) ext4fs_vfs_info.instance = strtol(argv[2], NULL, 10); else { printf("%s: Unrecognized parameters\n", NAME); return 1; } } async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_VFS, 0, 0); if (!vfs_sess) { printf("%s: Failed to connect to VFS\n", NAME); return 2; } int rc = ext4fs_global_init(); if (rc != EOK) { printf("%s: Global initialization failed\n", NAME); return rc; } rc = fs_register(vfs_sess, &ext4fs_vfs_info, &ext4fs_ops, &ext4fs_libfs_ops); if (rc != EOK) { printf("%s: Failed to register file system\n", NAME); return rc; } printf("%s: Accepting connections\n", NAME); task_retval(0); async_manager(); /* Not reached */ return 0; }