1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <errno.h>
4 #include <unistd.h>
5 #include <stdarg.h>
6 #include <string.h>
7 #include <sys/types.h>
8 #include <sys/stat.h>
9 #include <libmount.h>
10 #include <blkid.h>
11 #include <sys/utsname.h>
12
13 #include "nls.h"
14 #include "c.h"
15 #include "strutils.h"
16 #include "xalloc.h"
17 #include "pathnames.h"
18 #include "match.h"
19
20 #include "findmnt.h"
21
22 struct verify_context {
23 struct libmnt_fs *fs;
24 struct libmnt_table *tb;
25
26 char **fs_ary;
27 size_t fs_num;
28 size_t fs_alloc;
29
30 int nwarnings;
31 int nerrors;
32
33 unsigned int target_printed : 1,
34 no_fsck : 1;
35 };
36
37 static void __attribute__ ((__format__ (__printf__, 3, 0)))
38 verify_mesg(struct verify_context *vfy, char type, const char *fmt, va_list ap)
39 {
40 if (!vfy->target_printed && vfy->fs) {
41 fprintf(stdout, "%s\n", mnt_fs_get_target(vfy->fs));
42 vfy->target_printed = 1;
43 }
44
45 fprintf(stdout, " [%c] ", type);
46 vfprintf(stdout, fmt, ap);
47 fputc('\n', stdout);
48 }
49
50 static int __attribute__ ((__format__ (__printf__, 2, 3)))
51 verify_warn(struct verify_context *vfy, const char *fmt, ...)
52 {
53 va_list ap;
54 vfy->nwarnings++;
55 va_start(ap, fmt);
56 verify_mesg(vfy, 'W', fmt, ap);
57 va_end(ap);
58 return 0;
59 }
60
61 static int __attribute__ ((__format__ (__printf__, 2, 3)))
62 verify_err(struct verify_context *vfy, const char *fmt, ...)
63 {
64 va_list ap;
65 vfy->nerrors++;
66 va_start(ap, fmt);
67 verify_mesg(vfy, 'E', fmt, ap);
68 va_end(ap);
69 return 0;
70 }
71
72 static int __attribute__ ((__format__ (__printf__, 2, 3)))
73 verify_ok(struct verify_context *vfy __attribute__((unused)),
74 const char *fmt, ...)
75 {
76 va_list ap;
77
78 if (!(flags & FL_VERBOSE))
79 return 0;
80
81 va_start(ap, fmt);
82 verify_mesg(vfy, ' ', fmt, ap);
83 va_end(ap);
84 return 0;
85 }
86
87 static int verify_order(struct verify_context *vfy)
88 {
89 struct libmnt_iter *itr = NULL;
90 struct libmnt_fs *next;
91 const char *tgt;
92
93 tgt = mnt_fs_get_target(vfy->fs);
94 if (tgt && !(flags & FL_NOCACHE))
95 tgt = mnt_resolve_target(tgt, cache);
96 else if (!tgt)
97 return 0;
98
99 itr = mnt_new_iter(MNT_ITER_FORWARD);
100 if (!itr) {
101 warn(_("failed to initialize libmount iterator"));
102 goto done;
103 }
104
105 /* set iterator position to 'fs' */
106 mnt_table_set_iter(vfy->tb, itr, vfy->fs);
107
108 if (mnt_table_next_fs(vfy->tb, itr, &next) != 0)
109 goto done;
110
111 /* scan all next filesystems */
112 while (mnt_table_next_fs(vfy->tb, itr, &next) == 0) {
113 const char *n_tgt;
114 size_t len;
115
116 n_tgt = mnt_fs_get_target(next);
117 if (n_tgt && !(flags & FL_NOCACHE))
118 n_tgt = mnt_resolve_target(n_tgt, cache);
119 else if (!n_tgt)
120 continue;
121 len = strlen(n_tgt);
122
123 if (strncmp(n_tgt, tgt, len) == 0) {
124 if (*(tgt + len) == '\0')
125 verify_warn(vfy, _("target specified more than once"));
126 else if (*(tgt + len) == '/')
127 verify_err(vfy, _("wrong order: %s specified before %s"), tgt, n_tgt);
128 }
129 }
130 done:
131 mnt_free_iter(itr);
132 return 0;
133 }
134
135 static int verify_target(struct verify_context *vfy)
136 {
137 const char *tgt = mnt_fs_get_target(vfy->fs);
138 struct stat sb;
139
140 if (!tgt)
141 return verify_err(vfy, _("undefined target (fs_file)"));
142
143 if (!(flags & FL_NOCACHE)) {
144 const char *cn = mnt_resolve_target(tgt, cache);
145 if (!cn)
146 return -ENOMEM;
147 if (strcmp(cn, tgt) != 0)
148 verify_warn(vfy, _("non-canonical target path (real: %s)"), cn);
149 tgt = cn;
150 }
151 if (stat(tgt, &sb) != 0) {
152 if (mnt_fs_get_option(vfy->fs, "noauto", NULL, NULL) == 1)
153 verify_err(vfy, _("unreachable on boot required target: %m"));
154 else
155 verify_warn(vfy, _("unreachable target: %m"));
156
157 } else if (!S_ISDIR(sb.st_mode)
158 && mnt_fs_get_option(vfy->fs, "bind", NULL, NULL) == 1) {
159 verify_err(vfy, _("target is not a directory"));
160 } else
161 verify_ok(vfy, _("target exists"));
162
163 return 0;
164 }
165
166 static char *verify_tag(struct verify_context *vfy, const char *name,
167 const char *value)
168 {
169 char *src = NULL;
170
171 if (!(flags & FL_NOCACHE))
172 src = mnt_resolve_tag(name, value, cache);
173
174 if (!src) {
175 if (mnt_fs_get_option(vfy->fs, "noauto", NULL, NULL) == 1)
176 verify_err(vfy, _("unreachable on boot required source: %s=%s"), name, value);
177 else
178 verify_warn(vfy, _("unreachable: %s=%s"), name, value);
179 } else
180 verify_ok(vfy, _("%s=%s translated to %s"), name, value, src);
181
182 return src;
183 }
184
185 /* Note that mount source is very FS specific and we should not
186 * interpret unreachable source as error. The exception is only
187 * NAME=value, this has to be convertible to device name.
188 */
189 static int verify_source(struct verify_context *vfy)
190 {
191 const char *src = mnt_fs_get_srcpath(vfy->fs);
192 char *t = NULL, *v = NULL;
193 struct stat sb;
194 int isbind, rc = 0;
195
196 /* source is NAME=value tag */
197 if (!src) {
198 const char *tag = NULL, *val = NULL;
199
200 if (mnt_fs_get_tag(vfy->fs, &tag, &val) != 0)
201 return verify_err(vfy, _("undefined source (fs_spec)"));
202
203 src = verify_tag(vfy, tag, val);
204 if (!src)
205 goto done;
206
207 /* blkid is able to parse it, but libmount does not see it as a tag --
208 * it means unsupported tag */
209 } else if (blkid_parse_tag_string(src, &t, &v) == 0 && stat(src, &sb) != 0) {
210 rc = verify_err(vfy, _("unsupported source tag: %s"), src);
211 goto done;
212 }
213 isbind = mnt_fs_get_option(vfy->fs, "bind", NULL, NULL) == 0;
214
215 /* source is path */
216 if (mnt_fs_is_pseudofs(vfy->fs) || mnt_fs_is_netfs(vfy->fs))
217 verify_ok(vfy, _("do not check %s source (pseudo/net)"), src);
218
219 else if (stat(src, &sb) != 0)
220 verify_warn(vfy, _("unreachable source: %s: %m"), src);
221
222 else if ((S_ISDIR(sb.st_mode) || S_ISREG(sb.st_mode)) && !isbind)
223 verify_warn(vfy, _("non-bind mount source %s is a directory or regular file"), src);
224
225 else if (!S_ISBLK(sb.st_mode) && !isbind)
226 verify_warn(vfy, _("source %s is not a block device"), src);
227 else
228 verify_ok(vfy, _("source %s exists"), src);
229 done:
230 free(t);
231 free(v);
232 return rc;
233 }
234
235 static int verify_options(struct verify_context *vfy)
236 {
237 const char *opts;
238
239 opts = mnt_fs_get_vfs_options(vfy->fs);
240 if (opts)
241 verify_ok(vfy, _("VFS options: %s"), opts);
242
243 opts = mnt_fs_get_fs_options(vfy->fs);
244 if (opts)
245 verify_ok(vfy, _("FS options: %s"), opts);
246
247 opts = mnt_fs_get_user_options(vfy->fs);
248 if (opts)
249 verify_ok(vfy, _("userspace options: %s"), opts);
250
251 return 0;
252 }
253
254 static int verify_swaparea(struct verify_context *vfy)
255 {
256 char *arg;
257 size_t argsz = 0;
258
259 if (mnt_fs_get_option(vfy->fs, "discard", &arg, &argsz) == 0
260 && arg
261 && strncmp(arg, "once", argsz) != 0
262 && strncmp(arg, "pages", argsz) != 0)
263 verify_err(vfy, _("unsupported swaparea discard policy: %s"), arg);
264
265 if (mnt_fs_get_option(vfy->fs, "pri", &arg, &argsz) == 0 && arg) {
266 char *p = arg;
267 if (*p == '-')
268 p++;
269 for (; p < arg + argsz; p++) {
270 if (!isdigit((unsigned char) *p)) {
271 verify_err(vfy, _("failed to parse swaparea priority option"));
272 break;
273 }
274 }
275 }
276
277 return 0;
278 }
279
280 static int is_supported_filesystem(struct verify_context *vfy, const char *name)
281 {
282 size_t n;
283
284 if (!vfy->fs_num)
285 return 0;
286
287 for (n = 0; n < vfy->fs_num; n++ ) {
288 if (match_fstype(vfy->fs_ary[n], name))
289 return 1;
290 }
291
292 return 0;
293 }
294
295 static int add_filesystem(struct verify_context *vfy, const char *name)
296 {
297 #define MYCHUNK 16
298
299 if (is_supported_filesystem(vfy, name))
300 return 0;
301
302 if (vfy->fs_alloc == 0 || vfy->fs_num + 1 <= vfy->fs_alloc) {
303 vfy->fs_alloc = ((vfy->fs_alloc + 1 + MYCHUNK) / MYCHUNK) * MYCHUNK;
304 vfy->fs_ary = xrealloc(vfy->fs_ary, vfy->fs_alloc * sizeof(char *));
305 }
306
307 vfy->fs_ary[vfy->fs_num] = xstrdup(name);
308 vfy->fs_num++;
309
310 return 0;
311 }
312
313 static int read_proc_filesystems(struct verify_context *vfy)
314 {
315 int rc = 0;
316 FILE *f;
317 char buf[80], *cp, *t;
318
319 f = fopen("/proc/filesystems", "r");
320 if (!f)
321 return -errno;
322
323 while (!feof(f)) {
324 if (!fgets(buf, sizeof(buf), f))
325 break;
326 cp = buf;
327 if (!isspace(*cp)) {
328 while (*cp && !isspace(*cp))
329 cp++;
330 }
331 while (*cp && isspace(*cp))
332 cp++;
333 if ((t = strchr(cp, '\n')) != NULL)
334 *t = 0;
335 if ((t = strchr(cp, '\t')) != NULL)
336 *t = 0;
337 if ((t = strchr(cp, ' ')) != NULL)
338 *t = 0;
339
340 rc = add_filesystem(vfy, cp);
341 if (rc)
342 break;
343 }
344 fclose(f);
345 return rc;
346 }
347
348 static void free_proc_filesystems(struct verify_context *vfy)
349 {
350 size_t n;
351
352 if (!vfy->fs_ary)
353 return;
354
355 for (n = 0; n < vfy->fs_num; n++ )
356 free(vfy->fs_ary[n]);
357 free(vfy->fs_ary);
358 }
359
360 static int read_kernel_filesystems(struct verify_context *vfy)
361 {
362 int rc = 0;
363 #ifdef __linux__
364 struct utsname uts;
365 FILE *f;
366 char buf[1024];
367
368 if (uname(&uts))
369 return 0;
370 snprintf(buf, sizeof(buf), "/lib/modules/%s/modules.dep", uts.release);
371
372 f = fopen(buf, "r");
373 if (!f)
374 return 0;
375
376 while (!feof(f)) {
377 char *p, *name;
378
379 if (!fgets(buf, sizeof(buf), f))
380 break;
381
382 if (strncmp("kernel/fs/", buf, 10) != 0 ||
383 strncmp("kernel/fs/nls/", buf, 14) == 0)
384 continue;
385
386 p = strchr(buf, ':');
387 if (!p)
388 continue;
389 *p = '\0';
390
391 name = strrchr(buf, '/');
392 if (!name)
393 continue;
394 name++;
395
396 p = strstr(name, ".ko");
397 if (!p)
398 continue;
399 *p = '\0';
400
401 rc = add_filesystem(vfy, name);
402 if (rc)
403 break;
404 }
405 fclose(f);
406 #endif /* __linux__ */
407 return rc;
408 }
409
410 static int verify_fstype(struct verify_context *vfy)
411 {
412 char *src = mnt_resolve_spec(mnt_fs_get_source(vfy->fs), cache);
413 char *realtype = NULL;
414 const char *type;
415 int ambi = 0, isauto = 0, isswap = 0;
416
417 if (!src)
418 return 0;
419
420 if (mnt_fs_is_pseudofs(vfy->fs) || mnt_fs_is_netfs(vfy->fs)) {
421 verify_ok(vfy, _("do not check %s FS type (pseudo/net)"), src);
422 goto done;
423 }
424
425 type = mnt_fs_get_fstype(vfy->fs);
426
427 if (type) {
428 int none = strcmp(type, "none") == 0;
429
430 if (none
431 && mnt_fs_get_option(vfy->fs, "bind", NULL, NULL) == 1
432 && mnt_fs_get_option(vfy->fs, "move", NULL, NULL) == 1) {
433 verify_warn(vfy, _("\"none\" FS type is recommended for bind or move oprations only"));
434 goto done;
435 }
436
437 if (strcmp(type, "auto") == 0)
438 isauto = 1;
439 else if (strcmp(type, "swap") == 0)
440 isswap = 1;
441 else if (strcmp(type, "xfs") == 0 || strcmp(type, "btrfs") == 0)
442 vfy->no_fsck = 1;
443
444 if (!isswap && !isauto && !none && !is_supported_filesystem(vfy, type))
445 verify_warn(vfy, _("%s seems unsupported by the current kernel"), type);
446 }
447
448 errno = 0;
449 realtype = mnt_get_fstype(src, &ambi, cache);
450
451 if (!realtype) {
452 const char *reson = errno ? strerror(errno) : _("reason unknown");
453
454 if (isauto)
455 verify_err(vfy, _("cannot detect on-disk filesystem type (%s)"), reson);
456 else
457 verify_warn(vfy, _("cannot detect on-disk filesystem type (%s)"), reson);
458 goto done;
459 }
460
461 if (realtype) {
462 isswap = strcmp(realtype, "swap") == 0;
463 vfy->no_fsck = strcmp(realtype, "xfs") == 0
464 || strcmp(realtype, "btrfs") == 0;
465
466 if (type && !isauto && strcmp(type, realtype) != 0) {
467 verify_warn(vfy, _("%s does not match with on-disk %s"), type, realtype);
468 goto done;
469 }
470 if (!isswap && !is_supported_filesystem(vfy, realtype)) {
471 verify_warn(vfy, _("on-disk %s seems unsupported by the current kernel"), realtype);
472 goto done;
473 }
474
475 verify_ok(vfy, _("FS type is %s"), realtype);
476 }
477
478 done:
479 if (!cache) {
480 free(src);
481 free(realtype);
482 }
483 return 0;
484 }
485
486 static int verify_passno(struct verify_context *vfy)
487 {
488 int passno = mnt_fs_get_passno(vfy->fs);
489 const char *tgt = mnt_fs_get_target(vfy->fs);
490
491 if (tgt && strcmp("/", tgt) == 0 && passno != 1 && !vfy->no_fsck)
492 return verify_warn(vfy, _("recommended root FS passno is 1 (current is %d)"), passno);
493
494 return 0;
495 }
496
497 static int verify_filesystem(struct verify_context *vfy)
498 {
499 int rc = 0;
500
501 if (mnt_fs_is_swaparea(vfy->fs))
502 rc = verify_swaparea(vfy);
503 else {
504 rc = verify_target(vfy);
505 if (!rc)
506 rc = verify_options(vfy);
507 }
508
509 if (!rc)
510 rc = verify_source(vfy);
511 if (!rc)
512 rc = verify_fstype(vfy);
513 if (!rc)
514 rc = verify_passno(vfy); /* depends on verify_fstype() */
515
516 return rc;
517 }
518
519 int verify_table(struct libmnt_table *tb)
520 {
521 struct verify_context vfy = { .nerrors = 0 };
522 struct libmnt_iter *itr;
523 int rc = 0; /* overall return code (alloc errors, etc.) */
524 int check_order = is_listall_mode();
525 static int has_read_fs = 0;
526
527 itr = mnt_new_iter(MNT_ITER_FORWARD);
528 if (!itr) {
529 warn(_("failed to initialize libmount iterator"));
530 goto done;
531 }
532
533 vfy.tb = tb;
534
535 if (has_read_fs == 0) {
536 read_proc_filesystems(&vfy);
537 read_kernel_filesystems(&vfy);
538 has_read_fs = 1;
539 }
540
541 while (rc == 0 && (vfy.fs = get_next_fs(tb, itr))) {
542 vfy.target_printed = 0;
543 vfy.no_fsck = 0;
544
545 if (check_order)
546 rc = verify_order(&vfy);
547 if (!rc)
548 rc = verify_filesystem(&vfy);
549
550 if (flags & FL_FIRSTONLY)
551 break;
552 flags |= FL_NOSWAPMATCH;
553 }
554
555 #ifdef USE_SYSTEMD
556 {
557 struct stat a, b;
558
559 if (stat(_PATH_SD_UNITSLOAD, &a) == 0 &&
560 stat(_PATH_MNTTAB, &b) == 0 &&
561 cmp_stat_mtime(&a, &b, <))
562 verify_warn(&vfy, _(
563 "your fstab has been modified, but systemd still uses the old version;\n"
564 " use 'systemctl daemon-reload' to reload"));
565 }
566 #endif
567
568 done:
569 mnt_free_iter(itr);
570
571 /* summary */
572 if (vfy.nerrors || parse_nerrors || vfy.nwarnings) {
573 fputc('\n', stderr);
574 fprintf(stderr, P_("%d parse error", "%d parse errors", parse_nerrors), parse_nerrors);
575 fprintf(stderr, P_(", %d error", ", %d errors", vfy.nerrors), vfy.nerrors);
576 fprintf(stderr, P_(", %d warning", ", %d warnings", vfy.nwarnings), vfy.nwarnings);
577 fputc('\n', stderr);
578 } else
579 fprintf(stdout, _("Success, no errors or warnings detected\n"));
580
581
582 free_proc_filesystems(&vfy);
583
584 return rc != 0 ? rc : vfy.nerrors + parse_nerrors;
585 }