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         } else {
 212                 delete = false;
 213                 free(e);
 214         }
 215
 216         if (set_flags)
 217                 MOUNT(u)->still_exists = true;
 218
 219         if (live) {
 220                 if (set_flags)
 221                         MOUNT(u)->just_created = !MOUNT(u)->from_proc_self_mountinfo;
 222                 MOUNT(u)->from_proc_self_mountinfo = true;
 223         } else {
 224                 if (set_flags)
 225                         MOUNT(u)->just_created = !MOUNT(u)->from_etc_fstab;
 226                 MOUNT(u)->from_etc_fstab = true;
 227         }
 228
 229         if ((r = mount_add_node_links(MOUNT(u))) < 0)
 230                 goto fail;
 231
 232         if ((r = mount_add_path_links(MOUNT(u))) < 0)
 233                 goto fail;
 234
 235         unit_add_to_load_queue(u);
 236
 237         return 0;
 238
 239 fail:
 240         if (delete && u)
 241                 unit_free(u);
 242
 243         return 0;
 244 }
 245
 246 static char *fstab_node_to_udev_node(char *p) {
 247         char *dn, *t;
 248         int r;
 249
 250         /* FIXME: to follow udev's logic 100% we need to leave valid
 251          * UTF8 chars unescaped */
 252
 253         if (startswith(p, "LABEL=")) {
 254
 255                 if (!(t = xescape(p+6, "/ ")))
 256                         return NULL;
 257
 258                 r = asprintf(&dn, "/dev/disk/by-label/%s", t);
 259                 free(t);
 260
 261                 if (r < 0)
 262                         return NULL;
 263
 264                 return dn;
 265         }
 266
 267         if (startswith(p, "UUID=")) {
 268
 269                 if (!(t = xescape(p+5, "/ ")))
 270                         return NULL;
 271
 272                 r = asprintf(&dn, "/dev/disk/by-uuid/%s", ascii_strlower(t));
 273                 free(t);
 274
 275                 if (r < 0)
 276                         return NULL;
 277
 278                 return dn;
 279         }
 280
 281         return strdup(p);
 282 }
 283
 284 static int mount_load_etc_fstab(Manager *m, bool set_flags) {
 285         FILE *f;
 286         int r;
 287         struct mntent* me;
 288
 289         assert(m);
 290
 291         errno = 0;
 292         if (!(f = setmntent("/etc/fstab", "r")))
 293                 return -errno;
 294
 295         while ((me = getmntent(f))) {
 296                 char *where, *what;
 297
 298                 if (!(what = fstab_node_to_udev_node(me->mnt_fsname))) {
 299                         r = -ENOMEM;
 300                         goto finish;
 301                 }
 302
 303                 if (!(where = strdup(me->mnt_dir))) {
 304                         free(what);
 305                         r = -ENOMEM;
 306                         goto finish;
 307                 }
 308
 309                 if (what[0] == '/')
 310                         path_kill_slashes(what);
 311
 312                 if (where[0] == '/')
 313                         path_kill_slashes(where);
 314
 315                 r = mount_add_one(m, what, where, false, set_flags);
 316                 free(what);
 317                 free(where);
 318
 319                 if (r < 0)
 320                         goto finish;
 321         }
 322
 323         r = 0;
 324 finish:
 325
 326         endmntent(f);
 327         return r;
 328 }
 329
 330 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
 331         int r;
 332
 333         assert(m);
 334
 335         rewind(m->proc_self_mountinfo);
 336
 337         for (;;) {
 338                 int k;
 339                 char *device, *path, *d, *p;
 340
 341                 if ((k = fscanf(m->proc_self_mountinfo,
 342                                 "%*s "       /* (1) mount id */
 343                                 "%*s "       /* (2) parent id */
 344                                 "%*s "       /* (3) major:minor */
 345                                 "%*s "       /* (4) root */
 346                                 "%ms "       /* (5) mount point */
 347                                 "%*s"        /* (6) mount options */
 348                                 "%*[^-]"     /* (7) optional fields */
 349                                 "- "         /* (8) seperator */
 350                                 "%*s "       /* (9) file system type */
 351                                 "%ms"        /* (10) mount source */
 352                                 "%*[^\n]",   /* some rubbish at the end */
 353                                 &path,
 354                                 &device)) != 2) {
 355
 356                         if (k == EOF)
 357                                 break;
 358
 359                         return -EBADMSG;
 360                 }
 361
 362                 if (!(d = cunescape(device))) {
 363                         free(device);
 364                         free(path);
 365                         return -ENOMEM;
 366                 }
 367                 free(device);
 368
 369                 if (!(p = cunescape(path))) {
 370                         free(d);
 371                         free(path);
 372                         return -ENOMEM;
 373                 }
 374                 free(path);
 375
 376                 r = mount_add_one(m, d, p, true, set_flags);
 377                 free(d);
 378                 free(p);
 379
 380                 if (r < 0)
 381                         return r;
 382         }
 383
 384         return 0;
 385 }
 386
 387 static int mount_enumerate(Manager *m) {
 388         int r;
 389         struct epoll_event ev;
 390         assert(m);
 391
 392         if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "r")))
 393                 return -errno;
 394
 395         m->mount_watch.type = WATCH_MOUNT;
 396         m->mount_watch.fd = fileno(m->proc_self_mountinfo);
 397
 398         zero(ev);
 399         ev.events = EPOLLERR;
 400         ev.data.ptr = &m->mount_watch;
 401
 402         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
 403                 return -errno;
 404
 405         if ((r = mount_load_etc_fstab(m, false)) < 0)
 406                 goto fail;
 407
 408         if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
 409                 goto fail;
 410
 411         return 0;
 412
 413 fail:
 414         mount_shutdown(m);
 415         return r;
 416 }
 417
 418 void mount_fd_event(Manager *m, int events) {
 419         Meta *meta;
 420         int r;
 421
 422         assert(m);
 423         assert(events == POLLERR);
 424
 425         /* The manager calls this for every fd event happening on the
 426          * /proc/self/mountinfo file, which informs us about mounting
 427          * table changes */
 428
 429         if ((r = mount_load_proc_self_mountinfo(m, true)) < 0) {
 430                 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-errno));
 431                 return;
 432         }
 433
 434         manager_dispatch_load_queue(m);
 435
 436         LIST_FOREACH(units_per_type, meta, m->units_per_type[UNIT_MOUNT]) {
 437                 Mount *mount = (Mount*) meta;
 438
 439                 if (mount->just_created && mount->state == MOUNT_DEAD)
 440                         mount_set_state(mount, MOUNT_MOUNTED);
 441                 else if (!mount->still_exists && mount->state == MOUNT_MOUNTED) {
 442                         mount_set_state(mount, MOUNT_DEAD);
 443                         mount->from_proc_self_mountinfo = false;
 444                 }
 445
 446                 /* Clear the flags for later calls */
 447                 mount->just_created = false;
 448                 mount->still_exists = false;
 449         }
 450 }
 451
 452 const UnitVTable mount_vtable = {
 453         .suffix = ".mount",
 454
 455         .init = unit_load_fragment_and_dropin,
 456         .done = mount_done,
 457         .coldplug = mount_coldplug,
 458
 459         .dump = mount_dump,
 460
 461         .active_state = mount_active_state,
 462
 463         .enumerate = mount_enumerate,
 464         .shutdown = mount_shutdown
 465 };