shaba/systemd-stable
1
1
Fork 0
mirror of https://github.com/systemd/systemd-stable.git synced 2024-12-23 17:34:00 +03:00
Code

list: make our list macros a bit easier to use by not requring type spec on each invocation

Browse Source 
We can determine the list entry type via the typeof() gcc construct, and
so we should to make the macros much shorter to use.
This commit is contained in:
Lennart Poettering 2013-10-14 06:10:14 +02:00
parent 14bf2c9d37
commit 71fda00f32
38 changed files with 153 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
TODO
View File

@ -58,8 +58,6 @@ Features:
* tmpfiles: when applying ownership to /run/log/journal also do this for the journal fails contained in it
* rework list.h to use typeof() and thus simplify most linked list macros by not requring the type to be specified
* we probably should replace the left-over uses of strv_append() and replace them by strv_push() or strv_extend()
* move config_parse_path_strv() out of conf-parser.c

4
src/bootchart/bootchart.c
View File

@ -332,7 +332,7 @@ int main(int argc, char *argv[]) {
log_uptime();
LIST_HEAD_INIT(struct list_sample_data, head);
LIST_HEAD_INIT(head);
/* main program loop */
for (samples = 0; !exiting && samples < arg_samples_len; samples++) {
@ -406,7 +406,7 @@ int main(int argc, char *argv[]) {
/* calculate how many samples we lost and scrap them */
arg_samples_len -= (int)(newint_ns / interval);
}
LIST_PREPEND(struct list_sample_data, link, head, sampledata);
LIST_PREPEND(link, head, sampledata);
}
/* do some cleanup, close fd's */

2
src/bootchart/svg.c
View File

@ -81,7 +81,7 @@ static void svg_header(void) {
struct list_sample_data *sampledata_last;
sampledata = head;
LIST_FIND_TAIL(struct list_sample_data, link, sampledata, head);
LIST_FIND_TAIL(link, sampledata, head);
sampledata_last = head;
LIST_FOREACH_BEFORE(link, sampledata, head) {
sampledata_last = sampledata;

10
src/core/cgroup.c
View File

@ -41,7 +41,7 @@ void cgroup_context_free_device_allow(CGroupContext *c, CGroupDeviceAllow *a) {
assert(c);
assert(a);
LIST_REMOVE(CGroupDeviceAllow, device_allow, c->device_allow, a);
LIST_REMOVE(device_allow, c->device_allow, a);
free(a->path);
free(a);
}
@ -50,7 +50,7 @@ void cgroup_context_free_blockio_device_weight(CGroupContext *c, CGroupBlockIODe
assert(c);
assert(w);
LIST_REMOVE(CGroupBlockIODeviceWeight, device_weights, c->blockio_device_weights, w);
LIST_REMOVE(device_weights, c->blockio_device_weights, w);
free(w->path);
free(w);
}
@ -59,7 +59,7 @@ void cgroup_context_free_blockio_device_bandwidth(CGroupContext *c, CGroupBlockI
assert(c);
assert(b);
LIST_REMOVE(CGroupBlockIODeviceBandwidth, device_bandwidths, c->blockio_device_bandwidths, b);
LIST_REMOVE(device_bandwidths, c->blockio_device_bandwidths, b);
free(b->path);
free(b);
}
@ -426,7 +426,7 @@ static int unit_realize_cgroup_now(Unit *u) {
assert(u);
if (u->in_cgroup_queue) {
LIST_REMOVE(Unit, cgroup_queue, u->manager->cgroup_queue, u);
LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
u->in_cgroup_queue = false;
}
@ -450,7 +450,7 @@ static void unit_add_to_cgroup_queue(Unit *u) {
if (u->in_cgroup_queue)
return;
LIST_PREPEND(Unit, cgroup_queue, u->manager->cgroup_queue, u);
LIST_PREPEND(cgroup_queue, u->manager->cgroup_queue, u);
u->in_cgroup_queue = true;
}

8
src/core/dbus-cgroup.c
View File

@ -273,8 +273,7 @@ int bus_cgroup_set_property(
a->bandwidth = u64;
if (!exist)
LIST_PREPEND(CGroupBlockIODeviceBandwidth, device_bandwidths,
c->blockio_device_bandwidths, a);
LIST_PREPEND(device_bandwidths, c->blockio_device_bandwidths, a);
}
n++;
@ -369,8 +368,7 @@ int bus_cgroup_set_property(
a->weight = ul;
if (!exist)
LIST_PREPEND(CGroupBlockIODeviceWeight, device_weights,
c->blockio_device_weights, a);
LIST_PREPEND(device_weights,c->blockio_device_weights, a);
}
n++;
@ -517,7 +515,7 @@ int bus_cgroup_set_property(
a->m = !!strchr(rwm, 'm');
if (!exist)
LIST_PREPEND(CGroupDeviceAllow, device_allow, c->device_allow, a);
LIST_PREPEND(device_allow, c->device_allow, a);
}
n++;

2
src/core/dbus-job.c
View File

@ -319,7 +319,7 @@ void bus_job_send_change_signal(Job *j) {
assert(j);
if (j->in_dbus_queue) {
LIST_REMOVE(Job, dbus_queue, j->manager->dbus_job_queue, j);
LIST_REMOVE(dbus_queue, j->manager->dbus_job_queue, j);
j->in_dbus_queue = false;
}

4
src/core/dbus-unit.c
View File

@ -627,7 +627,7 @@ void bus_unit_send_change_signal(Unit *u) {
assert(u);
if (u->in_dbus_queue) {
LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
u->in_dbus_queue = false;
}
@ -801,7 +801,7 @@ DBusHandlerResult bus_unit_queue_job(
if (!cl)
goto oom;
LIST_PREPEND(JobBusClient, client, j->bus_client_list, cl);
LIST_PREPEND(client, j->bus_client_list, cl);
reply = dbus_message_new_method_return(message);
if (!reply)

2
src/core/dbus.c
View File

@ -1170,7 +1170,7 @@ static void shutdown_connection(Manager *m, DBusConnection *c) {
JobBusClient *cl, *nextcl;
LIST_FOREACH_SAFE(client, cl, nextcl, j->bus_client_list) {
if (cl->bus == c) {
LIST_REMOVE(JobBusClient, client, j->bus_client_list, cl);
LIST_REMOVE(client, j->bus_client_list, cl);
free(cl);
}
}

4
src/core/device.c
View File

@ -48,7 +48,7 @@ static void device_unset_sysfs(Device *d) {
/* Remove this unit from the chain of devices which share the
* same sysfs path. */
first = hashmap_get(UNIT(d)->manager->devices_by_sysfs, d->sysfs);
LIST_REMOVE(Device, same_sysfs, first, d);
LIST_REMOVE(same_sysfs, first, d);
if (first)
hashmap_remove_and_replace(UNIT(d)->manager->devices_by_sysfs, d->sysfs, first->sysfs, first);
@ -234,7 +234,7 @@ static int device_update_unit(Manager *m, struct udev_device *dev, const char *p
}
first = hashmap_get(m->devices_by_sysfs, sysfs);
LIST_PREPEND(Device, same_sysfs, first, DEVICE(u));
LIST_PREPEND(same_sysfs, first, DEVICE(u));
r = hashmap_replace(m->devices_by_sysfs, DEVICE(u)->sysfs, first);
if (r < 0)

6
src/core/execute.c
View File

@ -1706,7 +1706,7 @@ void exec_command_free_list(ExecCommand *c) {
ExecCommand *i;
while ((i = c)) {
LIST_REMOVE(ExecCommand, command, c, i);
LIST_REMOVE(command, c, i);
exec_command_done(i);
free(i);
}
@ -2194,8 +2194,8 @@ void exec_command_append_list(ExecCommand **l, ExecCommand *e) {
if (*l) {
/* It's kind of important, that we keep the order here */
LIST_FIND_TAIL(ExecCommand, command, *l, end);
LIST_INSERT_AFTER(ExecCommand, command, *l, end, e);
LIST_FIND_TAIL(command, *l, end);
LIST_INSERT_AFTER(command, *l, end, e);
} else
*l = e;
}

20
src/core/job.c
View File

@ -99,10 +99,10 @@ void job_free(Job *j) {
assert(!j->object_list);
if (j->in_run_queue)
LIST_REMOVE(Job, run_queue, j->manager->run_queue, j);
LIST_REMOVE(run_queue, j->manager->run_queue, j);
if (j->in_dbus_queue)
LIST_REMOVE(Job, dbus_queue, j->manager->dbus_job_queue, j);
LIST_REMOVE(dbus_queue, j->manager->dbus_job_queue, j);
if (j->timer_watch.type != WATCH_INVALID) {
assert(j->timer_watch.type == WATCH_JOB_TIMER);
@ -114,7 +114,7 @@ void job_free(Job *j) {
}
while ((cl = j->bus_client_list)) {
LIST_REMOVE(JobBusClient, client, j->bus_client_list, cl);
LIST_REMOVE(client, j->bus_client_list, cl);
free(cl);
}
free(j);
@ -267,9 +267,9 @@ JobDependency* job_dependency_new(Job *subject, Job *object, bool matters, bool
l->conflicts = conflicts;
if (subject)
LIST_PREPEND(JobDependency, subject, subject->subject_list, l);
LIST_PREPEND(subject, subject->subject_list, l);
LIST_PREPEND(JobDependency, object, object->object_list, l);
LIST_PREPEND(object, object->object_list, l);
return l;
}
@ -278,9 +278,9 @@ void job_dependency_free(JobDependency *l) {
assert(l);
if (l->subject)
LIST_REMOVE(JobDependency, subject, l->subject->subject_list, l);
LIST_REMOVE(subject, l->subject->subject_list, l);
LIST_REMOVE(JobDependency, object, l->object->object_list, l);
LIST_REMOVE(object, l->object->object_list, l);
free(l);
}
@ -491,7 +491,7 @@ int job_run_and_invalidate(Job *j) {
assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
assert(j->in_run_queue);
LIST_REMOVE(Job, run_queue, j->manager->run_queue, j);
LIST_REMOVE(run_queue, j->manager->run_queue, j);
j->in_run_queue = false;
if (j->state != JOB_WAITING)
@ -910,7 +910,7 @@ void job_add_to_run_queue(Job *j) {
if (j->in_run_queue)
return;
LIST_PREPEND(Job, run_queue, j->manager->run_queue, j);
LIST_PREPEND(run_queue, j->manager->run_queue, j);
j->in_run_queue = true;
}
@ -925,7 +925,7 @@ void job_add_to_dbus_queue(Job *j) {
* job might just have been created and not yet assigned to a
* connection/client. */
LIST_PREPEND(Job, dbus_queue, j->manager->dbus_job_queue, j);
LIST_PREPEND(dbus_queue, j->manager->dbus_job_queue, j);
j->in_dbus_queue = true;
}

22
src/core/load-fragment.c
View File

@ -300,10 +300,10 @@ int config_parse_socket_listen(const char *unit,
p->fd = -1;
if (s->ports) {
LIST_FIND_TAIL(SocketPort, port, s->ports, tail);
LIST_INSERT_AFTER(SocketPort, port, s->ports, tail, p);
LIST_FIND_TAIL(port, s->ports, tail);
LIST_INSERT_AFTER(port, s->ports, tail, p);
} else
LIST_PREPEND(SocketPort, port, s->ports, p);
LIST_PREPEND(port, s->ports, p);
return 0;
}
@ -1203,7 +1203,7 @@ int config_parse_timer(const char *unit,
v->value = u;
v->calendar_spec = c;
LIST_PREPEND(TimerValue, value, t->values, v);
LIST_PREPEND(value, t->values, v);
return 0;
}
@ -1323,7 +1323,7 @@ int config_parse_path_spec(const char *unit,
s->type = b;
s->inotify_fd = -1;
LIST_PREPEND(PathSpec, spec, p->specs, s);
LIST_PREPEND(spec, p->specs, s);
return 0;
}
@ -1657,7 +1657,7 @@ int config_parse_unit_condition_path(const char *unit,
if (!c)
return log_oom();
LIST_PREPEND(Condition, conditions, u->conditions, c);
LIST_PREPEND(conditions, u->conditions, c);
return 0;
}
@ -1712,7 +1712,7 @@ int config_parse_unit_condition_string(const char *unit,
if (!c)
return log_oom();
LIST_PREPEND(Condition, conditions, u->conditions, c);
LIST_PREPEND(conditions, u->conditions, c);
return 0;
}
@ -1766,7 +1766,7 @@ int config_parse_unit_condition_null(const char *unit,
if (!c)
return log_oom();
LIST_PREPEND(Condition, conditions, u->conditions, c);
LIST_PREPEND(conditions, u->conditions, c);
return 0;
}
@ -2128,7 +2128,7 @@ int config_parse_device_allow(
a->w = !!strchr(m, 'w');
a->m = !!strchr(m, 'm');
LIST_PREPEND(CGroupDeviceAllow, device_allow, c->device_allow, a);
LIST_PREPEND(device_allow, c->device_allow, a);
return 0;
}
@ -2234,7 +2234,7 @@ int config_parse_blockio_device_weight(
w->weight = lu;
LIST_PREPEND(CGroupBlockIODeviceWeight, device_weights, c->blockio_device_weights, w);
LIST_PREPEND(device_weights, c->blockio_device_weights, w);
return 0;
}
@ -2310,7 +2310,7 @@ int config_parse_blockio_bandwidth(
b->bandwidth = (uint64_t) bytes;
b->read = read;
LIST_PREPEND(CGroupBlockIODeviceBandwidth, device_bandwidths, c->blockio_device_bandwidths, b);
LIST_PREPEND(device_bandwidths, c->blockio_device_bandwidths, b);
return 0;
}

2
src/core/manager.c
View File

@ -676,7 +676,7 @@ static unsigned manager_dispatch_gc_queue(Manager *m) {
unit_gc_sweep(u, gc_marker);
LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
LIST_REMOVE(gc_queue, m->gc_queue, u);
u->in_gc_queue = false;
n++;

2
src/core/path.c
View File

@ -283,7 +283,7 @@ void path_free_specs(Path *p) {
while ((s = p->specs)) {
path_spec_unwatch(s, UNIT(p));
LIST_REMOVE(PathSpec, spec, p->specs, s);
LIST_REMOVE(spec, p->specs, s);
path_spec_done(s);
free(s);
}

2
src/core/socket.c
View File

@ -110,7 +110,7 @@ void socket_free_ports(Socket *s) {
assert(s);
while ((p = s->ports)) {
LIST_REMOVE(SocketPort, port, s->ports, p);
LIST_REMOVE(port, s->ports, p);
if (p->fd >= 0) {
unit_unwatch_fd(UNIT(s), &p->fd_watch);

4
src/core/swap.c
View File

@ -66,7 +66,7 @@ static void swap_unset_proc_swaps(Swap *s) {
* same kernel swap device. */
swaps = UNIT(s)->manager->swaps_by_proc_swaps;
first = hashmap_get(swaps, s->parameters_proc_swaps.what);
LIST_REMOVE(Swap, same_proc_swaps, first, s);
LIST_REMOVE(same_proc_swaps, first, s);
if (first)
hashmap_remove_and_replace(swaps,
@ -364,7 +364,7 @@ static int swap_add_one(
p->what = wp;
first = hashmap_get(m->swaps_by_proc_swaps, wp);
LIST_PREPEND(Swap, same_proc_swaps, first, SWAP(u));
LIST_PREPEND(same_proc_swaps, first, SWAP(u));
r = hashmap_replace(m->swaps_by_proc_swaps, wp, first);
if (r < 0)

2
src/core/timer.c
View File

@ -54,7 +54,7 @@ void timer_free_values(Timer *t) {
assert(t);
while ((v = t->values)) {
LIST_REMOVE(TimerValue, value, t->values, v);
LIST_REMOVE(value, t->values, v);
if (v->calendar_spec)
calendar_spec_free(v->calendar_spec);

4
src/core/transaction.c
View File

@ -775,10 +775,10 @@ static Job* transaction_add_one_job(Transaction *tr, JobType type, Unit *unit, b
j->override = override;
j->irreversible = tr->irreversible;
LIST_PREPEND(Job, transaction, f, j);
LIST_PREPEND(transaction, f, j);
if (hashmap_replace(tr->jobs, unit, f) < 0) {
LIST_REMOVE(Job, transaction, f, j);
LIST_REMOVE(transaction, f, j);
job_free(j);
return NULL;
}

20
src/core/umount.c
View File

@ -40,14 +40,14 @@
typedef struct MountPoint {
char *path;
dev_t devnum;
LIST_FIELDS (struct MountPoint, mount_point);
LIST_FIELDS(struct MountPoint, mount_point);
} MountPoint;
static void mount_point_free(MountPoint **head, MountPoint *m) {
assert(head);
assert(m);
LIST_REMOVE(MountPoint, mount_point, *head, m);
LIST_REMOVE(mount_point, *head, m);
free(m->path);
free(m);
@ -125,7 +125,7 @@ static int mount_points_list_get(MountPoint **head) {
}
m->path = p;
LIST_PREPEND(MountPoint, mount_point, *head, m);
LIST_PREPEND(mount_point, *head, m);
}
r = 0;
@ -190,7 +190,7 @@ static int swap_list_get(MountPoint **head) {
}
swap->path = d;
LIST_PREPEND(MountPoint, mount_point, *head, swap);
LIST_PREPEND(mount_point, *head, swap);
}
r = 0;
@ -250,7 +250,7 @@ static int loopback_list_get(MountPoint **head) {
}
lb->path = loop;
LIST_PREPEND(MountPoint, mount_point, *head, lb);
LIST_PREPEND(mount_point, *head, lb);
}
return 0;
@ -308,7 +308,7 @@ static int dm_list_get(MountPoint **head) {
m->path = node;
m->devnum = devnum;
LIST_PREPEND(MountPoint, mount_point, *head, m);
LIST_PREPEND(mount_point, *head, m);
}
return 0;
@ -513,7 +513,7 @@ int umount_all(bool *changed) {
bool umount_changed;
LIST_HEAD(MountPoint, mp_list_head);
LIST_HEAD_INIT(MountPoint, mp_list_head);
LIST_HEAD_INIT(mp_list_head);
r = mount_points_list_get(&mp_list_head);
if (r < 0)
goto end;
@ -543,7 +543,7 @@ int swapoff_all(bool *changed) {
int r;
LIST_HEAD(MountPoint, swap_list_head);
LIST_HEAD_INIT(MountPoint, swap_list_head);
LIST_HEAD_INIT(swap_list_head);
r = swap_list_get(&swap_list_head);
if (r < 0)
@ -561,7 +561,7 @@ int loopback_detach_all(bool *changed) {
int r;
LIST_HEAD(MountPoint, loopback_list_head);
LIST_HEAD_INIT(MountPoint, loopback_list_head);
LIST_HEAD_INIT(loopback_list_head);
r = loopback_list_get(&loopback_list_head);
if (r < 0)
@ -579,7 +579,7 @@ int dm_detach_all(bool *changed) {
int r;
LIST_HEAD(MountPoint, dm_list_head);
LIST_HEAD_INIT(MountPoint, dm_list_head);
LIST_HEAD_INIT(dm_list_head);
r = dm_list_get(&dm_list_head);
if (r < 0)

28
src/core/unit.c
View File

@ -171,7 +171,7 @@ int unit_add_name(Unit *u, const char *text) {
u->id = s;
u->instance = i;
LIST_PREPEND(Unit, units_by_type, u->manager->units_by_type[t], u);
LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
if (UNIT_VTABLE(u)->init)
UNIT_VTABLE(u)->init(u);
@ -284,7 +284,7 @@ void unit_add_to_load_queue(Unit *u) {
if (u->load_state != UNIT_STUB || u->in_load_queue)
return;
LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
LIST_PREPEND(load_queue, u->manager->load_queue, u);
u->in_load_queue = true;
}
@ -294,7 +294,7 @@ void unit_add_to_cleanup_queue(Unit *u) {
if (u->in_cleanup_queue)
return;
LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
u->in_cleanup_queue = true;
}
@ -307,7 +307,7 @@ void unit_add_to_gc_queue(Unit *u) {
if (unit_check_gc(u))
return;
LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
u->in_gc_queue = true;
u->manager->n_in_gc_queue ++;
@ -326,7 +326,7 @@ void unit_add_to_dbus_queue(Unit *u) {
return;
}
LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
u->in_dbus_queue = true;
}
@ -439,24 +439,24 @@ void unit_free(Unit *u) {
bidi_set_free(u, u->dependencies[d]);
if (u->type != _UNIT_TYPE_INVALID)
LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
if (u->in_load_queue)
LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
LIST_REMOVE(load_queue, u->manager->load_queue, u);
if (u->in_dbus_queue)
LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
if (u->in_cleanup_queue)
LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
if (u->in_gc_queue) {
LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
u->manager->n_in_gc_queue--;
}
if (u->in_cgroup_queue)
LIST_REMOVE(Unit, cgroup_queue, u->manager->cgroup_queue, u);
LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
if (u->cgroup_path) {
hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
@ -952,7 +952,7 @@ int unit_load(Unit *u) {
assert(u);
if (u->in_load_queue) {
LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
LIST_REMOVE(load_queue, u->manager->load_queue, u);
u->in_load_queue = false;
}
@ -2670,7 +2670,7 @@ Unit* unit_ref_set(UnitRef *ref, Unit *u) {
unit_ref_unset(ref);
ref->unit = u;
LIST_PREPEND(UnitRef, refs, u->refs, ref);
LIST_PREPEND(refs, u->refs, ref);
return u;
}
@ -2680,7 +2680,7 @@ void unit_ref_unset(UnitRef *ref) {
if (!ref->unit)
return;
LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
LIST_REMOVE(refs, ref->unit->refs, ref);
ref->unit = NULL;
}

4
src/initctl/initctl.c
View File

@ -251,7 +251,7 @@ static void fifo_free(Fifo *f) {
if (f->server) {
assert(f->server->n_fifos > 0);
f->server->n_fifos--;
LIST_REMOVE(Fifo, fifo, f->server->fifos, f);
LIST_REMOVE(fifo, f->server->fifos, f);
}
if (f->fd >= 0) {
@ -341,7 +341,7 @@ static int server_init(Server *s, unsigned n_sockets) {
}
f->fd = fd;
LIST_PREPEND(Fifo, fifo, s->fifos, f);
LIST_PREPEND(fifo, s->fifos, f);
f->server = s;
s->n_fifos ++;
}

8
src/journal/journald-rate-limit.c
View File

@ -96,8 +96,8 @@ static void journal_rate_limit_group_free(JournalRateLimitGroup *g) {
if (g->parent->lru_tail == g)
g->parent->lru_tail = g->lru_prev;
LIST_REMOVE(JournalRateLimitGroup, lru, g->parent->lru, g);
LIST_REMOVE(JournalRateLimitGroup, bucket, g->parent->buckets[g->hash % BUCKETS_MAX], g);
LIST_REMOVE(lru, g->parent->lru, g);
LIST_REMOVE(bucket, g->parent->buckets[g->hash % BUCKETS_MAX], g);
g->parent->n_groups --;
}
@ -156,8 +156,8 @@ static JournalRateLimitGroup* journal_rate_limit_group_new(JournalRateLimit *r,
journal_rate_limit_vacuum(r, ts);
LIST_PREPEND(JournalRateLimitGroup, bucket, r->buckets[g->hash % BUCKETS_MAX], g);
LIST_PREPEND(JournalRateLimitGroup, lru, r->lru, g);
LIST_PREPEND(bucket, r->buckets[g->hash % BUCKETS_MAX], g);
LIST_PREPEND(lru, r->lru, g);
if (!g->lru_next)
r->lru_tail = g;
r->n_groups ++;

4
src/journal/journald-stream.c
View File

@ -324,7 +324,7 @@ void stdout_stream_free(StdoutStream *s) {
if (s->server) {
assert(s->server->n_stdout_streams > 0);
s->server->n_stdout_streams --;
LIST_REMOVE(StdoutStream, stdout_stream, s->server->stdout_streams, s);
LIST_REMOVE(stdout_stream, s->server->stdout_streams, s);
}
if (s->fd >= 0) {
@ -404,7 +404,7 @@ int stdout_stream_new(Server *s) {
}
stream->server = s;
LIST_PREPEND(StdoutStream, stdout_stream, s->stdout_streams, stream);
LIST_PREPEND(stdout_stream, s->stdout_streams, stream);
s->n_stdout_streams ++;
return 0;

16
src/journal/mmap-cache.c
View File

@ -110,13 +110,13 @@ static void window_unlink(Window *w) {
munmap(w->ptr, w->size);
if (w->fd)
LIST_REMOVE(Window, by_fd, w->fd->windows, w);
LIST_REMOVE(by_fd, w->fd->windows, w);
if (w->in_unused) {
if (w->cache->last_unused == w)
w->cache->last_unused = w->unused_prev;
LIST_REMOVE(Window, unused, w->cache->unused, w);
LIST_REMOVE(unused, w->cache->unused, w);
}
LIST_FOREACH(by_window, c, w->contexts) {
@ -180,11 +180,11 @@ static void context_detach_window(Context *c) {
w = c->window;
c->window = NULL;
LIST_REMOVE(Context, by_window, w->contexts, c);
LIST_REMOVE(by_window, w->contexts, c);
if (!w->contexts && !w->keep_always) {
/* Not used anymore? */
LIST_PREPEND(Window, unused, c->cache->unused, w);
LIST_PREPEND(unused, c->cache->unused, w);
if (!c->cache->last_unused)
c->cache->last_unused = w;
@ -203,7 +203,7 @@ static void context_attach_window(Context *c, Window *w) {
if (w->in_unused) {
/* Used again? */
LIST_REMOVE(Window, unused, c->cache->unused, w);
LIST_REMOVE(unused, c->cache->unused, w);
if (c->cache->last_unused == w)
c->cache->last_unused = w->unused_prev;
@ -211,7 +211,7 @@ static void context_attach_window(Context *c, Window *w) {
}
c->window = w;
LIST_PREPEND(Context, by_window, w->contexts, c);
LIST_PREPEND(by_window, w->contexts, c);
}
static Context *context_add(MMapCache *m, unsigned id) {
@ -511,11 +511,11 @@ static int add_mmap(
w->size = wsize;
w->fd = f;
LIST_PREPEND(Window, by_fd, f->windows, w);
LIST_PREPEND(by_fd, f->windows, w);
context_detach_window(c);
c->window = w;
LIST_PREPEND(Context, by_window, w->contexts, c);
LIST_PREPEND(by_window, w->contexts, c);
*ret = (uint8_t*) w->ptr + (offset - w->offset);
return 1;

4
src/journal/sd-journal.c
View File

@ -186,7 +186,7 @@ static Match *match_new(Match *p, MatchType t) {
if (p) {
m->parent = p;
LIST_PREPEND(Match, matches, p->matches, m);
LIST_PREPEND(matches, p->matches, m);
}
return m;
@ -199,7 +199,7 @@ static void match_free(Match *m) {
match_free(m->matches);
if (m->parent)
LIST_REMOVE(Match, matches, m->parent->matches, m);
LIST_REMOVE(matches, m->parent->matches, m);
free(m->data);
free(m);

16
src/libsystemd-bus/bus-objects.c
View File

@ -1196,7 +1196,7 @@ static struct node *bus_node_allocate(sd_bus *bus, const char *path) {
}
if (parent)
LIST_PREPEND(struct node, siblings, parent->child, n);
LIST_PREPEND(siblings, parent->child, n);
return n;
}
@ -1217,7 +1217,7 @@ static void bus_node_gc(sd_bus *b, struct node *n) {
assert(hashmap_remove(b->nodes, n->path) == n);
if (n->parent)
LIST_REMOVE(struct node, siblings, n->parent->child, n);
LIST_REMOVE(siblings, n->parent->child, n);
free(n->path);
bus_node_gc(b, n->parent);
@ -1255,7 +1255,7 @@ static int bus_add_object(
c->userdata = userdata;
c->is_fallback = fallback;
LIST_PREPEND(struct node_callback, callbacks, n->callbacks, c);
LIST_PREPEND(callbacks, n->callbacks, c);
return 0;
fail:
@ -1289,7 +1289,7 @@ static int bus_remove_object(
if (!c)
return 0;
LIST_REMOVE(struct node_callback, callbacks, n->callbacks, c);
LIST_REMOVE(callbacks, n->callbacks, c);
free(c);
bus_node_gc(bus, n);
@ -1546,7 +1546,7 @@ static int add_object_vtable_internal(
}
}
LIST_PREPEND(struct node_vtable, vtables, n->vtables, c);
LIST_PREPEND(vtables, n->vtables, c);
return 0;
fail:
@ -1582,7 +1582,7 @@ static int remove_object_vtable_internal(
if (!c)
return 0;
LIST_REMOVE(struct node_vtable, vtables, n->vtables, c);
LIST_REMOVE(vtables, n->vtables, c);
free_node_vtable(bus, c);
bus_node_gc(bus, n);
@ -1656,7 +1656,7 @@ int sd_bus_add_node_enumerator(
c->callback = callback;
c->userdata = userdata;
LIST_PREPEND(struct node_enumerator, enumerators, n->enumerators, c);
LIST_PREPEND(enumerators, n->enumerators, c);
return 0;
fail:
@ -1690,7 +1690,7 @@ int sd_bus_remove_node_enumerator(
if (!c)
return 0;
LIST_REMOVE(struct node_enumerator, enumerators, n->enumerators, c);
LIST_REMOVE(enumerators, n->enumerators, c);
free(c);
bus_node_gc(bus, n);

14
src/libsystemd-bus/sd-bus.c
View File

@ -74,23 +74,23 @@ static void bus_node_destroy(sd_bus *b, struct node *n) {
bus_node_destroy(b, n->child);
while ((c = n->callbacks)) {
LIST_REMOVE(struct node_callback, callbacks, n->callbacks, c);
LIST_REMOVE(callbacks, n->callbacks, c);
free(c);
}
while ((v = n->vtables)) {
LIST_REMOVE(struct node_vtable, vtables, n->vtables, v);
LIST_REMOVE(vtables, n->vtables, v);
free(v->interface);
free(v);
}
while ((e = n->enumerators)) {
LIST_REMOVE(struct node_enumerator, enumerators, n->enumerators, e);
LIST_REMOVE(enumerators, n->enumerators, e);
free(e);
}
if (n->parent)
LIST_REMOVE(struct node, siblings, n->parent->child, n);
LIST_REMOVE(siblings, n->parent->child, n);
assert_se(hashmap_remove(b->nodes, n->path) == n);
free(n->path);
@ -133,7 +133,7 @@ static void bus_free(sd_bus *b) {
prioq_free(b->reply_callbacks_prioq);
while ((f = b->filter_callbacks)) {
LIST_REMOVE(struct filter_callback, callbacks, b->filter_callbacks, f);
LIST_REMOVE(callbacks, b->filter_callbacks, f);
free(f);
}
@ -2127,7 +2127,7 @@ int sd_bus_add_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *user
f->userdata = userdata;
bus->filter_callbacks_modified = true;
LIST_PREPEND(struct filter_callback, callbacks, bus->filter_callbacks, f);
LIST_PREPEND(callbacks, bus->filter_callbacks, f);
return 0;
}
@ -2144,7 +2144,7 @@ int sd_bus_remove_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *u
LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
if (f->callback == callback && f->userdata == userdata) {
bus->filter_callbacks_modified = true;
LIST_REMOVE(struct filter_callback, callbacks, bus->filter_callbacks, f);
LIST_REMOVE(callbacks, bus->filter_callbacks, f);
free(f);
return 1;
}

6
src/login/logind-device.c
View File

@ -77,7 +77,7 @@ void device_detach(Device *d) {
session_device_free(sd);
s = d->seat;
LIST_REMOVE(Device, devices, d->seat->devices, d);
LIST_REMOVE(devices, d->seat->devices, d);
d->seat = NULL;
if (!seat_has_master_device(s)) {
@ -110,11 +110,11 @@ void device_attach(Device *d, Seat *s) {
* per seat, so we iterate only a few times. */
if (d->master || !s->devices)
LIST_PREPEND(Device, devices, s->devices, d);
LIST_PREPEND(devices, s->devices, d);
else {
LIST_FOREACH(devices, i, s->devices) {
if (!i->devices_next || !i->master) {
LIST_INSERT_AFTER(Device, devices, s->devices, i, d);
LIST_INSERT_AFTER(devices, s->devices, i, d);
break;
}
}

6
src/login/logind-seat.c
View File

@ -67,7 +67,7 @@ void seat_free(Seat *s) {
assert(s);
if (s->in_gc_queue)
LIST_REMOVE(Seat, gc_queue, s->manager->seat_gc_queue, s);
LIST_REMOVE(gc_queue, s->manager->seat_gc_queue, s);
while (s->sessions)
session_free(s->sessions);
@ -415,7 +415,7 @@ int seat_attach_session(Seat *s, Session *session) {
assert(!session->seat);
session->seat = s;
LIST_PREPEND(Session, sessions_by_seat, s->sessions, session);
LIST_PREPEND(sessions_by_seat, s->sessions, session);
seat_send_changed(s, "Sessions\0");
@ -533,7 +533,7 @@ void seat_add_to_gc_queue(Seat *s) {
if (s->in_gc_queue)
return;
LIST_PREPEND(Seat, gc_queue, s->manager->seat_gc_queue, s);
LIST_PREPEND(gc_queue, s->manager->seat_gc_queue, s);
s->in_gc_queue = true;
}

4
src/login/logind-session-device.c
View File

@ -390,7 +390,7 @@ int session_device_new(Session *s, dev_t dev, SessionDevice **out) {
}
sd->fd = r;
LIST_PREPEND(SessionDevice, sd_by_device, sd->device->session_devices, sd);
LIST_PREPEND(sd_by_device, sd->device->session_devices, sd);
*out = sd;
return 0;
@ -409,7 +409,7 @@ void session_device_free(SessionDevice *sd) {
session_device_notify(sd, SESSION_DEVICE_RELEASE);
close_nointr_nofail(sd->fd);
LIST_REMOVE(SessionDevice, sd_by_device, sd->device->session_devices, sd);
LIST_REMOVE(sd_by_device, sd->device->session_devices, sd);
hashmap_remove(sd->session->devices, &sd->dev);

10
src/login/logind-session.c
View File

@ -96,7 +96,7 @@ void session_free(Session *s) {
assert(s);
if (s->in_gc_queue)
LIST_REMOVE(Session, gc_queue, s->manager->session_gc_queue, s);
LIST_REMOVE(gc_queue, s->manager->session_gc_queue, s);
session_drop_controller(s);
@ -106,7 +106,7 @@ void session_free(Session *s) {
hashmap_free(s->devices);
if (s->user) {
LIST_REMOVE(Session, sessions_by_user, s->user->sessions, s);
LIST_REMOVE(sessions_by_user, s->user->sessions, s);
if (s->user->display == s)
s->user->display = NULL;
@ -118,7 +118,7 @@ void session_free(Session *s) {
if (s->seat->pending_switch == s)
s->seat->pending_switch = NULL;
LIST_REMOVE(Session, sessions_by_seat, s->seat->sessions, s);
LIST_REMOVE(sessions_by_seat, s->seat->sessions, s);
}
if (s->scope) {
@ -149,7 +149,7 @@ void session_set_user(Session *s, User *u) {
assert(!s->user);
s->user = u;
LIST_PREPEND(Session, sessions_by_user, u->sessions, s);
LIST_PREPEND(sessions_by_user, u->sessions, s);
}
int session_save(Session *s) {
@ -938,7 +938,7 @@ void session_add_to_gc_queue(Session *s) {
if (s->in_gc_queue)
return;
LIST_PREPEND(Session, gc_queue, s->manager->session_gc_queue, s);
LIST_PREPEND(gc_queue, s->manager->session_gc_queue, s);
s->in_gc_queue = true;
}

4
src/login/logind-user.c
View File

@ -72,7 +72,7 @@ void user_free(User *u) {
assert(u);
if (u->in_gc_queue)
LIST_REMOVE(User, gc_queue, u->manager->user_gc_queue, u);
LIST_REMOVE(gc_queue, u->manager->user_gc_queue, u);
while (u->sessions)
session_free(u->sessions);
@ -644,7 +644,7 @@ void user_add_to_gc_queue(User *u) {
if (u->in_gc_queue)
return;
LIST_PREPEND(User, gc_queue, u->manager->user_gc_queue, u);
LIST_PREPEND(gc_queue, u->manager->user_gc_queue, u);
u->in_gc_queue = true;
}

6
src/login/logind.c
View File

@ -929,7 +929,7 @@ void manager_gc(Manager *m, bool drop_not_started) {
assert(m);
while ((seat = m->seat_gc_queue)) {
LIST_REMOVE(Seat, gc_queue, m->seat_gc_queue, seat);
LIST_REMOVE(gc_queue, m->seat_gc_queue, seat);
seat->in_gc_queue = false;
if (seat_check_gc(seat, drop_not_started) == 0) {
@ -939,7 +939,7 @@ void manager_gc(Manager *m, bool drop_not_started) {
}
while ((session = m->session_gc_queue)) {
LIST_REMOVE(Session, gc_queue, m->session_gc_queue, session);
LIST_REMOVE(gc_queue, m->session_gc_queue, session);
session->in_gc_queue = false;
if (session_check_gc(session, drop_not_started) == 0) {
@ -950,7 +950,7 @@ void manager_gc(Manager *m, bool drop_not_started) {
}
while ((user = m->user_gc_queue)) {
LIST_REMOVE(User, gc_queue, m->user_gc_queue, user);
LIST_REMOVE(gc_queue, m->user_gc_queue, user);
user->in_gc_queue = false;
if (user_check_gc(user, drop_not_started) == 0) {

4
src/machine/machine.c
View File

@ -73,7 +73,7 @@ void machine_free(Machine *m) {
assert(m);
if (m->in_gc_queue)
LIST_REMOVE(Machine, gc_queue, m->manager->machine_gc_queue, m);
LIST_REMOVE(gc_queue, m->manager->machine_gc_queue, m);
if (m->scope) {
hashmap_remove(m->manager->machine_units, m->scope);
@ -369,7 +369,7 @@ void machine_add_to_gc_queue(Machine *m) {
if (m->in_gc_queue)
return;
LIST_PREPEND(Machine, gc_queue, m->manager->machine_gc_queue, m);
LIST_PREPEND(gc_queue, m->manager->machine_gc_queue, m);
m->in_gc_queue = true;
}

2
src/machine/machined.c
View File

@ -249,7 +249,7 @@ void manager_gc(Manager *m, bool drop_not_started) {
assert(m);
while ((machine = m->machine_gc_queue)) {
LIST_REMOVE(Machine, gc_queue, m->machine_gc_queue, machine);
LIST_REMOVE(gc_queue, m->machine_gc_queue, machine);
machine->in_gc_queue = false;
if (machine_check_gc(machine, drop_not_started) == 0) {

26
src/shared/list.h
View File

@ -31,23 +31,23 @@
t *name##_next, *name##_prev
/* Initialize the list's head */
#define LIST_HEAD_INIT(t,head) \
#define LIST_HEAD_INIT(head) \
do { \
(head) = NULL; } \
while(false)
/* Initialize a list item */
#define LIST_INIT(t,name,item) \
#define LIST_INIT(name,item) \
do { \
t *_item = (item); \
typeof(*(item)) *_item = (item); \
assert(_item); \
_item->name##_prev = _item->name##_next = NULL; \
} while(false)
/* Prepend an item to the list */
#define LIST_PREPEND(t,name,head,item) \
#define LIST_PREPEND(name,head,item) \
do { \
t **_head = &(head), *_item = (item); \
typeof(*(head)) **_head = &(head), *_item = (item); \
assert(_item); \
if ((_item->name##_next = *_head)) \
_item->name##_next->name##_prev = _item; \
@ -56,9 +56,9 @@
} while(false)
/* Remove an item from the list */
#define LIST_REMOVE(t,name,head,item) \
#define LIST_REMOVE(name,head,item) \
do { \
t **_head = &(head), *_item = (item); \
typeof(*(head)) **_head = &(head), *_item = (item); \
assert(_item); \
if (_item->name##_next) \
_item->name##_next->name##_prev = _item->name##_prev; \
@ -72,9 +72,9 @@
} while(false)
/* Find the head of the list */
#define LIST_FIND_HEAD(t,name,item,head) \
#define LIST_FIND_HEAD(name,item,head) \
do { \
t *_item = (item); \
typeof(*(item)) *_item = (item); \
assert(_item); \
while (_item->name##_prev) \
_item = _item->name##_prev; \
@ -82,9 +82,9 @@
} while (false)
/* Find the tail of the list */
#define LIST_FIND_TAIL(t,name,item,tail) \
#define LIST_FIND_TAIL(name,item,tail) \
do { \
t *_item = (item); \
typeof(*(item)) *_item = (item); \
assert(_item); \
while (_item->name##_next) \
_item = _item->name##_next; \
@ -92,9 +92,9 @@
} while (false)
/* Insert an item after another one (a = where, b = what) */
#define LIST_INSERT_AFTER(t,name,head,a,b) \
#define LIST_INSERT_AFTER(name,head,a,b) \
do { \
t **_head = &(head), *_a = (a), *_b = (b); \
typeof(*(head)) **_head = &(head), *_a = (a), *_b = (b); \
assert(_b); \
if (!_a) { \
if ((_b->name##_next = *_head)) \

4
src/systemctl/systemctl.c
View File

@ -3019,7 +3019,7 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn
return r;
}
LIST_PREPEND(ExecStatusInfo, exec, i->exec, info);
LIST_PREPEND(exec, i->exec, info);
dbus_message_iter_next(&sub);
}
@ -3474,7 +3474,7 @@ static int show_one(const char *verb,
}
while ((p = info.exec)) {
LIST_REMOVE(ExecStatusInfo, exec, info.exec, p);
LIST_REMOVE(exec, info.exec, p);
exec_status_info_free(p);
}

22
src/test/test-list.c
View File

@ -29,13 +29,13 @@ int main(int argc, const char *argv[]) {
list_item items[4];
list_item *cursor;
LIST_HEAD_INIT(list_item, head);
LIST_HEAD_INIT(head);
assert_se(head == NULL);
for (i = 0; i < ELEMENTSOF(items); i++) {
LIST_INIT(list_item, item, &items[i]);
LIST_INIT(item, &items[i]);
assert_se(LIST_JUST_US(item, &items[i]));
LIST_PREPEND(list_item, item, head, &items[i]);
LIST_PREPEND(item, head, &items[i]);
}
assert_se(!LIST_JUST_US(item, head));
@ -50,13 +50,13 @@ int main(int argc, const char *argv[]) {
assert_se(items[2].item_prev == &items[3]);
assert_se(items[3].item_prev == NULL);
LIST_FIND_HEAD(list_item, item, &items[0], cursor);
LIST_FIND_HEAD(item, &items[0], cursor);
assert_se(cursor == &items[3]);
LIST_FIND_TAIL(list_item, item, &items[3], cursor);
LIST_FIND_TAIL(item, &items[3], cursor);
assert_se(cursor == &items[0]);
LIST_REMOVE(list_item, item, head, &items[1]);
LIST_REMOVE(item, head, &items[1]);
assert_se(LIST_JUST_US(item, &items[1]));
assert_se(items[0].item_next == NULL);
@ -67,7 +67,7 @@ int main(int argc, const char *argv[]) {
assert_se(items[2].item_prev == &items[3]);
assert_se(items[3].item_prev == NULL);
LIST_INSERT_AFTER(list_item, item, head, &items[3], &items[1]);
LIST_INSERT_AFTER(item, head, &items[3], &items[1]);
assert_se(items[0].item_next == NULL);
assert_se(items[2].item_next == &items[0]);
assert_se(items[1].item_next == &items[2]);
@ -78,7 +78,7 @@ int main(int argc, const char *argv[]) {
assert_se(items[1].item_prev == &items[3]);
assert_se(items[3].item_prev == NULL);
LIST_REMOVE(list_item, item, head, &items[0]);
LIST_REMOVE(item, head, &items[0]);
assert_se(LIST_JUST_US(item, &items[0]));
assert_se(items[2].item_next == NULL);
@ -89,7 +89,7 @@ int main(int argc, const char *argv[]) {
assert_se(items[1].item_prev == &items[3]);
assert_se(items[3].item_prev == NULL);
LIST_REMOVE(list_item, item, head, &items[1]);
LIST_REMOVE(item, head, &items[1]);
assert_se(LIST_JUST_US(item, &items[1]));
assert_se(items[2].item_next == NULL);
@ -98,11 +98,11 @@ int main(int argc, const char *argv[]) {
assert_se(items[2].item_prev == &items[3]);
assert_se(items[3].item_prev == NULL);
LIST_REMOVE(list_item, item, head, &items[2]);
LIST_REMOVE(item, head, &items[2]);
assert_se(LIST_JUST_US(item, &items[2]));
assert_se(LIST_JUST_US(item, head));
LIST_REMOVE(list_item, item, head, &items[3]);
LIST_REMOVE(item, head, &items[3]);
assert_se(LIST_JUST_US(item, &items[3]));
return 0;