/*      $NetBSD: autofs.c,v 1.6 2020/05/23 23:42:43 ad Exp $    */

/*-
 * Copyright (c) 2017 The NetBSD Foundation, Inc.
 * Copyright (c) 2016 The DragonFly Project
 * Copyright (c) 2014 The FreeBSD Foundation
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Tomohiro Kusumi <kusumi.tomohiro@gmail.com>.
 *
 * This software was developed by Edward Tomasz Napierala under sponsorship
 * from the FreeBSD Foundation.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */
/*-
 * Copyright (c) 1989, 1991, 1993, 1995
 *      The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Rick Macklem at The University of Guelph.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: autofs.c,v 1.6 2020/05/23 23:42:43 ad Exp $");

#include "autofs.h"

#include "ioconf.h"

#include <sys/atomic.h>
#include <sys/queue.h>
#include <sys/signalvar.h>

static dev_type_open(autofs_open);
static dev_type_close(autofs_close);
static dev_type_ioctl(autofs_ioctl);

const struct cdevsw autofs_cdevsw = {
        .d_open = autofs_open,
        .d_close = autofs_close,
        .d_read = noread,
        .d_write = nowrite,
        .d_ioctl = autofs_ioctl,
        .d_stop = nostop,
        .d_tty = notty,
        .d_poll = nopoll,
        .d_mmap = nommap,
        .d_kqfilter = nokqfilter,
        .d_discard = nodiscard,
        .d_flag = D_OTHER,
};

/*
 * List of signals that can interrupt an autofs trigger.
 */
static int autofs_sig_set[] = {
        SIGINT,
        SIGTERM,
        SIGHUP,
        SIGKILL,
        SIGQUIT,
};

struct pool     autofs_request_pool;
struct pool     autofs_node_pool;
struct autofs_softc     *autofs_softc = NULL;
struct workqueue        *autofs_tmo_wq = NULL;

int autofs_debug = 1;
int autofs_mount_on_stat = 0;
int autofs_timeout = 30;
int autofs_cache = 600;
int autofs_retry_attempts = 3;
int autofs_retry_delay = 1;
int autofs_interruptible = 1;

void
autofsattach(int n)
{
}

static int
autofs_node_cmp(const struct autofs_node *a, const struct autofs_node *b)
{

        return strcmp(a->an_name, b->an_name);
}

RB_GENERATE(autofs_node_tree, autofs_node, an_entry, autofs_node_cmp);

bool
autofs_ignore_thread(void)
{

        if (autofs_softc->sc_dev_opened == false)
                return false;

        mutex_enter(&proc_lock);
        if (autofs_softc->sc_dev_sid == curproc->p_pgrp->pg_id) {
                mutex_exit(&proc_lock);
                return true;
        }
        mutex_exit(&proc_lock);

        return false;
}

static char *
autofs_path(struct autofs_node *anp)
{
        struct autofs_mount *amp = anp->an_mount;
        size_t len;
        char *path, *tmp;

        path = kmem_strdup("", KM_SLEEP);
        for (; anp->an_parent; anp = anp->an_parent) {
                len = strlen(anp->an_name) + strlen(path) + 2;
                tmp = kmem_alloc(len, KM_SLEEP);
                snprintf(tmp, len, "%s/%s", anp->an_name, path);
                kmem_strfree(path);
                path = tmp;
        }

        len = strlen(amp->am_on) + strlen(path) + 2;
        tmp = kmem_alloc(len, KM_SLEEP);
        snprintf(tmp, len, "%s/%s", amp->am_on, path);
        kmem_strfree(path);

        return tmp;
}

void
autofs_timeout_wq(struct work *wk, void *arg)
{
        struct autofs_request *ar = (void *)wk;

        mutex_enter(&autofs_softc->sc_lock);
        AUTOFS_WARN("request %d for %s timed out after %d seconds",
            ar->ar_id, ar->ar_path, autofs_timeout);

        ar->ar_error = ETIMEDOUT;
        ar->ar_wildcards = true;
        ar->ar_done = true;
        ar->ar_in_progress = false;
        cv_broadcast(&autofs_softc->sc_cv);
        mutex_exit(&autofs_softc->sc_lock);
}

