* place /etc/inittab with explaining blurb.
* In command lines, support both "$FOO" and $FOO
-
* /etc must always take precedence even if we follow symlinks!
+* fix merging of device units
+* color aus bei stdout auf !tty
+
+getty before prefdm
* /lib/init/rw
* fingerprint.target, wireless.target, gps.target
-* fix merging of device units
-
* set_put(), hashmap_put() return values checken. i.e. == 0 macht kein free()!
+* crash on missing hostname
+
+* fix merging in .swap units
+
* pahole
-* color aus bei stdout auf !tty
+* io priority
+
+* network.target darf nm nicht unbedingt starten
External:
they are set or not.</para></listitem>
</varlistentry>
+ <varlistentry>
+ <term><option>--full</option></term>
+
+ <listitem><para>Do not ellipsize unit
+ names in the output of
+ <command>list-units</command> and
+ <command>list-jobs</command>.</para></listitem>
+ </varlistentry>
+
<varlistentry>
<term><option>--fail</option></term>
" <method name=\"ClearJobs\"/>\n" \
" <method name=\"ResetMaintenance\"/>\n" \
" <method name=\"ListUnits\">\n" \
- " <arg name=\"units\" type=\"a(sssssouso)\" direction=\"out\"/>\n" \
+ " <arg name=\"units\" type=\"a(ssssssouso)\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"ListJobs\">\n" \
" <arg name=\"jobs\" type=\"a(usssoo)\" direction=\"out\"/>\n" \
dbus_message_iter_init_append(reply, &iter);
- if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sssssouso)", &sub))
+ if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(ssssssouso)", &sub))
goto oom;
HASHMAP_FOREACH_KEY(u, k, m->units, i) {
char *u_path, *j_path;
- const char *description, *load_state, *active_state, *sub_state, *sjob_type;
+ const char *description, *load_state, *active_state, *sub_state, *sjob_type, *following;
DBusMessageIter sub2;
uint32_t job_id;
load_state = unit_load_state_to_string(u->meta.load_state);
active_state = unit_active_state_to_string(unit_active_state(u));
sub_state = unit_sub_state_to_string(u);
+ following = u->meta.following ? u->meta.following->meta.id : "";
if (!(u_path = unit_dbus_path(u)))
goto oom;
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &load_state) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &active_state) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &sub_state) ||
+ !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &following) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &u_path) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &job_id) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &sjob_type) ||
return 0;
}
+int bus_unit_append_following(Manager *m, DBusMessageIter *i, const char *property, void *data) {
+ Unit *u = data;
+ const char *d;
+
+ assert(m);
+ assert(i);
+ assert(property);
+ assert(u);
+
+ d = u->meta.following ? u->meta.following->meta.id : "";
+
+ if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &d))
+ return -ENOMEM;
+
+ return 0;
+}
+
int bus_unit_append_dependencies(Manager *m, DBusMessageIter *i, const char *property, void *data) {
Unit *u;
Iterator j;
" <signal name=\"Changed\"/>\n" \
" <property name=\"Id\" type=\"s\" access=\"read\"/>\n" \
" <property name=\"Names\" type=\"as\" access=\"read\"/>\n" \
+ " <property name=\"Following\" type=\"s\" access=\"read\"/>\n" \
" <property name=\"Requires\" type=\"as\" access=\"read\"/>\n" \
" <property name=\"RequiresOverridable\" type=\"as\" access=\"read\"/>\n" \
" <property name=\"Requisite\" type=\"as\" access=\"read\"/>\n" \
#define BUS_UNIT_PROPERTIES \
{ "org.freedesktop.systemd1.Unit", "Id", bus_property_append_string, "s", u->meta.id }, \
{ "org.freedesktop.systemd1.Unit", "Names", bus_unit_append_names, "as", u }, \
+ { "org.freedesktop.systemd1.Unit", "Following", bus_unit_append_following, "s", u }, \
{ "org.freedesktop.systemd1.Unit", "Requires", bus_unit_append_dependencies, "as", u->meta.dependencies[UNIT_REQUIRES] }, \
{ "org.freedesktop.systemd1.Unit", "RequiresOverridable", bus_unit_append_dependencies, "as", u->meta.dependencies[UNIT_REQUIRES_OVERRIDABLE] }, \
{ "org.freedesktop.systemd1.Unit", "Requisite", bus_unit_append_dependencies, "as", u->meta.dependencies[UNIT_REQUISITE] }, \
{ "org.freedesktop.systemd1.Unit", "JobTimeoutUSec", bus_property_append_usec, "t", &u->meta.job_timeout }
int bus_unit_append_names(Manager *m, DBusMessageIter *i, const char *property, void *data);
+int bus_unit_append_following(Manager *m, DBusMessageIter *i, const char *property, void *data);
int bus_unit_append_dependencies(Manager *m, DBusMessageIter *i, const char *property, void *data);
int bus_unit_append_description(Manager *m, DBusMessageIter *i, const char *property, void *data);
int bus_unit_append_load_state(Manager *m, DBusMessageIter *i, const char *property, void *data);
[DEVICE_PLUGGED] = UNIT_ACTIVE
};
+static void device_unset_sysfs(Device *d) {
+ Device *first;
+
+ assert(d);
+
+ if (d->sysfs) {
+ /* Remove this unit from the chain of devices which share the
+ * same sysfs path. */
+ first = hashmap_get(d->meta.manager->devices_by_sysfs, d->sysfs);
+ LIST_REMOVE(Device, same_sysfs, first, d);
+
+ if (first)
+ hashmap_remove_and_replace(d->meta.manager->devices_by_sysfs, d->sysfs, first->sysfs, first);
+ else
+ hashmap_remove(d->meta.manager->devices_by_sysfs, d->sysfs);
+
+ free(d->sysfs);
+ d->sysfs = NULL;
+ }
+
+ d->meta.following = NULL;
+}
+
static void device_init(Unit *u) {
Device *d = DEVICE(u);
assert(d);
assert(d->meta.load_state == UNIT_STUB);
+ /* In contrast to all other unit types we timeout jobs waiting
+ * for devices by default. This is because they otherwise wait
+ * indefinetely for plugged in devices, something which cannot
+ * happen for the other units since their operations time out
+ * anyway. */
d->meta.job_timeout = DEFAULT_TIMEOUT_USEC;
}
assert(d);
- free(d->sysfs);
- d->sysfs = NULL;
+ device_unset_sysfs(d);
}
static void device_set_state(Device *d, DeviceState state) {
return device_state_to_string(DEVICE(u)->state);
}
-static int device_add_escaped_name(Unit *u, const char *dn, bool make_id) {
+static int device_add_escaped_name(Unit *u, const char *dn) {
char *e;
int r;
return -ENOMEM;
r = unit_add_name(u, e);
-
- if (r >= 0 && make_id)
- unit_choose_id(u, e);
-
free(e);
if (r < 0 && r != -EEXIST)
return 0;
}
-static int device_process_new_device(Manager *m, struct udev_device *dev, bool update_state) {
- const char *dn, *wants, *sysfs, *model, *alias;
+static int device_update_unit(Manager *m, struct udev_device *dev, const char *path, bool main) {
+ const char *sysfs, *model;
Unit *u = NULL;
int r;
- char *w, *state;
- size_t l;
bool delete;
- struct udev_list_entry *item = NULL, *first = NULL;
assert(m);
if (!(sysfs = udev_device_get_syspath(dev)))
return -ENOMEM;
- /* Check whether this entry is even relevant for us. */
- dn = udev_device_get_devnode(dev);
- wants = udev_device_get_property_value(dev, "SYSTEMD_WANTS");
- alias = udev_device_get_property_value(dev, "SYSTEMD_ALIAS");
-
- /* We allow exactly one alias to be configured a this time and
- * it must be a path */
-
- if (alias && !is_path(alias)) {
- log_warning("SYSTEMD_ALIAS for %s is not a path, ignoring: %s", sysfs, alias);
- alias = NULL;
- }
-
- if ((r = device_find_escape_name(m, sysfs, &u)) < 0)
+ if ((r = device_find_escape_name(m, path, &u)) < 0)
return r;
- if (r == 0 && dn)
- if ((r = device_find_escape_name(m, dn, &u)) < 0)
- return r;
-
- if (r == 0) {
- first = udev_device_get_devlinks_list_entry(dev);
- udev_list_entry_foreach(item, first) {
- if ((r = device_find_escape_name(m, udev_list_entry_get_name(item), &u)) < 0)
- return r;
-
- if (r > 0)
- break;
- }
- }
-
- if (r == 0 && alias)
- if ((r = device_find_escape_name(m, alias, &u)) < 0)
- return r;
-
- /* FIXME: this needs proper merging */
-
- assert((r > 0) == !!u);
-
/* If this is a different unit, then let's not merge things */
- if (u && DEVICE(u)->sysfs && !path_equal(DEVICE(u)->sysfs, sysfs))
- u = NULL;
+ if (u && DEVICE(u)->sysfs && !path_equal(DEVICE(u)->sysfs, sysfs)) {
+ log_error("Hmm, something's broken. Asked to create two devices with same name but different sysfs paths.");
+ return -EEXIST;
+ }
if (!u) {
+ Device *first;
delete = true;
if (!(u = unit_new(m)))
return -ENOMEM;
- if ((r = device_add_escaped_name(u, sysfs, true)) < 0)
+ if ((r = device_add_escaped_name(u, path)) < 0)
goto fail;
- unit_add_to_load_queue(u);
- } else
- delete = false;
-
- if (!(DEVICE(u)->sysfs))
if (!(DEVICE(u)->sysfs = strdup(sysfs))) {
r = -ENOMEM;
goto fail;
}
- if (alias)
- if ((r = device_add_escaped_name(u, alias, true)) < 0)
- goto fail;
+ unit_add_to_load_queue(u);
- if (dn)
- if ((r = device_add_escaped_name(u, dn, true)) < 0)
- goto fail;
+ if (!m->devices_by_sysfs)
+ if (!(m->devices_by_sysfs = hashmap_new(string_hash_func, string_compare_func))) {
+ r = -ENOMEM;
+ goto fail;
+ }
- first = udev_device_get_devlinks_list_entry(dev);
- udev_list_entry_foreach(item, first)
- if ((r = device_add_escaped_name(u, udev_list_entry_get_name(item), false)) < 0)
+ first = hashmap_get(m->devices_by_sysfs, sysfs);
+ LIST_PREPEND(Device, same_sysfs, first, DEVICE(u));
+
+ if ((r = hashmap_replace(m->devices_by_sysfs, DEVICE(u)->sysfs, first)) < 0)
goto fail;
+ } else
+ delete = false;
+
if ((model = udev_device_get_property_value(dev, "ID_MODEL_FROM_DATABASE")) ||
(model = udev_device_get_property_value(dev, "ID_MODEL"))) {
if ((r = unit_set_description(u, model)) < 0)
goto fail;
- } else if (dn) {
- if ((r = unit_set_description(u, dn)) < 0)
- goto fail;
} else
- if ((r = unit_set_description(u, sysfs)) < 0)
+ if ((r = unit_set_description(u, path)) < 0)
goto fail;
- if (wants) {
- FOREACH_WORD_QUOTED(w, l, wants, state) {
- char *e;
-
- if (!(e = strndup(w, l))) {
- r = -ENOMEM;
- goto fail;
+ if (main) {
+ /* The additional systemd udev properties we only
+ * interpret for the main object */
+ const char *wants, *alias;
+
+ if ((alias = udev_device_get_property_value(dev, "SYSTEMD_ALIAS"))) {
+ if (!is_path(alias))
+ log_warning("SYSTEMD_ALIAS for %s is not a path, ignoring: %s", sysfs, alias);
+ else {
+ if ((r = device_add_escaped_name(u, alias)) < 0)
+ goto fail;
}
+ }
- r = unit_add_dependency_by_name(u, UNIT_WANTS, e, NULL, true);
- free(e);
+ if ((wants = udev_device_get_property_value(dev, "SYSTEMD_WANTS"))) {
+ char *state, *w;
+ size_t l;
- if (r < 0)
- goto fail;
+ FOREACH_WORD_QUOTED(w, l, wants, state) {
+ char *e;
+
+ if (!(e = strndup(w, l))) {
+ r = -ENOMEM;
+ goto fail;
+ }
+
+ r = unit_add_dependency_by_name(u, UNIT_WANTS, e, NULL, true);
+ free(e);
+
+ if (r < 0)
+ goto fail;
+ }
}
- }
- if (update_state) {
- manager_dispatch_load_queue(u->meta.manager);
- device_set_state(DEVICE(u), DEVICE_PLUGGED);
- }
+ u->meta.following = NULL;
+ } else
+ device_find_escape_name(m, sysfs, &u->meta.following);
unit_add_to_dbus_queue(u);
-
return 0;
fail:
-
log_warning("Failed to load device unit: %s", strerror(-r));
if (delete && u)
return r;
}
+static int device_process_new_device(Manager *m, struct udev_device *dev, bool update_state) {
+ const char *sysfs, *dn;
+ struct udev_list_entry *item = NULL, *first = NULL;
+
+ assert(m);
+
+ if (!(sysfs = udev_device_get_syspath(dev)))
+ return -ENOMEM;
+
+ /* Add the main unit named after the sysfs path */
+ device_update_unit(m, dev, sysfs, true);
+
+ /* Add an additional unit for the device node */
+ if ((dn = udev_device_get_devnode(dev)))
+ device_update_unit(m, dev, dn, false);
+
+ /* Add additional units for all symlinks */
+ first = udev_device_get_devlinks_list_entry(dev);
+ udev_list_entry_foreach(item, first) {
+ const char *p;
+
+ /* Don't bother with the /dev/block links */
+ p = udev_list_entry_get_name(item);
+
+ if (path_startswith(p, "/dev/block/") ||
+ path_startswith(p, "/dev/char/"))
+ continue;
+
+ device_update_unit(m, dev, p, false);
+ }
+
+ if (update_state) {
+ Device *d, *l;
+
+ manager_dispatch_load_queue(m);
+
+ l = hashmap_get(m->devices_by_sysfs, sysfs);
+ LIST_FOREACH(same_sysfs, d, l)
+ device_set_state(d, DEVICE_PLUGGED);
+ }
+
+ return 0;
+}
+
static int device_process_path(Manager *m, const char *path, bool update_state) {
int r;
struct udev_device *dev;
static int device_process_removed_device(Manager *m, struct udev_device *dev) {
const char *sysfs;
- char *e;
- Unit *u;
Device *d;
assert(m);
if (!(sysfs = udev_device_get_syspath(dev)))
return -ENOMEM;
- assert(sysfs[0] == '/');
- if (!(e = unit_name_from_path(sysfs, ".device")))
- return -ENOMEM;
-
- u = manager_get_unit(m, e);
- free(e);
-
- if (!u)
- return 0;
-
- d = DEVICE(u);
- free(d->sysfs);
- d->sysfs = NULL;
+ /* Remove all units of this sysfs path */
+ while ((d = hashmap_get(m->devices_by_sysfs, sysfs))) {
+ device_unset_sysfs(d);
+ device_set_state(d, DEVICE_DEAD);
+ }
- device_set_state(d, DEVICE_DEAD);
return 0;
}
udev_unref(m->udev);
m->udev = NULL;
}
+
+ hashmap_free(m->devices_by_sysfs);
+ m->devices_by_sysfs = NULL;
}
static int device_enumerate(Manager *m) {
.no_instances = true,
.no_snapshots = true,
.no_isolate = true,
+ .no_alias = true,
.init = device_init,
DeviceState state;
char *sysfs;
+
+ /* In order to be able to distuingish dependencies on
+ different device nodes we might end up creating multiple
+ devices for the same sysfs path. We chain them up here. */
+
+ LIST_FIELDS(struct Device, same_sysfs);
};
extern const UnitVTable device_vtable;
return 0;
}
+int hashmap_remove_and_replace(Hashmap *h, const void *old_key, const void *new_key, void *value) {
+ struct hashmap_entry *e, *k;
+ unsigned old_hash, new_hash;
+
+ if (!h)
+ return -ENOENT;
+
+ old_hash = h->hash_func(old_key) % NBUCKETS;
+ if (!(e = hash_scan(h, old_hash, old_key)))
+ return -ENOENT;
+
+ new_hash = h->hash_func(new_key) % NBUCKETS;
+
+ if ((k = hash_scan(h, new_hash, new_key)))
+ if (e != k)
+ remove_entry(h, k);
+
+ unlink_entry(h, e, old_hash);
+
+ e->key = new_key;
+ e->value = value;
+
+ link_entry(h, e, new_hash);
+
+ return 0;
+}
+
void* hashmap_remove_value(Hashmap *h, const void *key, void *value) {
struct hashmap_entry *e;
unsigned hash;
void* hashmap_remove(Hashmap *h, const void *key);
void* hashmap_remove_value(Hashmap *h, const void *key, void *value);
int hashmap_remove_and_put(Hashmap *h, const void *old_key, const void *new_key, void *value);
+int hashmap_remove_and_replace(Hashmap *h, const void *old_key, const void *new_key, void *value);
int hashmap_merge(Hashmap *h, Hashmap *other);
void hashmap_move(Hashmap *h, Hashmap *other);
struct udev* udev;
struct udev_monitor* udev_monitor;
Watch udev_watch;
+ Hashmap *devices_by_sysfs;
/* Data specific to the mount subsystem */
FILE *proc_self_mountinfo;
} PathType;
typedef struct PathSpec {
- PathType type;
char *path;
+ Watch watch;
+
+ LIST_FIELDS(struct PathSpec, spec);
+
+ PathType type;
int inotify_fd;
int primary_wd;
- bool previous_exists;
- Watch watch;
+ bool previous_exists;
- LIST_FIELDS(struct PathSpec, spec);
} PathSpec;
struct Path {
LIST_HEAD(PathSpec, specs);
- PathState state, deserialized_state;
Unit *unit;
+ PathState state, deserialized_state;
+
bool failure;
};
ServiceType type;
ServiceRestart restart;
- NotifyAccess notify_access;
-
/* If set we'll read the main daemon PID from this file */
char *pid_file;
ExecCommand* exec_command[_SERVICE_EXEC_COMMAND_MAX];
ExecContext exec_context;
- bool permissions_start_only;
- bool root_directory_start_only;
- bool valid_no_process;
-
ServiceState state, deserialized_state;
ExecStatus main_exec_status;
ExecCommand *control_command;
ServiceExecCommand control_command_id;
pid_t main_pid, control_pid;
+
+ bool permissions_start_only;
+ bool root_directory_start_only;
+ bool valid_no_process;
+
bool main_pid_known:1;
/* If we shut down, remember why */
bool got_socket_fd:1;
bool sysv_has_lsb:1;
- char *sysv_path;
+
+ int socket_fd;
int sysv_start_priority;
+
+ char *sysv_path;
char *sysv_runlevels;
char *bus_name;
RateLimit ratelimit;
- int socket_fd;
struct Socket *socket;
Watch timer_watch;
+
+ NotifyAccess notify_access;
};
extern const UnitVTable service_vtable;
static bool arg_no_wall = false;
static bool arg_dry = false;
static bool arg_quiet = false;
+static char arg_full = false;
static char **arg_wall = NULL;
static enum action {
ACTION_INVALID,
printf("%-45s %-6s %-12s %-12s %-15s %s\n", "UNIT", "LOAD", "ACTIVE", "SUB", "JOB", "DESCRIPTION");
while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
- const char *id, *description, *load_state, *active_state, *sub_state, *unit_path, *job_type, *job_path, *dot;
+ const char *id, *description, *load_state, *active_state, *sub_state, *following, *unit_path, *job_type, *job_path, *dot;
uint32_t job_id;
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &load_state, true) < 0 ||
bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &active_state, true) < 0 ||
bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &sub_state, true) < 0 ||
+ bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &following, true) < 0 ||
bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_path, true) < 0 ||
bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &job_id, true) < 0 ||
bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &job_type, true) < 0 ||
if ((!arg_type || ((dot = strrchr(id, '.')) &&
streq(dot+1, arg_type))) &&
- (arg_all || !streq(active_state, "inactive") || job_id > 0)) {
-
+ (arg_all || !(streq(active_state, "inactive") || following[0]) || job_id > 0)) {
+ char *e;
int a = 0, b = 0;
if (streq(active_state, "maintenance"))
fputs(ANSI_HIGHLIGHT_ON, stdout);
- printf("%-45s %-6s %-12s %-12s%n", id, load_state, active_state, sub_state, &a);
+ e = arg_full ? NULL : ellipsize(id, 45, 33);
+ printf("%-45s %-6s %-12s %-12s%n", e ? e : id, load_state, active_state, sub_state, &a);
+ free(e);
if (job_id != 0)
printf(" => %-12s%n", job_type, &b);
while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
const char *name, *type, *state, *job_path, *unit_path;
uint32_t id;
+ char *e;
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
log_error("Failed to parse reply.");
goto finish;
}
- printf("%4u %-45s %-17s %-7s\n", id, name, type, state);
+ e = arg_full ? NULL : ellipsize(name, 45, 33);
+ printf("%4u %-45s %-17s %-7s\n", id, e ? e : name, type, state);
+ free(e);
+
k++;
dbus_message_iter_next(&sub);
" -t --type=TYPE List only units of a particular type\n"
" -p --property=NAME Show only properties by this name\n"
" -a --all Show all units/properties, including dead/empty ones\n"
+ " --full Don't ellipsize unit names.\n"
" --fail When installing a new job, fail if conflicting jobs are\n"
" pending\n"
" --system Connect to system bus\n"
ARG_NO_BLOCK,
ARG_NO_WALL,
ARG_ORDER,
- ARG_REQUIRE
+ ARG_REQUIRE,
+ ARG_FULL
};
static const struct option options[] = {
{ "type", required_argument, NULL, 't' },
{ "property", required_argument, NULL, 'p' },
{ "all", no_argument, NULL, 'a' },
+ { "full", no_argument, NULL, ARG_FULL },
{ "fail", no_argument, NULL, ARG_FAIL },
{ "session", no_argument, NULL, ARG_SESSION },
{ "system", no_argument, NULL, ARG_SYSTEM },
arg_dot = DOT_REQUIRE;
break;
+ case ARG_FULL:
+ arg_full = true;
+ break;
+
case 'q':
arg_quiet = true;
break;
string load_state;
string active_state;
string sub_state;
+ string following;
ObjectPath unit_path;
uint32 job_id;
string job_type;
SET_FOREACH(t, u->meta.names, i)
fprintf(f, "%s\tName: %s\n", prefix, t);
+ if (u->meta.following)
+ fprintf(f, "%s\tFollowing: %s\n", prefix, u->meta.following->meta.id);
+
if (u->meta.fragment_path)
fprintf(f, "%s\tFragment Path: %s\n", prefix, u->meta.fragment_path);
/* GC queue */
LIST_FIELDS(Meta, gc_queue);
+ /* This follows another unit in state */
+ Unit *following;
+
/* Used during GC sweeps */
unsigned gc_marker;
a.st_ino != b.st_ino;
}
+char *ellipsize(const char *s, unsigned length, unsigned percent) {
+ size_t l, x;
+ char *r;
+
+ assert(s);
+ assert(percent <= 100);
+ assert(length >= 3);
+
+ l = strlen(s);
+
+ if (l <= 3 || l <= length)
+ return strdup(s);
+
+ if (!(r = new0(char, length+1)))
+ return r;
+
+ x = (length * percent) / 100;
+
+ if (x > length - 3)
+ x = length - 3;
+
+ memcpy(r, s, x);
+ r[x] = '.';
+ r[x+1] = '.';
+ r[x+2] = '.';
+ memcpy(r + x + 3,
+ s + l - (length - x - 3),
+ length - x - 3);
+
+ return r;
+}
+
static const char *const ioprio_class_table[] = {
[IOPRIO_CLASS_NONE] = "none",
[IOPRIO_CLASS_RT] = "realtime",
int running_in_chroot(void);
+char *ellipsize(const char *s, unsigned length, unsigned percent);
+
const char *ioprio_class_to_string(int i);
int ioprio_class_from_string(const char *s);
~ianmdlvl / elogind.git / commitdiff