cmogstored 1.8.1 - use default system stack size

[cmogstored.git] / mnt.c

/*
 * Copyright (C) 2012-2020 all contributors <cmogstored-public@yhbt.net>
 * License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 */
/*
 * Uses the mountlist library in gnulib to map system device IDs and
 * system device names to mount entries.
 */
#include "cmogstored.h"

struct init_args {
        pthread_mutex_t cond_lock;
        pthread_cond_t cond;
};

static pthread_mutex_t by_dev_lock = PTHREAD_MUTEX_INITIALIZER;

/*
 * by_dev maps (system) device IDs to a mount_entry; mount_entry structs may
 * be chained as multiple mount entries may be aliased (e.g. "rootfs" and
 * "/dev/root") on Linux.
 */
static Hash_table *by_dev;

static void me_free(void *entry)
{
        struct mount_entry *next;
        struct mount_entry *me = entry;

        do {
                assert(me->me_type == NULL
                       && me->me_type_malloced == 0
                       && "me_type still malloc-ed in mountlist");
                next = me->me_next;
                free_mount_entry(me);
        } while ((me = next));
}

static size_t me_hash(const void *entry, size_t tablesize)
{
        const struct mount_entry *me = entry;

        return me->me_dev % tablesize;
}

static bool me_cmp(const void *a, const void *b)
{
        const struct mount_entry *me_a = a;
        const struct mount_entry *me_b = b;

        return me_a->me_dev == me_b->me_dev;
}

static void mnt_atexit(void)
{
        hash_free(by_dev);
}

static Hash_table * mnt_new(size_t n)
{
        Hash_table *rv = hash_initialize(n, NULL, me_hash, me_cmp, me_free);

        mog_oom_if_null(rv);

        return rv;
}

/* populates a hash table starting with the mount list */
static void mnt_populate(Hash_table *tbl)
{
        struct mount_entry *head = read_file_system_list(false);
        struct mount_entry *next;
        union {
                const void *ptr;
                struct mount_entry *old_me;
        } exist;

        for ( ; head; head = next) {
                next = head->me_next;

                /* ensure we can me_free() without side effects when skipping */
                head->me_next = NULL;

                /* we don't care about FS type at all */
                if (head->me_type_malloced) {
                        free(head->me_type);
                        head->me_type_malloced = 0;
                }
                head->me_type = NULL;

                if (!mog_mnt_usable(head))
                        goto skip;

                /* mark the device as something we _might_ track util for */
                mog_iou_active(head->me_dev);

                switch (hash_insert_if_absent(tbl, head, &exist.ptr)) {
                case 0: {
                        /* chain entries if they have multiple st_dev */
                        struct mount_entry *me = exist.old_me;

                        while (me->me_next)
                                me = me->me_next;

                        assert(me != head && "circular mount ref");
                        me->me_next = head;
                }
                        continue;
                case 1:
                        continue;
                default: mog_oom();
                }
                assert(0 && "compiler bug?");
skip:
                me_free(head);
        }
}

/* runs inside a thread, this is called at startup before daemonization */
static void * init_once(void *ptr)
{
        struct init_args *ia = ptr;
        int err;

        CHECK(int, 0, pthread_mutex_lock(&by_dev_lock) );
        assert(by_dev == NULL &&
               "by_dev exists during initialization");
        by_dev = mnt_new(7);
        mnt_populate(by_dev);
        CHECK(int, 0, pthread_mutex_unlock(&by_dev_lock) );

        /* wake up parent thread, this tells parent to cancel us */
        CHECK(int, 0, pthread_mutex_lock(&ia->cond_lock));
        CHECK(int, 0, pthread_cond_signal(&ia->cond));
        CHECK(int, 0, pthread_mutex_unlock(&ia->cond_lock));

        /* wait for cancellation, mog_sleep may return ENOMEM or EINTR */
        do {
                err = mog_sleep(-1);
        } while (err == EINTR || err == ENOMEM);
        assert(0 && "init_once did not get cancelled");
        return NULL;
}

