picnoir/Systemd
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

fsckd daemon for inter-fsckd communication

Browse source 
Add systemd-fsckd multiplexer which accepts multiple systemd-fsck
instances to connect to it and sends progress report. systemd-fsckd then
computes and writes to /dev/console the number of devices currently being
checked and the minimum fsck progress. This will be used for interactive
progress report and cancelling in plymouth.

systemd-fsckd stops on idle when no systemd-fsck is connected.

Make the necessary changes to systemd-fsck to connect to the systemd-fsckd
socket.
This commit is contained in:
Didier Roche 2015-02-04 16:42:47 +01:00 committed by Martin Pitt
parent 502184de0f
commit ac6e2f0dfc
6 changed files with 484 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -77,6 +77,7 @@
/systemd-evcat
/systemd-firstboot
/systemd-fsck
/systemd-fsckd
/systemd-fstab-generator
/systemd-getty-generator
/systemd-gnome-ask-password-agent

13
Makefile.am
View file

@ -391,6 +391,7 @@ rootlibexec_PROGRAMS = \
systemd-remount-fs \
systemd-reply-password \
systemd-fsck \
systemd-fsckd \
systemd-machine-id-commit \
systemd-ac-power \
systemd-sysctl \
@ -2356,6 +2357,18 @@ systemd_fsck_LDADD = \
libudev-internal.la \
libsystemd-shared.la
# ------------------------------------------------------------------------------
systemd_fsckd_SOURCES = \
src/fsckd/fsckd.c \
$(NULL)
systemd_fsckd_LDADD = \
libsystemd-internal.la \
libsystemd-label.la \
libsystemd-shared.la \
libudev-internal.la \
$(NULL)
# ------------------------------------------------------------------------------
systemd_machine_id_commit_SOURCES = \
src/machine-id-commit/machine-id-commit.c \

88
src/fsck/fsck.c
View file