static void
autofs_timeout_callout(void *context)
{
        struct autofs_request *ar = context;

        workqueue_enqueue(autofs_tmo_wq, &ar->ar_wk, NULL);
}

bool
autofs_cached(struct autofs_node *anp, const char *component, int componentlen)
{
        struct autofs_mount *amp = anp->an_mount;

        KASSERT(!mutex_owned(&amp->am_lock));

        /*
         * For root node we need to request automountd(8) assistance even
         * if the node is marked as cached, but the requested top-level
         * directory does not exist.  This is necessary for wildcard indirect
         * map keys to work.  We don't do this if we know that there are
         * no wildcards.
         */
        if (!anp->an_parent && componentlen && anp->an_wildcards) {
                int error;
                KASSERT(amp->am_root == anp);
                mutex_enter(&amp->am_lock);
                error = autofs_node_find(anp, component, componentlen, NULL);
                mutex_exit(&amp->am_lock);
                if (error)
                        return false;
        }

        return anp->an_cached;
}

static void
autofs_cache_callout(void *context)
{
        struct autofs_node *anp = context;

        autofs_node_uncache(anp);
}

void
autofs_flush(struct autofs_mount *amp)
{
        struct autofs_node *anp = amp->am_root;
        struct autofs_node *child;

        mutex_enter(&amp->am_lock);
        RB_FOREACH(child, autofs_node_tree, &anp->an_children) {
                autofs_node_uncache(child);
        }
        autofs_node_uncache(amp->am_root);
        mutex_exit(&amp->am_lock);

        AUTOFS_DEBUG("%s flushed", amp->am_on);
}

/*
 * The set/restore sigmask functions are used to (temporarily) overwrite
 * the thread sigmask during triggering.
 */
static void
autofs_set_sigmask(sigset_t *oldset)
{
        sigset_t newset;
        int i;

        sigfillset(&newset);
        /* Remove the autofs set of signals from newset */
        mutex_enter(&proc_lock);
        mutex_enter(curproc->p_lock);

        for (i = 0; i < __arraycount(autofs_sig_set); i++) {
                /*
                 * But make sure we leave the ones already masked
                 * by the process, i.e. remove the signal from the
                 * temporary signalmask only if it wasn't already
                 * in sigmask.
                 */
                if (!sigismasked(curlwp, autofs_sig_set[i]))
                        sigdelset(&newset, autofs_sig_set[i]);
        }
        sigprocmask1(curlwp, SIG_SETMASK, &newset, oldset);

        mutex_exit(curproc->p_lock);
        mutex_exit(&proc_lock);
}

static void
autofs_restore_sigmask(sigset_t *set)
{

        mutex_enter(&proc_lock);
        mutex_enter(curproc->p_lock);

        sigprocmask1(curlwp, SIG_SETMASK, set, NULL);

        mutex_exit(curproc->p_lock);
        mutex_exit(&proc_lock);
}

