mount.c

   1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
   2
   3 #include <errno.h>
   4 #include <stdio.h>
   5 #include <mntent.h>
   6 #include <sys/epoll.h>
   7 #include <sys/poll.h>
   8
   9 #include "unit.h"
  10 #include "mount.h"
  11 #include "load-fragment.h"
  12 #include "load-dropin.h"
  13 #include "log.h"
  14
  15 static const UnitActiveState state_translation_table[_MOUNT_STATE_MAX] = {
  16         [MOUNT_DEAD] = UNIT_INACTIVE,
  17         [MOUNT_MOUNTING] = UNIT_ACTIVATING,
  18         [MOUNT_MOUNTED] = UNIT_ACTIVE,
  19         [MOUNT_UNMOUNTING] = UNIT_DEACTIVATING,
  20         [MOUNT_MAINTAINANCE] = UNIT_INACTIVE,
  21 };
  22
  23 static const char* const state_string_table[_MOUNT_STATE_MAX] = {
  24         [MOUNT_DEAD] = "dead",
  25         [MOUNT_MOUNTING] = "mounting",
  26         [MOUNT_MOUNTED] = "mounted",
  27         [MOUNT_UNMOUNTING] = "unmounting",
  28         [MOUNT_MAINTAINANCE] = "maintainance"
  29 };
  30
  31 static void mount_done(Unit *u) {
  32         Mount *m = MOUNT(u);
  33
  34         assert(m);
  35         free(m->what);
  36         free(m->where);
  37 }
  38
  39 static void mount_set_state(Mount *m, MountState state) {
  40         MountState old_state;
  41         assert(m);
  42
  43         if (state == m->state)
  44                 return;
  45
  46         old_state = m->state;
  47         m->state = state;
  48
  49         log_debug("%s changed %s → %s", unit_id(UNIT(m)), state_string_table[old_state], state_string_table[state]);
  50
  51         unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state]);
  52 }
  53
  54 static int mount_coldplug(Unit *u) {
  55         Mount *m = MOUNT(u);
  56
  57         assert(m);
  58         assert(m->state == MOUNT_DEAD);
  59
  60         if (m->from_proc_self_mountinfo)
  61                 mount_set_state(m, MOUNT_MOUNTED);
  62
  63         return 0;
  64 }
  65
  66 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
  67         Mount *s = MOUNT(u);
  68
  69         assert(s);
  70
  71         fprintf(f,
  72                 "%sMount State: %s\n"
  73                 "%sWhere: %s\n"
  74                 "%sWhat: %s\n"
  75                 "%sFrom /etc/fstab: %s\n"
  76                 "%sFrom /proc/self/mountinfo: %s\n",
  77                 prefix, state_string_table[s->state],
  78                 prefix, s->where,
  79                 prefix, s->what,
  80                 prefix, yes_no(s->from_etc_fstab),
  81                 prefix, yes_no(s->from_proc_self_mountinfo));
  82 }
  83
  84 static UnitActiveState mount_active_state(Unit *u) {
  85         assert(u);
  86
  87         return state_translation_table[MOUNT(u)->state];
  88 }
  89
  90 static void mount_shutdown(Manager *m) {
  91         assert(m);
  92
  93         if (m->proc_self_mountinfo)
  94                 fclose(m->proc_self_mountinfo);
  95 }
  96
  97 static int mount_add_node_links(Mount *m) {
  98         Unit *device;
  99         char *e;
 100         int r;
 101
 102         assert(m);
 103
 104         /* Adds in links to the device that this node is based on */
 105
 106         if (!path_startswith(m->what, "/dev/"))
 107                 return 0;
 108
 109         if (!(e = unit_name_escape_path("node-", m->what+1, ".device")))
 110                 return -ENOMEM;
 111
 112         r = manager_load_unit(UNIT(m)->meta.manager, e, &device);
 113         free(e);
 114
 115         if (r < 0)
 116                 return r;
 117
 118         if ((r = unit_add_dependency(UNIT(m), UNIT_AFTER, device)) < 0)
 119                 return r;
 120
 121         if ((r = unit_add_dependency(UNIT(m), UNIT_REQUIRES, device)) < 0)
 122                 return r;
 123
 124         if ((r = unit_add_dependency(device, UNIT_WANTS, UNIT(m))) < 0)
 125                 return r;
 126
 127         return 0;
 128 }
 129
 130 static int mount_add_path_links(Mount *m) {
 131         Meta *other;
 132         int r;
 133
 134         /* Adds in link to other mount points, that might lie below or
 135          * above us in the hierarchy */
 136
 137         LIST_FOREACH(units_per_type, other, UNIT(m)->meta.manager->units_per_type[UNIT_MOUNT]) {
 138                 Mount *n;
 139
 140                 n = (Mount*) other;
 141
 142                 if (n == m)
 143                         return 0;
 144
 145                 if (path_startswith(m->where, n->where)) {
 146
 147                         if ((r = unit_add_dependency(UNIT(m), UNIT_AFTER, (Unit*) other)) < 0)
 148                                 return r;
 149
 150                         if ((r = unit_add_dependency(UNIT(m), UNIT_REQUIRES, (Unit*) other)) < 0)
 151                                 return r;
 152
 153                 } else if (startswith(n->where, m->where)) {
 154
 155                         if ((r = unit_add_dependency(UNIT(m), UNIT_BEFORE, (Unit*) other)) < 0)
 156                                 return r;
 157
 158                         if ((r = unit_add_dependency((Unit*) other, UNIT_REQUIRES, UNIT(m))) < 0)
 159                                 return r;
 160                 }
 161         }
 162
 163         return 0;
 164 }
 165
 166 static int mount_add_one(Manager *m, const char *what, const char *where, bool live, bool set_flags) {
 167         char *e;
 168         int r;
 169         Unit *u;
 170         bool delete;
 171
 172         assert(m);
 173         assert(what);
 174         assert(where);
 175
 176         /* probably some kind of swap, which we don't cover for now */
 177         if (where[0] != '/')
 178                 return 0;
 179
 180         if (streq(where, "/"))
 181                 e = strdup("rootfs.mount");
 182         else
 183                 e = unit_name_escape_path("fs-", where+1, ".mount");
 184
 185         if (!e)
 186                 return -ENOMEM;
 187
 188         if (!(u = manager_get_unit(m, e))) {
 189                 delete = true;
 190
 191                 if (!(u = unit_new(m))) {
 192                         free(e);
 193                         return -ENOMEM;
 194                 }
 195
 196                 r = unit_add_name(u, e);
 197                 free(e);
 198
 199                 if (r < 0)
 200                         goto fail;
 201
 202                 if (!(MOUNT(u)->what = strdup(what)) ||
 203                     !(MOUNT(u)->where = strdup(where))) {
 204                             r = -ENOMEM;
 205                             goto fail;
 206                     }
 207
 208                 if ((r = unit_set_description(u, where)) < 0)
 209                         goto fail;
 210
 211                 unit_add_to_load_queue(u);
 212         } else {
 213                 delete = false;
 214                 free(e);
 215         }
 216
 217         if (set_flags)
 218                 MOUNT(u)->still_exists = true;
 219
 220         if (live) {
 221                 if (set_flags)
 222                         MOUNT(u)->just_created = !MOUNT(u)->from_proc_self_mountinfo;
 223                 MOUNT(u)->from_proc_self_mountinfo = true;
 224         } else {
 225                 if (set_flags)
 226                         MOUNT(u)->just_created = !MOUNT(u)->from_etc_fstab;
 227                 MOUNT(u)->from_etc_fstab = true;
 228         }
 229
 230         if ((r = mount_add_node_links(MOUNT(u))) < 0)
 231                 goto fail;
 232
 233         if ((r = mount_add_path_links(MOUNT(u))) < 0)
 234                 goto fail;
 235
 236         return 0;
 237
 238 fail:
 239         if (delete && u)
 240                 unit_free(u);
 241
 242         return 0;
 243 }
 244
 245 static char *fstab_node_to_udev_node(char *p) {
 246         char *dn, *t;
 247         int r;
 248
 249         /* FIXME: to follow udev's logic 100% we need to leave valid
 250          * UTF8 chars unescaped */
 251
 252         if (startswith(p, "LABEL=")) {
 253
 254                 if (!(t = xescape(p+6, "/ ")))
 255                         return NULL;
 256
 257                 r = asprintf(&dn, "/dev/disk/by-label/%s", t);
 258                 free(t);
 259
 260                 if (r < 0)
 261                         return NULL;
 262
 263                 return dn;
 264         }
 265
 266         if (startswith(p, "UUID=")) {
 267
 268                 if (!(t = xescape(p+5, "/ ")))
 269                         return NULL;
 270
 271                 r = asprintf(&dn, "/dev/disk/by-uuid/%s", ascii_strlower(t));
 272                 free(t);
 273
 274                 if (r < 0)
 275                         return NULL;
 276
 277                 return dn;
 278         }
 279
 280         return strdup(p);
 281 }
 282
 283 static int mount_load_etc_fstab(Manager *m, bool set_flags) {
 284         FILE *f;
 285         int r;
 286         struct mntent* me;
 287
 288         assert(m);
 289
 290         errno = 0;
 291         if (!(f = setmntent("/etc/fstab", "r")))
 292                 return -errno;
 293
 294         while ((me = getmntent(f))) {
 295                 char *where, *what;
 296
 297                 if (!(what = fstab_node_to_udev_node(me->mnt_fsname))) {
 298                         r = -ENOMEM;
 299                         goto finish;
 300                 }
 301
 302                 if (!(where = strdup(me->mnt_dir))) {
 303                         free(what);
 304                         r = -ENOMEM;
 305                         goto finish;
 306                 }
 307
 308                 if (what[0] == '/')
 309                         path_kill_slashes(what);
 310
 311                 if (where[0] == '/')
 312                         path_kill_slashes(where);
 313
 314                 r = mount_add_one(m, what, where, false, set_flags);
 315                 free(what);
 316                 free(where);
 317
 318                 if (r < 0)
 319                         goto finish;
 320         }
 321
 322         r = 0;
 323 finish:
 324
 325         endmntent(f);
 326         return r;
 327 }
 328
 329 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
 330         int r;
 331
 332         assert(m);
 333
 334         rewind(m->proc_self_mountinfo);
 335
 336         for (;;) {
 337                 int k;
 338                 char *device, *path, *d, *p;
 339
 340                 if ((k = fscanf(m->proc_self_mountinfo,
 341                                 "%*s "       /* (1) mount id */
 342                                 "%*s "       /* (2) parent id */
 343                                 "%*s "       /* (3) major:minor */
 344                                 "%*s "       /* (4) root */
 345                                 "%ms "       /* (5) mount point */
 346                                 "%*s"        /* (6) mount options */
 347                                 "%*[^-]"     /* (7) optional fields */
 348                                 "- "         /* (8) seperator */
 349                                 "%*s "       /* (9) file system type */
 350                                 "%ms"        /* (10) mount source */
 351                                 "%*[^\n]",   /* some rubbish at the end */
 352                                 &path,
 353                                 &device)) != 2) {
 354
 355                         if (k == EOF)
 356                                 break;
 357
 358                         return -EBADMSG;
 359                 }
 360
 361                 if (!(d = cunescape(device))) {
 362                         free(device);
 363                         free(path);
 364                         return -ENOMEM;
 365                 }
 366                 free(device);
 367
 368                 if (!(p = cunescape(path))) {
 369                         free(d);
 370                         free(path);
 371                         return -ENOMEM;
 372                 }
 373                 free(path);
 374
 375                 r = mount_add_one(m, d, p, true, set_flags);
 376                 free(d);
 377                 free(p);
 378
 379                 if (r < 0)
 380                         return r;
 381         }
 382
 383         return 0;
 384 }
 385
 386 static int mount_enumerate(Manager *m) {
 387         int r;
 388         struct epoll_event ev;
 389         assert(m);
 390
 391         if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "r")))
 392                 return -errno;
 393
 394         m->mount_watch.type = WATCH_MOUNT;
 395         m->mount_watch.fd = fileno(m->proc_self_mountinfo);
 396
 397         zero(ev);
 398         ev.events = EPOLLERR;
 399         ev.data.ptr = &m->mount_watch;
 400
 401         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
 402                 return -errno;
 403
 404         if ((r = mount_load_etc_fstab(m, false)) < 0)
 405                 goto fail;
 406
 407         if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
 408                 goto fail;
 409
 410         return 0;
 411
 412 fail:
 413         mount_shutdown(m);
 414         return r;
 415 }
 416
 417 void mount_fd_event(Manager *m, int events) {
 418         Meta *meta;
 419         int r;
 420
 421         assert(m);
 422         assert(events == EPOLLERR);
 423
 424         /* The manager calls this for every fd event happening on the
 425          * /proc/self/mountinfo file, which informs us about mounting
 426          * table changes */
 427
 428         if ((r = mount_load_proc_self_mountinfo(m, true)) < 0) {
 429                 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-errno));
 430                 return;
 431         }
 432
 433         manager_dispatch_load_queue(m);
 434
 435         LIST_FOREACH(units_per_type, meta, m->units_per_type[UNIT_MOUNT]) {
 436                 Mount *mount = (Mount*) meta;
 437
 438                 if (mount->just_created && mount->state == MOUNT_DEAD)
 439                         mount_set_state(mount, MOUNT_MOUNTED);
 440                 else if (!mount->still_exists && mount->state == MOUNT_MOUNTED) {
 441                         mount_set_state(mount, MOUNT_DEAD);
 442                         mount->from_proc_self_mountinfo = false;
 443                 }
 444
 445                 /* Clear the flags for later calls */
 446                 mount->just_created = false;
 447                 mount->still_exists = false;
 448         }
 449 }
 450
 451 const UnitVTable mount_vtable = {
 452         .suffix = ".mount",
 453
 454         .init = unit_load_fragment_and_dropin,
 455         .done = mount_done,
 456         .coldplug = mount_coldplug,
 457
 458         .dump = mount_dump,
 459
 460         .active_state = mount_active_state,
 461
 462         .enumerate = mount_enumerate,
 463         .shutdown = mount_shutdown
 464 };