// SPDX-License-Identifier: GPL-2.0-only

#include "dev.h"
#include "sysctl.h"
#include "fuse_dev_i.h"
#include "dev_uring_i.h"

/* Frequency (in seconds) of request timeout checks, if opted into */
#define FUSE_TIMEOUT_TIMER_FREQ 15

/* Frequency (in jiffies) of request timeout checks, if opted into */
static const unsigned long fuse_timeout_timer_freq =
        secs_to_jiffies(FUSE_TIMEOUT_TIMER_FREQ);

/*
 * Default timeout (in seconds) for the server to reply to a request
 * before the connection is aborted, if no timeout was specified on mount.
 *
 * Exported via sysctl
 */
unsigned int fuse_default_req_timeout;

/*
 * Max timeout (in seconds) for the server to reply to a request before
 * the connection is aborted.
 *
 * Exported via sysctl
 */
unsigned int fuse_max_req_timeout;

bool fuse_request_expired(struct fuse_chan *fch, struct list_head *list)
{
        struct fuse_req *req;

        req = list_first_entry_or_null(list, struct fuse_req, list);
        if (!req)
                return false;
        return time_is_before_jiffies(req->create_time + fch->timeout.req_timeout);
}

static bool fuse_fpq_processing_expired(struct fuse_chan *fch, struct list_head *processing)
{
        int i;

        for (i = 0; i < FUSE_PQ_HASH_SIZE; i++)
                if (fuse_request_expired(fch, &processing[i]))
                        return true;

        return false;
}

/*
 * Check if any requests aren't being completed by the time the request timeout
 * elapses. To do so, we:
 * - check the fiq pending list
 * - check the bg queue
 * - check the fpq io and processing lists
 *
 * To make this fast, we only check against the head request on each list since
 * these are generally queued in order of creation time (eg newer requests get
 * queued to the tail). We might miss a few edge cases (eg requests transitioning
 * between lists, re-sent requests at the head of the pending list having a
 * later creation time than other requests on that list, etc.) but that is fine
 * since if the request never gets fulfilled, it will eventually be caught.
 */
static void fuse_check_timeout(struct work_struct *work)
{
        struct delayed_work *dwork = to_delayed_work(work);
        struct fuse_chan *fch = container_of(dwork, struct fuse_chan, timeout.work);
        struct fuse_iqueue *fiq = &fch->iq;
        struct fuse_dev *fud;
        struct fuse_pqueue *fpq;
        bool expired = false;

        if (!atomic_read(&fch->num_waiting))
                goto out;

        spin_lock(&fiq->lock);
        expired = fuse_request_expired(fch, &fiq->pending);
        spin_unlock(&fiq->lock);
        if (expired)
                goto chan_abort;

        spin_lock(&fch->bg_lock);
        expired = fuse_request_expired(fch, &fch->bg_queue);
        spin_unlock(&fch->bg_lock);
        if (expired)
                goto chan_abort;

        spin_lock(&fch->lock);
        if (!fch->connected) {
                spin_unlock(&fch->lock);
                return;
        }
        list_for_each_entry(fud, &fch->devices, entry) {
                fpq = &fud->pq;
                spin_lock(&fpq->lock);
                if (fuse_request_expired(fch, &fpq->io) ||
                    fuse_fpq_processing_expired(fch, fpq->processing)) {
                        spin_unlock(&fpq->lock);
                        spin_unlock(&fch->lock);
                        goto chan_abort;
                }

                spin_unlock(&fpq->lock);
        }
        spin_unlock(&fch->lock);

        if (fuse_uring_request_expired(fch))
                goto chan_abort;

out:
        queue_delayed_work(system_percpu_wq, &fch->timeout.work,
                           fuse_timeout_timer_freq);
        return;

chan_abort:
        fuse_chan_abort(fch, false);
}

static void set_request_timeout(struct fuse_chan *fch, unsigned int timeout)
{
        fch->timeout.req_timeout = secs_to_jiffies(timeout);
        INIT_DELAYED_WORK(&fch->timeout.work, fuse_check_timeout);
        queue_delayed_work(system_percpu_wq, &fch->timeout.work,
                           fuse_timeout_timer_freq);
}

void fuse_init_server_timeout(struct fuse_chan *fch, unsigned int timeout)
{
        if (!timeout && !fuse_max_req_timeout && !fuse_default_req_timeout)
                return;

        if (!timeout)
                timeout = fuse_default_req_timeout;

        if (fuse_max_req_timeout) {
                if (timeout)
                        timeout = min(fuse_max_req_timeout, timeout);
                else
                        timeout = fuse_max_req_timeout;
        }

        timeout = max(FUSE_TIMEOUT_TIMER_FREQ, timeout);

        set_request_timeout(fch, timeout);
}