/* Self-locked. Not multiple-caller safe */ void pa_memimport_free(pa_memimport *i) { pa_memexport *e; pa_memblock *b; pa_assert(i); pa_mutex_lock(i->mutex); while ((b = pa_hashmap_first(i->blocks))) memblock_replace_import(b); pa_assert(pa_hashmap_size(i->segments) == 0); pa_mutex_unlock(i->mutex); pa_mutex_lock(i->pool->mutex); /* If we've exported this block further we need to revoke that export */ for (e = i->pool->exports; e; e = e->next) memexport_revoke_blocks(e, i); PA_LLIST_REMOVE(pa_memimport, i->pool->imports, i); pa_mutex_unlock(i->pool->mutex); pa_hashmap_free(i->blocks); pa_hashmap_free(i->segments); pa_mutex_free(i->mutex); pa_xfree(i); }
void pa__done(pa_module*m) { struct userdata*u; pa_assert(m); if (!(u = m->userdata)) return; unpublish_all_services(u); if (u->services) pa_hashmap_free(u->services); if (u->sink_new_slot) pa_hook_slot_free(u->sink_new_slot); if (u->source_new_slot) pa_hook_slot_free(u->source_new_slot); if (u->sink_changed_slot) pa_hook_slot_free(u->sink_changed_slot); if (u->source_changed_slot) pa_hook_slot_free(u->source_changed_slot); if (u->sink_unlink_slot) pa_hook_slot_free(u->sink_unlink_slot); if (u->source_unlink_slot) pa_hook_slot_free(u->source_unlink_slot); if (u->native) pa_native_protocol_unref(u->native); pa_xfree(u->service_name); pa_xfree(u); }
void pa__done(pa_module*m) { struct userdata*u; pa_assert(m); if (!(u = m->userdata)) return; if (u->client) avahi_client_free(u->client); if (u->avahi_poll) pa_avahi_poll_free(u->avahi_poll); if (u->tunnels) { struct tunnel *t; while ((t = pa_hashmap_steal_first(u->tunnels))) { pa_module_unload_request_by_index(u->core, t->module_index, TRUE); tunnel_free(t); } pa_hashmap_free(u->tunnels, NULL, NULL); } pa_xfree(u); }
void pa__done(pa_module *m) { struct userdata *u; pa_assert(m); if (!(u = m->userdata)) return; if (u->udev_io) m->core->mainloop->io_free(u->udev_io); if (u->monitor) udev_monitor_unref(u->monitor); if (u->udev) udev_unref(u->udev); if (u->inotify_io) m->core->mainloop->io_free(u->inotify_io); if (u->inotify_fd >= 0) pa_close(u->inotify_fd); if (u->devices) pa_hashmap_free(u->devices); pa_xfree(u); }
void pa__done(pa_module*m) { struct userdata* u; pa_assert(m); if (!(u = m->userdata)) return; if (u->subscription) pa_subscription_free(u->subscription); if (u->sink_input_new_hook_slot) pa_hook_slot_free(u->sink_input_new_hook_slot); if (u->sink_input_fixate_hook_slot) pa_hook_slot_free(u->sink_input_fixate_hook_slot); if (u->source_output_new_hook_slot) pa_hook_slot_free(u->source_output_new_hook_slot); if (u->hashmap) { save_rules(u); pa_hashmap_free(u->hashmap, free_func, NULL); } if (u->save_time_event) u->core->mainloop->time_free(u->save_time_event); pa_xfree(u->table_file); pa_xfree(u); }
void pa__done(pa_module *m) { struct userdata *u; pa_assert(m); if (!(u = m->userdata)) return; if (u->udev_io) m->core->mainloop->io_free(u->udev_io); if (u->monitor) udev_monitor_unref(u->monitor); if (u->udev) udev_unref(u->udev); if (u->inotify_io) m->core->mainloop->io_free(u->inotify_io); if (u->inotify_fd >= 0) pa_close(u->inotify_fd); if (u->devices) { struct device *d; while ((d = pa_hashmap_steal_first(u->devices))) device_free(d); pa_hashmap_free(u->devices, NULL, NULL); } pa_xfree(u); }
void pa_headerlist_free(pa_headerlist* p) { struct header *hdr; while ((hdr = pa_hashmap_steal_first(MAKE_HASHMAP(p)))) header_free(hdr); pa_hashmap_free(MAKE_HASHMAP(p), NULL, NULL); }
void pa_device_port_hashmap_free(pa_hashmap *h) { pa_device_port *p; pa_assert(h); while ((p = pa_hashmap_steal_first(h))) pa_device_port_unref(p); pa_hashmap_free(h, NULL, NULL); }
void pa__done(pa_module*m) { struct userdata *u; struct device_info *d; pa_assert(m); if (!m->userdata) return; u = m->userdata; if (u->sink_new_slot) pa_hook_slot_free(u->sink_new_slot); if (u->sink_unlink_slot) pa_hook_slot_free(u->sink_unlink_slot); if (u->sink_state_changed_slot) pa_hook_slot_free(u->sink_state_changed_slot); if (u->source_new_slot) pa_hook_slot_free(u->source_new_slot); if (u->source_unlink_slot) pa_hook_slot_free(u->source_unlink_slot); if (u->source_state_changed_slot) pa_hook_slot_free(u->source_state_changed_slot); if (u->sink_input_new_slot) pa_hook_slot_free(u->sink_input_new_slot); if (u->sink_input_unlink_slot) pa_hook_slot_free(u->sink_input_unlink_slot); if (u->sink_input_move_start_slot) pa_hook_slot_free(u->sink_input_move_start_slot); if (u->sink_input_move_finish_slot) pa_hook_slot_free(u->sink_input_move_finish_slot); if (u->sink_input_state_changed_slot) pa_hook_slot_free(u->sink_input_state_changed_slot); if (u->source_output_new_slot) pa_hook_slot_free(u->source_output_new_slot); if (u->source_output_unlink_slot) pa_hook_slot_free(u->source_output_unlink_slot); if (u->source_output_move_start_slot) pa_hook_slot_free(u->source_output_move_start_slot); if (u->source_output_move_finish_slot) pa_hook_slot_free(u->source_output_move_finish_slot); if (u->source_output_state_changed_slot) pa_hook_slot_free(u->source_output_state_changed_slot); while ((d = pa_hashmap_steal_first(u->device_infos))) device_info_free(d); pa_hashmap_free(u->device_infos, NULL, NULL); pa_xfree(u); }
void pa_property_cleanup(pa_core *c) { pa_assert(c); if (!c->properties) return; pa_assert(!pa_hashmap_size(c->properties)); pa_hashmap_free(c->properties, NULL, NULL); c->properties = NULL; }
void pa_autoload_free(pa_core *c) { if (c->autoload_hashmap) { pa_hashmap_free(c->autoload_hashmap, free_func, NULL); c->autoload_hashmap = NULL; } if (c->autoload_idxset) { pa_idxset_free(c->autoload_idxset, NULL, NULL); c->autoload_idxset = NULL; } }
static void context_free(pa_context *c) { pa_assert(c); context_unlink(c); #ifdef HAVE_DBUS if (c->system_bus) { if (c->filter_added) dbus_connection_remove_filter(pa_dbus_wrap_connection_get(c->system_bus), filter_cb, c); pa_dbus_wrap_connection_free(c->system_bus); } if (c->session_bus) { if (c->filter_added) dbus_connection_remove_filter(pa_dbus_wrap_connection_get(c->session_bus), filter_cb, c); pa_dbus_wrap_connection_free(c->session_bus); } #endif if (c->record_streams) pa_hashmap_free(c->record_streams, NULL, NULL); if (c->playback_streams) pa_hashmap_free(c->playback_streams, NULL, NULL); if (c->mempool) pa_mempool_free(c->mempool); if (c->conf) pa_client_conf_free(c->conf); pa_strlist_free(c->server_list); if (c->proplist) pa_proplist_free(c->proplist); pa_xfree(c->server); pa_xfree(c); }
void pa__done(pa_module*m) { struct userdata *u; pa_assert(m); if (!m->userdata) return; u = m->userdata; pa_hashmap_free(u->device_infos); pa_xfree(u); }
static void device_port_free(pa_object *o) { pa_device_port *p = PA_DEVICE_PORT(o); pa_assert(p); pa_assert(pa_device_port_refcnt(p) == 0); if (p->proplist) pa_proplist_free(p->proplist); if (p->profiles) pa_hashmap_free(p->profiles, NULL, NULL); pa_xfree(p->name); pa_xfree(p->description); pa_xfree(p); }
void pa__done(pa_module*m) { struct userdata *u; pa_assert(m); if (!m->userdata) return; u = m->userdata; if (u->sink_new_slot) pa_hook_slot_free(u->sink_new_slot); if (u->sink_unlink_slot) pa_hook_slot_free(u->sink_unlink_slot); if (u->sink_state_changed_slot) pa_hook_slot_free(u->sink_state_changed_slot); if (u->source_new_slot) pa_hook_slot_free(u->source_new_slot); if (u->source_unlink_slot) pa_hook_slot_free(u->source_unlink_slot); if (u->source_state_changed_slot) pa_hook_slot_free(u->source_state_changed_slot); if (u->sink_input_new_slot) pa_hook_slot_free(u->sink_input_new_slot); if (u->sink_input_unlink_slot) pa_hook_slot_free(u->sink_input_unlink_slot); if (u->sink_input_move_start_slot) pa_hook_slot_free(u->sink_input_move_start_slot); if (u->sink_input_move_finish_slot) pa_hook_slot_free(u->sink_input_move_finish_slot); if (u->sink_input_state_changed_slot) pa_hook_slot_free(u->sink_input_state_changed_slot); if (u->source_output_new_slot) pa_hook_slot_free(u->source_output_new_slot); if (u->source_output_unlink_slot) pa_hook_slot_free(u->source_output_unlink_slot); if (u->source_output_move_start_slot) pa_hook_slot_free(u->source_output_move_start_slot); if (u->source_output_move_finish_slot) pa_hook_slot_free(u->source_output_move_finish_slot); if (u->source_output_state_changed_slot) pa_hook_slot_free(u->source_output_state_changed_slot); pa_hashmap_free(u->device_infos, (pa_free_cb_t) device_info_free); pa_xfree(u); }
void pa_source_new_data_done(pa_source_new_data *data) { pa_assert(data); pa_proplist_free(data->proplist); if (data->ports) { pa_device_port *p; while ((p = pa_hashmap_steal_first(data->ports))) pa_device_port_free(p); pa_hashmap_free(data->ports, NULL, NULL); } pa_xfree(data->name); pa_xfree(data->active_port); }
void pa__done(pa_module *m) { struct userdata* u; pa_assert(m); if (!(u = m->userdata)) return; if (u->client_new_slot) pa_hook_slot_free(u->client_new_slot); if (u->client_proplist_changed_slot) pa_hook_slot_free(u->client_proplist_changed_slot); if (u->cache) pa_hashmap_free(u->cache); pa_xfree(u); }
void pa__done(pa_module*m) { struct userdata*u; pa_assert(m); if (!(u = m->userdata)) return; if (u->services) { struct service *s; while ((s = pa_hashmap_first(u->services))) service_free(s); pa_hashmap_free(u->services, NULL, NULL); } if (u->sink_new_slot) pa_hook_slot_free(u->sink_new_slot); if (u->source_new_slot) pa_hook_slot_free(u->source_new_slot); if (u->sink_changed_slot) pa_hook_slot_free(u->sink_changed_slot); if (u->source_changed_slot) pa_hook_slot_free(u->source_changed_slot); if (u->sink_unlink_slot) pa_hook_slot_free(u->sink_unlink_slot); if (u->source_unlink_slot) pa_hook_slot_free(u->source_unlink_slot); if (u->main_entry_group) avahi_entry_group_free(u->main_entry_group); if (u->client) avahi_client_free(u->client); if (u->avahi_poll) pa_avahi_poll_free(u->avahi_poll); if (u->native) pa_native_protocol_unref(u->native); pa_xfree(u->service_name); pa_xfree(u); }
static void devices_free(struct pa_classify_device *devices) { struct pa_classify_device_def *d; if (devices) { for (d = devices->defs; d->type; d++) { pa_xfree((void *)d->type); if (d->data.ports) pa_hashmap_free(d->data.ports, (pa_free_cb_t) pa_classify_port_entry_free); if (d->method == pa_classify_method_matches) regfree(&d->arg.rexp); else pa_xfree((void *)d->arg.string); } pa_xfree(devices); } }
void pa__done(pa_module *m) { struct userdata* u; pa_assert(m); if (!(u = m->userdata)) return; if (u->sink_input_put_slot) pa_hook_slot_free(u->sink_input_put_slot); if (u->sink_input_unlink_slot) pa_hook_slot_free(u->sink_input_unlink_slot); if (u->sink_input_move_start_slot) pa_hook_slot_free(u->sink_input_move_start_slot); if (u->sink_input_move_finish_slot) pa_hook_slot_free(u->sink_input_move_finish_slot); if (u->cork_state) pa_hashmap_free(u->cork_state, NULL, NULL); pa_xfree(u); }
void pa__done(pa_module *m) { struct userdata* u; pa_assert(m); if (!(u = m->userdata)) return; if (u->client_new_slot) pa_hook_slot_free(u->client_new_slot); if (u->client_proplist_changed_slot) pa_hook_slot_free(u->client_proplist_changed_slot); if (u->cache) { struct rule *r; while ((r = pa_hashmap_steal_first(u->cache))) rule_free(r); pa_hashmap_free(u->cache, NULL, NULL); } pa_xfree(u); }
void pa_cond_free(pa_cond *c) { assert(c); pa_hashmap_free(c->wait_events, NULL); pa_xfree(c); }
void pa_headerlist_free(pa_headerlist* p) { pa_hashmap_free(MAKE_HASHMAP(p), (pa_free_cb_t) header_free); }
static void core_free(pa_object *o) { pa_core *c = PA_CORE(o); int j; pa_assert(c); c->state = PA_CORE_SHUTDOWN; /* Note: All modules and samples in the cache should be unloaded before * we get here */ pa_assert(pa_idxset_isempty(c->scache)); pa_idxset_free(c->scache, NULL); pa_assert(pa_idxset_isempty(c->modules)); pa_idxset_free(c->modules, NULL); pa_assert(pa_idxset_isempty(c->clients)); pa_idxset_free(c->clients, NULL); pa_assert(pa_idxset_isempty(c->cards)); pa_idxset_free(c->cards, NULL); pa_assert(pa_idxset_isempty(c->sinks)); pa_idxset_free(c->sinks, NULL); pa_assert(pa_idxset_isempty(c->sources)); pa_idxset_free(c->sources, NULL); pa_assert(pa_idxset_isempty(c->source_outputs)); pa_idxset_free(c->source_outputs, NULL); pa_assert(pa_idxset_isempty(c->sink_inputs)); pa_idxset_free(c->sink_inputs, NULL); pa_assert(pa_hashmap_isempty(c->namereg)); pa_hashmap_free(c->namereg); pa_assert(pa_hashmap_isempty(c->shared)); pa_hashmap_free(c->shared); pa_assert(pa_hashmap_isempty(c->modules_pending_unload)); pa_hashmap_free(c->modules_pending_unload); pa_subscription_free_all(c); if (c->exit_event) c->mainloop->time_free(c->exit_event); pa_assert(!c->default_source); pa_assert(!c->default_sink); pa_silence_cache_done(&c->silence_cache); if (c->rw_mempool) pa_mempool_free(c->rw_mempool); pa_mempool_free(c->mempool); for (j = 0; j < PA_CORE_HOOK_MAX; j++) pa_hook_done(&c->hooks[j]); for (j = 0; j < PA_ACCESS_HOOK_MAX; j++) pa_hook_done(&c->access[j]); pa_xfree(c); }
void pa_proplist_free(pa_proplist* p) { pa_assert(p); pa_hashmap_free(MAKE_HASHMAP(p)); }
void pa_proplist_free(pa_proplist* p) { pa_assert(p); pa_hashmap_free(MAKE_HASHMAP(p), (pa_free_cb_t) property_free); }
void pa_headerlist_free(pa_headerlist* p) { pa_hashmap_free(MAKE_HASHMAP(p)); }
void pa_proplist_free(pa_proplist* p) { pa_assert(p); pa_proplist_clear(p); pa_hashmap_free(MAKE_HASHMAP(p), NULL, NULL); }