void netlink_slot_disconnect(sd_netlink_slot *slot, bool unref) { sd_netlink *nl; assert(slot); nl = slot->netlink; if (!nl) return; switch (slot->type) { case NETLINK_REPLY_CALLBACK: (void) hashmap_remove(nl->reply_callbacks, &slot->reply_callback.serial); if (slot->reply_callback.timeout != 0) prioq_remove(nl->reply_callbacks_prioq, &slot->reply_callback, &slot->reply_callback.prioq_idx); break; case NETLINK_MATCH_CALLBACK: LIST_REMOVE(match_callbacks, nl->match_callbacks, &slot->match_callback); switch (slot->match_callback.type) { case RTM_NEWLINK: case RTM_DELLINK: (void) socket_broadcast_group_unref(nl, RTNLGRP_LINK); break; case RTM_NEWADDR: case RTM_DELADDR: (void) socket_broadcast_group_unref(nl, RTNLGRP_IPV4_IFADDR); (void) socket_broadcast_group_unref(nl, RTNLGRP_IPV6_IFADDR); break; case RTM_NEWROUTE: case RTM_DELROUTE: (void) socket_broadcast_group_unref(nl, RTNLGRP_IPV4_ROUTE); (void) socket_broadcast_group_unref(nl, RTNLGRP_IPV6_ROUTE); break; } break; default: assert_not_reached("Wut? Unknown slot type?"); } slot->type = _NETLINK_SLOT_INVALID; slot->netlink = NULL; LIST_REMOVE(slots, nl->slots, slot); if (!slot->floating) sd_netlink_unref(nl); else if (unref) sd_netlink_slot_unref(slot); }
static ClientContext* client_context_free(Server *s, ClientContext *c) { assert(s); if (!c) return NULL; assert_se(hashmap_remove(s->client_contexts, PID_TO_PTR(c->pid)) == c); if (c->in_lru) assert_se(prioq_remove(s->client_contexts_lru, c, &c->lru_index) >= 0); client_context_reset(s, c); return mfree(c); }
static void dns_cache_item_unlink_and_free(DnsCache *c, DnsCacheItem *i) { DnsCacheItem *first; assert(c); if (!i) return; first = hashmap_get(c->by_key, i->key); LIST_REMOVE(by_key, first, i); if (first) assert_se(hashmap_replace(c->by_key, first->key, first) >= 0); else hashmap_remove(c->by_key, i->key); prioq_remove(c->by_expiry, i, &i->prioq_idx); dns_cache_item_free(i); }
void bus_slot_disconnect(sd_bus_slot *slot, bool unref) { sd_bus *bus; assert(slot); if (!slot->bus) return; switch (slot->type) { case BUS_REPLY_CALLBACK: if (slot->reply_callback.cookie != 0) ordered_hashmap_remove(slot->bus->reply_callbacks, &slot->reply_callback.cookie); if (slot->reply_callback.timeout_usec != 0) prioq_remove(slot->bus->reply_callbacks_prioq, &slot->reply_callback, &slot->reply_callback.prioq_idx); break; case BUS_FILTER_CALLBACK: slot->bus->filter_callbacks_modified = true; LIST_REMOVE(callbacks, slot->bus->filter_callbacks, &slot->filter_callback); break; case BUS_MATCH_CALLBACK: if (slot->match_added) (void) bus_remove_match_internal(slot->bus, slot->match_callback.match_string); if (slot->match_callback.install_slot) { bus_slot_disconnect(slot->match_callback.install_slot, true); slot->match_callback.install_slot = sd_bus_slot_unref(slot->match_callback.install_slot); } slot->bus->match_callbacks_modified = true; bus_match_remove(&slot->bus->match_callbacks, &slot->match_callback); slot->match_callback.match_string = mfree(slot->match_callback.match_string); break; case BUS_NODE_CALLBACK: if (slot->node_callback.node) { LIST_REMOVE(callbacks, slot->node_callback.node->callbacks, &slot->node_callback); slot->bus->nodes_modified = true; bus_node_gc(slot->bus, slot->node_callback.node); } break; case BUS_NODE_ENUMERATOR: if (slot->node_enumerator.node) { LIST_REMOVE(enumerators, slot->node_enumerator.node->enumerators, &slot->node_enumerator); slot->bus->nodes_modified = true; bus_node_gc(slot->bus, slot->node_enumerator.node); } break; case BUS_NODE_OBJECT_MANAGER: if (slot->node_object_manager.node) { LIST_REMOVE(object_managers, slot->node_object_manager.node->object_managers, &slot->node_object_manager); slot->bus->nodes_modified = true; bus_node_gc(slot->bus, slot->node_object_manager.node); } break; case BUS_NODE_VTABLE: if (slot->node_vtable.node && slot->node_vtable.interface && slot->node_vtable.vtable) { const sd_bus_vtable *v; for (v = slot->node_vtable.vtable; v->type != _SD_BUS_VTABLE_END; v = bus_vtable_next(slot->node_vtable.vtable, v)) { struct vtable_member *x = NULL; switch (v->type) { case _SD_BUS_VTABLE_METHOD: { struct vtable_member key; key.path = slot->node_vtable.node->path; key.interface = slot->node_vtable.interface; key.member = v->x.method.member; x = hashmap_remove(slot->bus->vtable_methods, &key); break; } case _SD_BUS_VTABLE_PROPERTY: case _SD_BUS_VTABLE_WRITABLE_PROPERTY: { struct vtable_member key; key.path = slot->node_vtable.node->path; key.interface = slot->node_vtable.interface; key.member = v->x.method.member; x = hashmap_remove(slot->bus->vtable_properties, &key); break; }} free(x); } } slot->node_vtable.interface = mfree(slot->node_vtable.interface); if (slot->node_vtable.node) { LIST_REMOVE(vtables, slot->node_vtable.node->vtables, &slot->node_vtable); slot->bus->nodes_modified = true; bus_node_gc(slot->bus, slot->node_vtable.node); } break; default: assert_not_reached("Wut? Unknown slot type?"); } bus = slot->bus; slot->type = _BUS_SLOT_INVALID; slot->bus = NULL; LIST_REMOVE(slots, bus->slots, slot); if (!slot->floating) sd_bus_unref(bus); else if (unref) sd_bus_slot_unref(slot); }
static void test_struct(void) { Prioq *q; Set *s; unsigned previous = 0, i; int r; srand(0); q = prioq_new(test_compare); assert_se(q); s = set_new(test_hash, test_compare); assert_se(s); for (i = 0; i < SET_SIZE; i++) { struct test *t; t = new0(struct test, 1); assert_se(t); t->value = (unsigned) rand(); r = prioq_put(q, t, &t->idx); assert_se(r >= 0); if (i % 4 == 0) { r = set_consume(s, t); assert_se(r >= 0); } } for (;;) { struct test *t; t = set_steal_first(s); if (!t) break; r = prioq_remove(q, t, &t->idx); assert_se(r > 0); free(t); } for (i = 0; i < SET_SIZE * 3 / 4; i++) { struct test *t; assert_se(prioq_size(q) == (SET_SIZE * 3 / 4) - i); t = prioq_pop(q); assert_se(t); assert_se(previous <= t->value); previous = t->value; free(t); } assert_se(prioq_isempty(q)); prioq_free(q); assert_se(set_isempty(s)); set_free(s); }