static int
autofs_trigger_one(struct autofs_node *anp, const char *component,
    int componentlen)
{
        struct autofs_mount *amp = anp->an_mount;
        struct autofs_request *ar;
        char *key, *path;
        int error = 0, request_error;
        bool wildcards;

        KASSERT(mutex_owned(&autofs_softc->sc_lock));

        if (!anp->an_parent) {
                key = autofs_strndup(component, componentlen, KM_SLEEP);
        } else {
                struct autofs_node *firstanp;
                for (firstanp = anp; firstanp->an_parent->an_parent;
                    firstanp = firstanp->an_parent)
                        continue;
                key = kmem_strdup(firstanp->an_name, KM_SLEEP);
        }

        path = autofs_path(anp);

        TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) {
                if (strcmp(ar->ar_path, path))
                        continue;
                if (strcmp(ar->ar_key, key))
                        continue;

                KASSERT(!strcmp(ar->ar_from, amp->am_from));
                KASSERT(!strcmp(ar->ar_prefix, amp->am_prefix));
                KASSERT(!strcmp(ar->ar_options, amp->am_options));
                break;
        }

        if (ar) {
                atomic_add_int(&ar->ar_refcount, 1);
        } else {
                ar = pool_get(&autofs_request_pool, PR_WAITOK);
                ar->ar_mount = amp;
                ar->ar_id = autofs_softc->sc_last_request_id++;
                ar->ar_done = false;
                ar->ar_error = 0;
                ar->ar_wildcards = false;
                ar->ar_in_progress = false;
                strlcpy(ar->ar_from, amp->am_from, sizeof(ar->ar_from));
                strlcpy(ar->ar_path, path, sizeof(ar->ar_path));
                strlcpy(ar->ar_prefix, amp->am_prefix, sizeof(ar->ar_prefix));
                strlcpy(ar->ar_key, key, sizeof(ar->ar_key));
                strlcpy(ar->ar_options,
                    amp->am_options, sizeof(ar->ar_options));

                callout_init(&ar->ar_callout, 0);
                callout_reset(&ar->ar_callout, autofs_timeout * hz,
                    autofs_timeout_callout, ar);
                ar->ar_refcount = 1;
                TAILQ_INSERT_TAIL(&autofs_softc->sc_requests, ar, ar_next);
        }

        cv_broadcast(&autofs_softc->sc_cv);
        while (ar->ar_done == false) {
                if (autofs_interruptible) {
                        sigset_t oldset;
                        autofs_set_sigmask(&oldset);
                        error = cv_wait_sig(&autofs_softc->sc_cv,
                            &autofs_softc->sc_lock);
                        autofs_restore_sigmask(&oldset);
                        if (error) {
                                AUTOFS_WARN("cv_wait_sig for %s failed "
                                    "with error %d", ar->ar_path, error);
                                break;
                        }
                } else {
                        cv_wait(&autofs_softc->sc_cv, &autofs_softc->sc_lock);
                }
        }

        request_error = ar->ar_error;
        if (request_error)
                AUTOFS_WARN("request for %s completed with error %d, "
                    "pid %d (%s)", ar->ar_path, request_error,
                    curproc->p_pid, curproc->p_comm);

        wildcards = ar->ar_wildcards;

        /*
         * Check if this is the last reference.
         */
        if (!atomic_add_int_nv(&ar->ar_refcount, -1)) {
                TAILQ_REMOVE(&autofs_softc->sc_requests, ar, ar_next);
                mutex_exit(&autofs_softc->sc_lock);
                callout_halt(&ar->ar_callout, NULL);
                pool_put(&autofs_request_pool, ar);
                mutex_enter(&autofs_softc->sc_lock);
        }

        /*
         * Note that we do not do negative caching on purpose.  This
         * way the user can retry access at any time, e.g. after fixing
         * the failure reason, without waiting for cache timer to expire.
         */
        if (!error && !request_error && autofs_cache > 0) {
                autofs_node_cache(anp);
                anp->an_wildcards = wildcards;
                callout_reset(&anp->an_callout, autofs_cache * hz,
                    autofs_cache_callout, anp);
        }

        kmem_strfree(key);
        kmem_strfree(path);

        if (error)
                return error;
        return request_error;
}

int
autofs_trigger(struct autofs_node *anp, const char *component,
    int componentlen)
{
        for (;;) {
                int error, dummy;

                error = autofs_trigger_one(anp, component, componentlen);
                if (!error) {
                        anp->an_retries = 0;
                        return 0;
                }
                if (error == EINTR || error == ERESTART) {
                        AUTOFS_DEBUG("trigger interrupted by signal, "
                            "not retrying");
                        anp->an_retries = 0;
                        return error;
                }
                anp->an_retries++;
                if (anp->an_retries >= autofs_retry_attempts) {
                        AUTOFS_DEBUG("trigger failed %d times; returning "
                            "error %d", anp->an_retries, error);
                        anp->an_retries = 0;
                        return error;

                }
                AUTOFS_DEBUG("trigger failed with error %d; will retry in "
                    "%d seconds, %d attempts left", error, autofs_retry_delay,
                    autofs_retry_attempts - anp->an_retries);
                mutex_exit(&autofs_softc->sc_lock);
                tsleep(&dummy, 0, "autofs_retry", autofs_retry_delay * hz);
                mutex_enter(&autofs_softc->sc_lock);
        }
}

