/** 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;
}
