void bt_a2dp_unregister(void)
{
DBG("");
g_slist_free_full(setups, setup_free);
setups = NULL;
g_slist_free_full(endpoints, unregister_endpoint);
endpoints = NULL;
g_slist_free_full(devices, a2dp_device_free);
devices = NULL;
ipc_unregister(hal_ipc, HAL_SERVICE_ID_A2DP);
hal_ipc = NULL;
bt_adapter_remove_record(record_id);
record_id = 0;
if (server) {
g_io_channel_shutdown(server, TRUE, NULL);
g_io_channel_unref(server);
server = NULL;
}
if (audio_ipc) {
ipc_unregister(audio_ipc, AUDIO_SERVICE_ID);
ipc_cleanup(audio_ipc);
audio_ipc = NULL;
}
}
static void bt_audio_unregister(void)
{
DBG("");
if (audio_retry_id > 0)
g_source_remove(audio_retry_id);
g_slist_free_full(endpoints, unregister_endpoint);
endpoints = NULL;
g_slist_free_full(setups, setup_free);
setups = NULL;
ipc_cleanup(audio_ipc);
audio_ipc = NULL;
}
int main(int argc, char *argv[])
{
GOptionContext *context;
GError *err = NULL;
guint signal;
set_version();
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &err) == FALSE) {
if (err != NULL) {
g_printerr("%s\n", err->message);
g_error_free(err);
} else
g_printerr("An unknown error occurred\n");
exit(EXIT_FAILURE);
}
g_option_context_free(context);
if (option_version == TRUE) {
printf("%s\n", VERSION);
exit(EXIT_SUCCESS);
}
signal = setup_signalfd();
if (!signal)
return EXIT_FAILURE;
if (option_dbg || option_mgmt_dbg)
__btd_log_init("*", 0);
else
__btd_log_init(NULL, 0);
if (!set_capabilities()) {
__btd_log_cleanup();
g_source_remove(signal);
return EXIT_FAILURE;
}
quit_timeout = g_timeout_add_seconds(STARTUP_GRACE_SECONDS,
quit_eventloop, NULL);
if (quit_timeout == 0) {
error("Failed to init startup timeout");
__btd_log_cleanup();
g_source_remove(signal);
return EXIT_FAILURE;
}
if (!bt_bluetooth_start(option_index, option_mgmt_dbg, adapter_ready)) {
__btd_log_cleanup();
g_source_remove(quit_timeout);
g_source_remove(signal);
return EXIT_FAILURE;
}
/* Use params: mtu = 0, flags = 0 */
start_sdp_server(0, 0);
DBG("Entering main loop");
event_loop = g_main_loop_new(NULL, FALSE);
g_main_loop_run(event_loop);
g_source_remove(signal);
if (quit_timeout > 0)
g_source_remove(quit_timeout);
cleanup_services();
stop_sdp_server();
bt_bluetooth_cleanup();
g_main_loop_unref(event_loop);
/* If no adapter was initialized, hal_ipc is NULL */
if (hal_ipc) {
ipc_unregister(hal_ipc, HAL_SERVICE_ID_CORE);
ipc_cleanup(hal_ipc);
}
info("Exit");
__btd_log_cleanup();
free(config_vendor);
free(config_model);
free(config_name);
free(config_serial);
free(config_fw_rev);
free(config_hw_rev);
return EXIT_SUCCESS;
}
/*
* semget - Semget system call.
*/
static int
semget(key_t key, int nsems, int semflg)
{
ksemid_t *sp;
kmutex_t *lock;
int id, error;
proc_t *pp = curproc;
top:
if (error = ipc_get(sem_svc, key, semflg, (kipc_perm_t **)&sp, &lock))
return (set_errno(error));
if (!IPC_FREE(&sp->sem_perm)) {
/*
* A semaphore with the requested key exists.
*/
if (!((nsems >= 0) && (nsems <= sp->sem_nsems))) {
mutex_exit(lock);
return (set_errno(EINVAL));
}
} else {
/*
* This is a new semaphore set. Finish initialization.
*/
if (nsems <= 0 || (rctl_test(rc_process_semmsl, pp->p_rctls, pp,
nsems, RCA_SAFE) & RCT_DENY)) {
mutex_exit(lock);
mutex_exit(&pp->p_lock);
ipc_cleanup(sem_svc, (kipc_perm_t *)sp);
return (set_errno(EINVAL));
}
mutex_exit(lock);
mutex_exit(&pp->p_lock);
/*
* We round the allocation up to coherency granularity
* so that multiple semaphore allocations won't result
* in the false sharing of their sem structures.
*/
sp->sem_base =
kmem_zalloc(P2ROUNDUP(nsems * sizeof (struct sem), 64),
KM_SLEEP);
sp->sem_binary = (nsems == 1);
sp->sem_nsems = (ushort_t)nsems;
sp->sem_ctime = gethrestime_sec();
sp->sem_otime = 0;
list_create(&sp->sem_undos, sizeof (struct sem_undo),
offsetof(struct sem_undo, un_list));
if (error = ipc_commit_begin(sem_svc, key, semflg,
(kipc_perm_t *)sp)) {
if (error == EAGAIN)
goto top;
return (set_errno(error));
}
sp->sem_maxops =
rctl_enforced_value(rc_process_semopm, pp->p_rctls, pp);
if (rctl_test(rc_process_semmsl, pp->p_rctls, pp, nsems,
RCA_SAFE) & RCT_DENY) {
ipc_cleanup(sem_svc, (kipc_perm_t *)sp);
return (set_errno(EINVAL));
}
lock = ipc_commit_end(sem_svc, &sp->sem_perm);
}
if (audit_active)
audit_ipcget(AT_IPC_SEM, (void *)sp);
id = sp->sem_perm.ipc_id;
mutex_exit(lock);
return (id);
}
