chiark / gitweb /
README: add SCSI BSG option
[elogind.git] / src / fstab-generator / fstab-generator.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2012 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <stdio.h>
23 #include <mntent.h>
24 #include <errno.h>
25 #include <string.h>
26 #include <unistd.h>
27
28 #include "log.h"
29 #include "util.h"
30 #include "unit-name.h"
31 #include "path-util.h"
32 #include "mount-setup.h"
33 #include "special.h"
34 #include "mkdir.h"
35 #include "virt.h"
36 #include "fileio.h"
37
38 static const char *arg_dest = "/tmp";
39 static bool arg_enabled = true;
40
41 static int mount_find_pri(struct mntent *me, int *ret) {
42         char *end, *pri;
43         unsigned long r;
44
45         assert(me);
46         assert(ret);
47
48         pri = hasmntopt(me, "pri");
49         if (!pri)
50                 return 0;
51
52         pri += 4;
53
54         errno = 0;
55         r = strtoul(pri, &end, 10);
56         if (errno > 0)
57                 return -errno;
58
59         if (end == pri || (*end != ',' && *end != 0))
60                 return -EINVAL;
61
62         *ret = (int) r;
63         return 1;
64 }
65
66 static int add_swap(const char *what, struct mntent *me) {
67         _cleanup_free_ char *name = NULL, *unit = NULL, *lnk = NULL, *device = NULL;
68         _cleanup_fclose_ FILE *f = NULL;
69         int r, pri = -1;
70
71         assert(what);
72         assert(me);
73
74         r = mount_find_pri(me, &pri);
75         if (r < 0) {
76                 log_error("Failed to parse priority");
77                 return pri;
78         }
79
80         name = unit_name_from_path(what, ".swap");
81         if (!name)
82                 return log_oom();
83
84         unit = strjoin(arg_dest, "/", name, NULL);
85         if (!unit)
86                 return log_oom();
87
88         f = fopen(unit, "wxe");
89         if (!f) {
90                 if (errno == EEXIST)
91                         log_error("Failed to create swap unit file %s, as it already exists. Duplicate entry in /etc/fstab?", unit);
92                 else
93                         log_error("Failed to create unit file %s: %m", unit);
94                 return -errno;
95         }
96
97         fprintf(f,
98                 "# Automatically generated by systemd-fstab-generator\n\n"
99                 "[Unit]\n"
100                 "SourcePath=/etc/fstab\n"
101                 "\n"
102                 "[Swap]\n"
103                 "What=%s\n",
104                 what);
105
106         if (pri >= 0)
107                 fprintf(f,
108                         "Priority=%i\n",
109                         pri);
110
111         fflush(f);
112         if (ferror(f)) {
113                 log_error("Failed to write unit file %s: %m", unit);
114                 return -errno;
115         }
116
117         return 0;
118 }
119
120 static bool mount_is_network(struct mntent *me) {
121         assert(me);
122
123         return
124                 hasmntopt(me, "_netdev") ||
125                 fstype_is_network(me->mnt_type);
126 }
127
128 static bool mount_in_initrd(struct mntent *me) {
129         assert(me);
130
131         return
132                 hasmntopt(me, "x-initrd.mount") ||
133                 streq(me->mnt_dir, "/usr");
134 }
135
136 static int add_mount(
137                 const char *what,
138                 const char *where,
139                 const char *type,
140                 const char *opts,
141                 int passno,
142                 bool noauto,
143                 bool nofail,
144                 bool automount,
145                 const char *post,
146                 const char *source) {
147         _cleanup_free_ char
148                 *name = NULL, *unit = NULL, *lnk = NULL, *device = NULL,
149                 *automount_name = NULL, *automount_unit = NULL;
150         _cleanup_fclose_ FILE *f = NULL;
151
152         assert(what);
153         assert(where);
154         assert(type);
155         assert(opts);
156         assert(source);
157
158         if (streq(type, "autofs"))
159                 return 0;
160
161         if (!is_path(where)) {
162                 log_warning("Mount point %s is not a valid path, ignoring.", where);
163                 return 0;
164         }
165
166         if (mount_point_is_api(where) ||
167             mount_point_ignore(where))
168                 return 0;
169
170         name = unit_name_from_path(where, ".mount");
171         if (!name)
172                 return log_oom();
173
174         unit = strjoin(arg_dest, "/", name, NULL);
175         if (!unit)
176                 return log_oom();
177
178         f = fopen(unit, "wxe");
179         if (!f) {
180                 if (errno == EEXIST)
181                         log_error("Failed to create mount unit file %s, as it already exists. Duplicate entry in /etc/fstab?", unit);
182                 else
183                         log_error("Failed to create unit file %s: %m", unit);
184                 return -errno;
185         }
186
187         fprintf(f,
188               "# Automatically generated by systemd-fstab-generator\n\n"
189               "[Unit]\n"
190               "SourcePath=%s\n",
191               source);
192
193         if (post && !noauto && !nofail && !automount)
194                 fprintf(f,
195                         "Before=%s\n",
196                         post);
197
198         fprintf(f,
199                 "\n"
200                 "[Mount]\n"
201                 "What=%s\n"
202                 "Where=%s\n"
203                 "Type=%s\n"
204                 "FsckPassNo=%i\n",
205                 what,
206                 where,
207                 type,
208                 passno);
209
210         if (!isempty(opts) &&
211             !streq(opts, "defaults"))
212                 fprintf(f,
213                         "Options=%s\n",
214                         opts);
215
216         fflush(f);
217         if (ferror(f)) {
218                 log_error("Failed to write unit file %s: %m", unit);
219                 return -errno;
220         }
221
222         if (!noauto) {
223                 if (post) {
224                         lnk = strjoin(arg_dest, "/", post, nofail || automount ? ".wants/" : ".requires/", name, NULL);
225                         if (!lnk)
226                                 return log_oom();
227
228                         mkdir_parents_label(lnk, 0755);
229                         if (symlink(unit, lnk) < 0) {
230                                 log_error("Failed to create symlink %s: %m", lnk);
231                                 return -errno;
232                         }
233                 }
234         }
235
236         if (automount && !path_equal(where, "/")) {
237                 automount_name = unit_name_from_path(where, ".automount");
238                 if (!automount_name)
239                         return log_oom();
240
241                 automount_unit = strjoin(arg_dest, "/", automount_name, NULL);
242                 if (!automount_unit)
243                         return log_oom();
244
245                 fclose(f);
246                 f = fopen(automount_unit, "wxe");
247                 if (!f) {
248                         log_error("Failed to create unit file %s: %m", automount_unit);
249                         return -errno;
250                 }
251
252                 fprintf(f,
253                         "# Automatically generated by systemd-fstab-generator\n\n"
254                         "[Unit]\n"
255                         "SourcePath=%s\n",
256                         source);
257
258                 if (post)
259                         fprintf(f,
260                                 "Before= %s\n",
261                                 post);
262
263                 fprintf(f,
264                         "[Automount]\n"
265                         "Where=%s\n",
266                         where);
267
268                 fflush(f);
269                 if (ferror(f)) {
270                         log_error("Failed to write unit file %s: %m", automount_unit);
271                         return -errno;
272                 }
273
274                 free(lnk);
275                 lnk = strjoin(arg_dest, "/", post, nofail ? ".wants/" : ".requires/", automount_name, NULL);
276                 if (!lnk)
277                         return log_oom();
278
279                 mkdir_parents_label(lnk, 0755);
280                 if (symlink(automount_unit, lnk) < 0) {
281                         log_error("Failed to create symlink %s: %m", lnk);
282                         return -errno;
283                 }
284         }
285
286         return 0;
287 }
288
289 static int parse_fstab(const char *prefix, bool initrd) {
290         _cleanup_free_ char *fstab_path = NULL;
291         FILE *f;
292         int r = 0;
293         struct mntent *me;
294
295         fstab_path = strjoin(strempty(prefix), "/etc/fstab", NULL);
296         if (!fstab_path)
297                 return log_oom();
298
299         f = setmntent(fstab_path, "r");
300         if (!f) {
301                 if (errno == ENOENT)
302                         return 0;
303
304                 log_error("Failed to open %s/etc/fstab: %m", strempty(prefix));
305                 return -errno;
306         }
307
308         while ((me = getmntent(f))) {
309                 _cleanup_free_ char *where = NULL, *what = NULL;
310                 int k;
311
312                 if (initrd && !mount_in_initrd(me))
313                         continue;
314
315                 what = fstab_node_to_udev_node(me->mnt_fsname);
316                 where = strjoin(strempty(prefix), me->mnt_dir, NULL);
317                 if (!what || !where) {
318                         r = log_oom();
319                         goto finish;
320                 }
321
322                 if (is_path(where))
323                         path_kill_slashes(where);
324
325                 log_debug("Found entry what=%s where=%s type=%s", what, where, me->mnt_type);
326
327                 if (streq(me->mnt_type, "swap"))
328                         k = add_swap(what, me);
329                 else {
330                         bool noauto, nofail, automount;
331                         const char *post;
332
333                         noauto = !!hasmntopt(me, "noauto");
334                         nofail = !!hasmntopt(me, "nofail");
335                         automount =
336                                   hasmntopt(me, "comment=systemd.automount") ||
337                                   hasmntopt(me, "x-systemd.automount");
338
339                         if (initrd) {
340                                 post = SPECIAL_INITRD_FS_TARGET;
341                         } else if (mount_in_initrd(me)) {
342                                 post = SPECIAL_INITRD_ROOT_FS_TARGET;
343                         } else if (mount_is_network(me)) {
344                                 post = SPECIAL_REMOTE_FS_TARGET;
345                         } else {
346                                 post = SPECIAL_LOCAL_FS_TARGET;
347                         }
348
349                         k = add_mount(what, where, me->mnt_type, me->mnt_opts,
350                                       me->mnt_passno, noauto, nofail, automount,
351                                       post, fstab_path);
352                 }
353
354                 if (k < 0)
355                         r = k;
356         }
357
358 finish:
359         endmntent(f);
360         return r;
361 }
362
363 static int parse_new_root_from_proc_cmdline(void) {
364         _cleanup_free_ char *what = NULL, *type = NULL, *opts = NULL, *line = NULL;
365         char *w, *state;
366         int r;
367         size_t l;
368         bool noauto, nofail;
369
370         r = read_one_line_file("/proc/cmdline", &line);
371         if (r < 0) {
372                 log_error("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
373                 return 0;
374         }
375
376         opts = strdup("ro");
377         type = strdup("auto");
378         if (!opts || !type)
379                 return log_oom();
380
381         /* root= and roofstype= may occur more than once, the last instance should take precedence.
382          * In the case of multiple rootflags= the arguments should be concatenated */
383         FOREACH_WORD_QUOTED(w, l, line, state) {
384                 _cleanup_free_ char *word;
385
386                 word = strndup(w, l);
387                 if (!word)
388                         return log_oom();
389
390                 else if (startswith(word, "root=")) {
391                         free(what);
392                         what = fstab_node_to_udev_node(word+5);
393                         if (!what)
394                                 return log_oom();
395
396                 } else if (startswith(word, "rootfstype=")) {
397                         free(type);
398                         type = strdup(word + 11);
399                         if (!type)
400                                 return log_oom();
401
402                 } else if (startswith(word, "rootflags=")) {
403                         char *o;
404
405                         o = strjoin(opts, ",", word + 10, NULL);
406                         if (!o)
407                                 return log_oom();
408
409                         free(opts);
410                         opts = o;
411
412                 } else if (streq(word, "ro") || streq(word, "rw")) {
413                         char *o;
414
415                         o = strjoin(opts, ",", word, NULL);
416                         if (!o)
417                                 return log_oom();
418
419                         free(opts);
420                         opts = o;
421                 }
422         }
423
424         noauto = !!strstr(opts, "noauto");
425         nofail = !!strstr(opts, "nofail");
426
427         if (!what) {
428                 log_debug("Could not find a root= entry on the kernel commandline.");
429                 return 0;
430         }
431
432         if (what[0] != '/') {
433                 log_debug("Skipping entry what=%s where=/sysroot type=%s", what, type);
434                 return 0;
435         }
436
437         log_debug("Found entry what=%s where=/sysroot type=%s", what, type);
438         r = add_mount(what, "/sysroot", type, opts, 0, noauto, nofail, false,
439                       SPECIAL_INITRD_ROOT_FS_TARGET, "/proc/cmdline");
440
441         return (r < 0) ? r : 0;
442 }
443
444 static int parse_proc_cmdline(void) {
445         _cleanup_free_ char *line = NULL;
446         char *w, *state;
447         int r;
448         size_t l;
449
450         if (detect_container(NULL) > 0)
451                 return 0;
452
453         r = read_one_line_file("/proc/cmdline", &line);
454         if (r < 0) {
455                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
456                 return 0;
457         }
458
459         FOREACH_WORD_QUOTED(w, l, line, state) {
460                 _cleanup_free_ char *word = NULL;
461
462                 word = strndup(w, l);
463                 if (!word)
464                         return log_oom();
465
466                 if (startswith(word, "fstab=")) {
467                         r = parse_boolean(word + 6);
468                         if (r < 0)
469                                 log_warning("Failed to parse fstab switch %s. Ignoring.", word + 6);
470                         else
471                                 arg_enabled = r;
472
473                 } else if (startswith(word, "rd.fstab=")) {
474
475                         if (in_initrd()) {
476                                 r = parse_boolean(word + 9);
477                                 if (r < 0)
478                                         log_warning("Failed to parse fstab switch %s. Ignoring.", word + 9);
479                                 else
480                                         arg_enabled = r;
481                         }
482
483                 } else if (startswith(word, "fstab.") ||
484                            (in_initrd() && startswith(word, "rd.fstab."))) {
485
486                         log_warning("Unknown kernel switch %s. Ignoring.", word);
487                 }
488         }
489
490         return 0;
491 }
492
493 int main(int argc, char *argv[]) {
494         int r = 0, k, l = 0;
495
496         if (argc > 1 && argc != 4) {
497                 log_error("This program takes three or no arguments.");
498                 return EXIT_FAILURE;
499         }
500
501         if (argc > 1)
502                 arg_dest = argv[1];
503
504         log_set_target(LOG_TARGET_SAFE);
505         log_parse_environment();
506         log_open();
507
508         umask(0022);
509
510         if (parse_proc_cmdline() < 0)
511                 return EXIT_FAILURE;
512
513         if (in_initrd())
514                 r = parse_new_root_from_proc_cmdline();
515
516         if (!arg_enabled)
517                 return (r < 0) ? EXIT_FAILURE : EXIT_SUCCESS;
518
519         k = parse_fstab(NULL, false);
520
521         if (in_initrd())
522                 l = parse_fstab("/sysroot", true);
523
524         return (r < 0) || (k < 0) || (l < 0) ? EXIT_FAILURE : EXIT_SUCCESS;
525 }