@ -27,6 +27,7 @@
#include <unistd.h>
#include <fcntl.h>
#include <sys/file.h>
#include <sys/stat.h>
#include "sd-bus.h"
#include "libudev.h"
@ -39,6 +40,8 @@
#include "fileio.h"
#include "udev-util.h"
#include "path-util.h"
#include "socket-util.h"
#include "fsckd/fsckd.h"
static bool arg_skip = false;
static bool arg_force = false;
@ -132,58 +135,36 @@ static void test_files(void) {
arg_show_progress = true;
}
static double percent(int pass, unsigned long cur, unsigned long max) {
/* Values stolen from e2fsck */
static const int pass_table[] = {
0, 70, 90, 92, 95, 100
static int process_progress(int fd, dev_t device_num) {
_cleanup_fclose_ FILE *f = NULL;
usec_t last = 0;
_cleanup_close_ int fsckd_fd = -1;
static const union sockaddr_union sa = {
.un.sun_family = AF_UNIX,
.un.sun_path = FSCKD_SOCKET_PATH,
};
if (pass <= 0)
return 0.0;
if ((unsigned) pass >= ELEMENTSOF(pass_table) || max == 0)
return 100.0;
return (double) pass_table[pass-1] +
((double) pass_table[pass] - (double) pass_table[pass-1]) *
(double) cur / (double) max;
}
static int process_progress(int fd) {
_cleanup_fclose_ FILE *console = NULL, *f = NULL;
usec_t last = 0;
bool locked = false;
int clear = 0;
fsckd_fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
if (fsckd_fd < 0)
return log_warning_errno(errno, "Cannot open fsckd socket, we won't report fsck progress: %m");
if (connect(fsckd_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path)) < 0)
return log_warning_errno(errno, "Cannot connect to fsckd socket, we won't report fsck progress: %m");
f = fdopen(fd, "r");
if (!f) {
safe_close(fd);
return -errno;
}
console = fopen("/dev/console", "we");
if (!console)
return -ENOMEM;
if (!f)
return log_warning_errno(errno, "Cannot connect to fsck, we won't report fsck progress: %m");
while (!feof(f)) {
int pass, m;
unsigned long cur, max;
_cleanup_free_ char *device = NULL;
double p;
int pass;
size_t cur, max;
ssize_t n;
usec_t t;
_cleanup_free_ char *device = NULL;
FsckProgress progress;
if (fscanf(f, "%i %lu %lu %ms", &pass, &cur, &max, &device) != 4)
break;
/* Only show one progress counter at max */
if (!locked) {
if (flock(fileno(console), LOCK_EX|LOCK_NB) < 0)
continue;
locked = true;
}
/* Only update once every 50ms */
t = now(CLOCK_MONOTONIC);
if (last + 50 * USEC_PER_MSEC > t)
@ -191,22 +172,15 @@ static int process_progress(int fd) {
last = t;
p = percent(pass, cur, max);
fprintf(console, "\r%s: fsck %3.1f%% complete...\r%n", device, p, &m);
fflush(console);
/* send progress to fsckd */
progress.devnum = device_num;
progress.cur = cur;
progress.max = max;
progress.pass = pass;
if (m > clear)
clear = m;
}
if (clear > 0) {
unsigned j;
fputc('\r', console);
for (j = 0; j < (unsigned) clear; j++)
fputc(' ', console);
fputc('\r', console);
fflush(console);
n = send(fsckd_fd, &progress, sizeof(FsckProgress), 0);
if (n < 0 || (size_t) n < sizeof(FsckProgress))
log_warning_errno(errno, "Cannot communicate fsck progress to fsckd: %m");
}
return 0;
@ -358,7 +332,7 @@ int main(int argc, char *argv[]) {
progress_pipe[1] = safe_close(progress_pipe[1]);
if (progress_pipe[0] >= 0) {
process_progress(progress_pipe[0]);
process_progress(progress_pipe[0], st.st_rdev);
progress_pipe[0] = -1;
}

1
src/fsckd/Makefile Symbolic link
View file

@ -0,0 +1 @@
../Makefile

404
src/fsckd/fsckd.c Normal file
View file

@ -0,0 +1,404 @@
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
/***
This file is part of systemd.
Copyright 2015 Canonical
Author:
Didier Roche <didrocks@ubuntu.com>
systemd is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
systemd is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
#include <getopt.h>
#include <errno.h>
#include <math.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
#include <unistd.h>
#include "build.h"
#include "event-util.h"
#include "fsckd.h"
#include "log.h"
#include "list.h"
#include "macro.h"
#include "sd-daemon.h"
#include "socket-util.h"
#include "util.h"
#define IDLE_TIME_SECONDS 30
struct Manager;
typedef struct Client {
struct Manager *manager;
int fd;
dev_t devnum;
size_t cur;
size_t max;
int pass;
double percent;
size_t buflen;
LIST_FIELDS(struct Client, clients);
} Client;
typedef struct Manager {
sd_event *event;
Client *clients;
int clear;
int connection_fd;
FILE *console;
double percent;
int numdevices;
} Manager;
static void manager_free(Manager *m);
DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
#define _cleanup_manager_free_ _cleanup_(manager_freep)
static double compute_percent(int pass, size_t cur, size_t max) {
/* Values stolen from e2fsck */
static const double pass_table[] = {
0, 70, 90, 92, 95, 100
};
if (pass <= 0)
return 0.0;
if ((unsigned) pass >= ELEMENTSOF(pass_table) || max == 0)
return 100.0;
return pass_table[pass-1] +
(pass_table[pass] - pass_table[pass-1]) *
(double) cur / max;
}
static void remove_client(Client **first, Client *item) {
LIST_REMOVE(clients, *first, item);
safe_close(item->fd);
free(item);
}
static int update_global_progress(Manager *m) {
Client *current = NULL;
_cleanup_free_ char *console_message = NULL;
int current_numdevices = 0, l = 0;
double current_percent = 100;
/* get the overall percentage */
LIST_FOREACH(clients, current, m->clients) {
current_numdevices++;
/* right now, we only keep the minimum % of all fsckd processes. We could in the future trying to be
linear, but max changes and corresponds to the pass. We have all the informations into fsckd
already if we can treat that in a smarter way. */
current_percent = MIN(current_percent, current->percent);
}
/* update if there is anything user-visible to update */
if (fabs(current_percent - m->percent) > 0.001 || current_numdevices != m->numdevices) {
m->numdevices = current_numdevices;
m->percent = current_percent;
if (asprintf(&console_message, "Checking in progress on %d disks (%3.1f%% complete)",
m->numdevices, m->percent) < 0)
return -ENOMEM;
/* write to console */
if (m->console) {
fprintf(m->console, "\r%s\r%n", console_message, &l);
fflush(m->console);
}
if (l > m->clear)
m->clear = l;
}
return 0;
}
static int progress_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
Client *client = userdata;
Manager *m = NULL;
FsckProgress fsck_data;
size_t buflen;
int r;
assert(client);
m = client->manager;
/* ensure we have enough data to read */
r = ioctl(fd, FIONREAD, &buflen);
if (r == 0 && buflen != 0 && (size_t) buflen < sizeof(FsckProgress)) {
if (client->buflen != buflen)
client->buflen = buflen;
/* we got twice the same size from a bad behaving client, kick it off the list */
else {
log_warning("Closing bad behaving fsck client connection at fd %d", client->fd);
remove_client(&(m->clients), client);
r = update_global_progress(m);
if (r < 0)
log_warning_errno(r, "Couldn't update global progress: %m");
}
return 0;
}
/* read actual data */
r = recv(fd, &fsck_data, sizeof(FsckProgress), 0);
if (r == 0) {
log_debug("Fsck client connected to fd %d disconnected", client->fd);
remove_client(&(m->clients), client);
} else if (r > 0 && r != sizeof(FsckProgress))
log_warning("Unexpected data structure sent to fsckd socket from fd: %d. Ignoring", client->fd);
else if (r > 0 && r == sizeof(FsckProgress)) {
client->devnum = fsck_data.devnum;
client->cur = fsck_data.cur;
client->max = fsck_data.max;
client->pass = fsck_data.pass;
client->percent = compute_percent(client->pass, client->cur, client->max);
log_debug("Getting progress for %u:%u (%lu, %lu, %d) : %3.1f%%",
major(client->devnum), minor(client->devnum),
client->cur, client->max, client->pass, client->percent);
} else
log_error_errno(r, "Unknown error while trying to read fsck data: %m");
r = update_global_progress(m);
if (r < 0)
log_warning_errno(r, "Couldn't update global progress: %m");
return 0;
}
static int new_connection_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
Manager *m = userdata;
Client *client = NULL;
int new_client_fd, r;
assert(m);
/* Initialize and list new clients */
new_client_fd = accept4(m->connection_fd, NULL, NULL, SOCK_CLOEXEC);
if (new_client_fd > 0) {
log_debug("New fsck client connected to fd: %d", new_client_fd);
client = new0(Client, 1);
if (!client)
return log_oom();
client->fd = new_client_fd;
client->manager = m;
LIST_PREPEND(clients, m->clients, client);
r = sd_event_add_io(m->event, NULL, client->fd, EPOLLIN, progress_handler, client);
if (r < 0) {
remove_client(&(m->clients), client);
return r;
}
} else
return log_error_errno(errno, "Couldn't accept a new connection: %m");
return 0;
}
static void manager_free(Manager *m) {
Client *current = NULL, *l = NULL;
if (!m)
return;
/* clear last line */
if (m->console && m->clear > 0) {
unsigned j;
fputc('\r', m->console);
for (j = 0; j < (unsigned) m->clear; j++)
fputc(' ', m->console);
fputc('\r', m->console);
fflush(m->console);
}
safe_close(m->connection_fd);
if (m->console)
fclose(m->console);
LIST_FOREACH_SAFE(clients, current, l, m->clients)
remove_client(&(m->clients), current);
sd_event_unref(m->event);
free(m);
}
static int manager_new(Manager **ret, int fd) {
_cleanup_manager_free_ Manager *m = NULL;
int r;
assert(ret);
m = new0(Manager, 1);
if (!m)
return -ENOMEM;
r = sd_event_default(&m->event);
if (r < 0)
return r;
m->connection_fd = fd;
m->console = fopen("/dev/console", "we");
if (!m->console)
return log_warning_errno(errno, "Can't connect to /dev/console: %m");
m->percent = 100;
*ret = m;
m = NULL;
return 0;
}
static int run_event_loop_with_timeout(sd_event *e, usec_t timeout) {
int r, code;
assert(e);
for (;;) {
r = sd_event_get_state(e);
if (r < 0)
return r;
if (r == SD_EVENT_FINISHED)
break;
r = sd_event_run(e, timeout);
if (r < 0)
return r;
/* timeout reached */
if (r == 0) {
sd_event_exit(e, 0);
break;
}
}
r = sd_event_get_exit_code(e, &code);
if (r < 0)
return r;
return code;
}
static void help(void) {
printf("%s [OPTIONS...]\n\n"
"Capture fsck progress and forward one stream to plymouth\n\n"
" -h --help Show this help\n"
" --version Show package version\n",
program_invocation_short_name);
}
static int parse_argv(int argc, char *argv[]) {
enum {
ARG_VERSION = 0x100,
ARG_ROOT,
};
static const struct option options[] = {
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, ARG_VERSION },
{}
};
int c;
assert(argc >= 0);
assert(argv);
while ((c = getopt_long(argc, argv, "hv", options, NULL)) >= 0)
switch (c) {
case 'h':
help();
return 0;
case ARG_VERSION:
puts(PACKAGE_STRING);
puts(SYSTEMD_FEATURES);
return 0;
case '?':
return -EINVAL;
default:
assert_not_reached("Unhandled option");
}
if (optind < argc) {
log_error("Extraneous arguments");
return -EINVAL;
}
return 1;
}
int main(int argc, char *argv[]) {
_cleanup_manager_free_ Manager *m = NULL;
int fd = -1;
int r, n;
log_set_target(LOG_TARGET_AUTO);
log_parse_environment();
log_open();
r = parse_argv(argc, argv);
if (r <= 0)
return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
n = sd_listen_fds(0);
if (n > 1) {
log_error("Too many file descriptors received.");
return EXIT_FAILURE;
} else if (n == 1) {
fd = SD_LISTEN_FDS_START + 0;
} else {
fd = make_socket_fd(LOG_DEBUG, FSCKD_SOCKET_PATH, SOCK_STREAM | SOCK_CLOEXEC);
if (fd < 0) {
log_error_errno(r, "Couldn't create listening socket fd on %s: %m", FSCKD_SOCKET_PATH);
return EXIT_FAILURE;
}
}
r = manager_new(&m, fd);
if (r < 0) {
log_error_errno(r, "Failed to allocate manager: %m");
return EXIT_FAILURE;
}
r = sd_event_add_io(m->event, NULL, fd, EPOLLIN, new_connection_handler, m);
if (r < 0) {
log_error_errno(r, "Can't listen to connection socket: %m");
return EXIT_FAILURE;
}
r = run_event_loop_with_timeout(m->event, IDLE_TIME_SECONDS * USEC_PER_SEC);
if (r < 0) {
log_error_errno(r, "Failed to run event loop: %m");
return EXIT_FAILURE;
}
sd_event_get_exit_code(m->event, &r);
return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}

34
src/fsckd/fsckd.h Normal file
View file

@ -0,0 +1,34 @@
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
/***
This file is part of systemd.
Copyright 2015 Canonical
Author:
Didier Roche <didrocks@ubuntu.com>
systemd is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
systemd is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
#define FSCKD_SOCKET_PATH "/run/systemd/fsckd"
#include "libudev.h"
typedef struct FsckProgress {
dev_t devnum;
size_t cur;
size_t max;
int pass;
} FsckProgress;