static int
autofs_ioctl_request(struct autofs_daemon_request *adr)
{
        struct autofs_request *ar;

        mutex_enter(&autofs_softc->sc_lock);
        for (;;) {
                int error;
                TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) {
                        if (ar->ar_done)
                                continue;
                        if (ar->ar_in_progress)
                                continue;
                        break;
                }

                if (ar)
                        break;

                error = cv_wait_sig(&autofs_softc->sc_cv,
                    &autofs_softc->sc_lock);
                if (error) {
                        mutex_exit(&autofs_softc->sc_lock);
                        return error;
                }
        }

        ar->ar_in_progress = true;
        mutex_exit(&autofs_softc->sc_lock);

        adr->adr_id = ar->ar_id;
        strlcpy(adr->adr_from, ar->ar_from, sizeof(adr->adr_from));
        strlcpy(adr->adr_path, ar->ar_path, sizeof(adr->adr_path));
        strlcpy(adr->adr_prefix, ar->ar_prefix, sizeof(adr->adr_prefix));
        strlcpy(adr->adr_key, ar->ar_key, sizeof(adr->adr_key));
        strlcpy(adr->adr_options, ar->ar_options, sizeof(adr->adr_options));

        mutex_enter(&proc_lock);
        autofs_softc->sc_dev_sid = curproc->p_pgrp->pg_id;
        mutex_exit(&proc_lock);

        return 0;
}

static int
autofs_ioctl_done(struct autofs_daemon_done *add)
{
        struct autofs_request *ar;

        mutex_enter(&autofs_softc->sc_lock);
        TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) {
                if (ar->ar_id == add->add_id)
                        break;
        }

        if (!ar) {
                mutex_exit(&autofs_softc->sc_lock);
                AUTOFS_DEBUG("id %d not found", add->add_id);
                return ESRCH;
        }

        ar->ar_error = add->add_error;
        ar->ar_wildcards = add->add_wildcards;
        ar->ar_done = true;
        ar->ar_in_progress = false;
        cv_broadcast(&autofs_softc->sc_cv);

        mutex_exit(&autofs_softc->sc_lock);

        return 0;
}

static int
autofs_open(dev_t dev, int flags, int mode, struct lwp *l)
{

        mutex_enter(&autofs_softc->sc_lock);
        /*
         * We must never block automountd(8) and its descendants, and we use
         * session ID to determine that: we store session id of the process
         * that opened the device, and then compare it with session ids
         * of triggering processes.  This means running a second automountd(8)
         * instance would break the previous one.  The check below prevents
         * it from happening.
         */
        if (autofs_softc->sc_dev_opened) {
                mutex_exit(&autofs_softc->sc_lock);
                return EBUSY;
        }

        autofs_softc->sc_dev_opened = true;
        mutex_exit(&autofs_softc->sc_lock);

        return 0;
}

static int
autofs_close(dev_t dev, int flags, int mode, struct lwp *l)
{

        mutex_enter(&autofs_softc->sc_lock);
        KASSERT(autofs_softc->sc_dev_opened);
        autofs_softc->sc_dev_opened = false;
        mutex_exit(&autofs_softc->sc_lock);

        return 0;
}

static int
autofs_ioctl(dev_t dev, const u_long cmd, void *data, int flag, struct lwp *l)
{

        KASSERT(autofs_softc->sc_dev_opened);

        switch (cmd) {
        case AUTOFSREQUEST:
                return autofs_ioctl_request(
                    (struct autofs_daemon_request *)data);
        case AUTOFSDONE:
                return autofs_ioctl_done(
                    (struct autofs_daemon_done *)data);
        default:
                AUTOFS_DEBUG("invalid cmd %lx", cmd);
                return EINVAL;
        }
        return EINVAL;
}