/* once-only initialization */
static void timed_init_once(void)
{
        int rc;
        pthread_t thr;
        unsigned long tries;
        struct init_args ia = {
                .cond_lock = PTHREAD_MUTEX_INITIALIZER,
                .cond = PTHREAD_COND_INITIALIZER
        };

        CHECK(int, 0, pthread_mutex_lock(&ia.cond_lock));

        for (tries = 0; ;) {
                rc = pthread_create(&thr, NULL, init_once, &ia);
                if (rc == 0)
                        break;

                /* this must succeed, keep looping */
                if (mog_pthread_create_retryable(rc)) {
                        if ((++tries % 1024) == 0)
                                warn("pthread_create: %s (tries: %lu)",
                                     strerror(rc), tries);
                        mog_yield();
                } else {
                        assert(0 && "pthread_create usage error");
                }
        }

        for (tries = 0; ;) {
                struct timespec ts;

                gettime(&ts);
                ts.tv_sec += 5;
                rc = pthread_cond_timedwait(&ia.cond, &ia.cond_lock, &ts);

                if (rc == 0)
                        break;
                if (rc == ETIMEDOUT)
                        warn("still populating mountlist (tries: %lu)",
                             ++tries);
                else if (rc == EINTR)
                        continue;
                else
                        assert(0 && "unhandled pthread_cond_timedwait failure");
        }
        CHECK(int, 0, pthread_mutex_unlock(&ia.cond_lock));

        /*
         * this will load libgcc_s under glibc, we want to do this early
         * in process lifetime to prevent load failures if we are under
         * FD pressure later on.
         */
        CHECK(int, 0, pthread_cancel(thr));

        CHECK(int, 0, pthread_join(thr, NULL));
        CHECK(int, 0, pthread_cond_destroy(&ia.cond));
        CHECK(int, 0, pthread_mutex_destroy(&ia.cond_lock));
        atexit(mnt_atexit);
}

void mog_mnt_refresh(void)
{
        Hash_table *new, *old;
        size_t n = 0;
        static pthread_mutex_t refresh_lock = PTHREAD_MUTEX_INITIALIZER;

        CHECK(int, 0, pthread_mutex_lock(&refresh_lock) ); /* protects old */

        CHECK(int, 0, pthread_mutex_lock(&by_dev_lock) );
        old = by_dev; /* save early for validation */
        if (old)
                n = hash_get_n_buckets_used(old);
        CHECK(int, 0, pthread_mutex_unlock(&by_dev_lock) );

        if (old) {
                mog_iou_cleanup_begin();
                new = mnt_new(n);
                mnt_populate(new); /* slow, can stat all devices */

                /* quickly swap in the new mount list */
                CHECK(int, 0, pthread_mutex_lock(&by_dev_lock) );
                assert(old == by_dev &&
                       "by_dev hash modified during update");
                by_dev = new;
                CHECK(int, 0, pthread_mutex_unlock(&by_dev_lock) );

                /*
                 * must cleanup _after_ replacing by_dev, since readers
                 * can still mark devices as active before we wrlock.
                 */
                mog_iou_cleanup_finish();
                hash_free(old);
        } else {
                timed_init_once();
        }

        CHECK(int, 0, pthread_mutex_unlock(&refresh_lock) );
}

/*
 * Looks up a mount_entry by st_dev, returns NULL if nothing was found
 * Users may only acquire one mount entry at a time and MUST release it
 */
const struct mount_entry * mog_mnt_acquire(dev_t st_dev)
{
        struct mount_entry me = { .me_dev = st_dev };
        struct mount_entry *rv;

        CHECK(int, 0, pthread_mutex_lock(&by_dev_lock) );
        rv = hash_lookup(by_dev, &me);

        /* user must release this via mog_mnt_release if non-NULL */
        if (rv) {
                struct mount_entry *rv_me = rv;

                /*
                 * if multiple entries match st_dev, favor the one
                 * with a leading slash
                 */
                while (rv_me && rv_me->me_devname[0] != '/')
                        rv_me = rv_me->me_next;

                return rv_me ? rv_me : rv;
        }

        CHECK(int, 0, pthread_mutex_unlock(&by_dev_lock) );
        return NULL;
}

/* releases the mount entry, allowing mog_mnt_acquire to be called again */
void mog_mnt_release(const struct mount_entry *me)
{
        struct mount_entry *check_me;
        union { const void *in; void *out; } deconst = { .in = me };

        check_me = hash_lookup(by_dev, deconst.out);

        while (check_me->me_next && check_me != me)
                check_me = check_me->me_next;

        assert(check_me == me && "did not release acquired mount_entry");
        CHECK(int, 0, pthread_mutex_unlock(&by_dev_lock) );
}

#define MOG_DEV_T_INVAL ((dev_t)-1)

struct mnt_update {
        char prefix[(sizeof("/dev/") - 1) + MOG_IOSTAT_DEVLEN];
        size_t prefixlen;
        dev_t st_rdev;
        char util[MOG_IOUTIL_LEN];
};

/*
 * returns true if the mount entry matches the update request
 * (and thus can be updated).  False if no match.
 */
static bool me_update_match(struct mount_entry *me, struct mnt_update *update)
{
        if (update->st_rdev != MOG_DEV_T_INVAL
            && me->me_dev == update->st_rdev)
                return true;

        if (strlen(me->me_devname) < update->prefixlen)
                return false;
        return memcmp(update->prefix, me->me_devname, update->prefixlen) == 0;
}

/* Hash iterator */
static bool update_util_each(void *ent, void *upd)
{
        struct mount_entry *me = ent;
        struct mnt_update *update = upd;
        dev_t this_dev = me->me_dev;

        /* attempt to resolve multiple mounts mapped to the same mount point */
        for (; me; me = me->me_next) {
                assert(this_dev == me->me_dev && "me_dev mismatch");

                if (me_update_match(me, update)) {
                        mog_iou_write(this_dev, update->util);
                        /*
                         * We could cull mismatched mount entries here.
                         * mount point aliasing is relatively uncommon so
                         * probably not worth the code.
                         */
                        break;
                }
        }

        return true; /* continue */
}

/*
 * takes a line of iostat information and updates entries in our
 * mountlist which match it.  This is O(mountpoints) for now.
 */
void mog_mnt_update_util(struct mog_iostat *iostat)
{
        static const size_t pfx_len = sizeof("/dev/") - 1;
        struct mnt_update update;
        size_t cpy_len = strlen(iostat->dev);
        char *dst = mempcpy(update.prefix, "/dev/", pfx_len);
        struct stat st;

        mempcpy(dst, iostat->dev, cpy_len + 1);
        update.prefixlen = cpy_len + pfx_len;

        /*
         * st_rdev matching is necessary for cryptmount(8) on Linux, where
         * /dev/mapper/FOO is NOT a symlink to /dev/dm-N, but /dev/dm-N
         * and /dev/mapper/FOO both refer to the same device (where
         * /dev/mapper/FOO is the mounted device name, mountlist never
         * sees /dev/dm-N).
         *
         * FIXME: parse /proc/partitions under Linux like mogstored does
         * may avoid this stat.
         */
        if (stat(update.prefix, &st) == 0 && S_ISBLK(st.st_mode))
                update.st_rdev = st.st_rdev;
        else
                update.st_rdev = MOG_DEV_T_INVAL;

        assert(sizeof(update.util) == sizeof(iostat->util));
        memcpy(&update.util, iostat->util, sizeof(update.util));

        CHECK(int, 0, pthread_mutex_lock(&by_dev_lock) );
        (void)hash_do_for_each(by_dev, update_util_each, &update);
        CHECK(int, 0, pthread_mutex_unlock(&by_dev_lock) );
}