[PATCH 3/9] io-wq: add infra data structure for fixed workers

Hao Xu
2022-04-29T10:19:14Z

Add data sttructure and basic initialization for fixed worker.

Signed-off-by: Hao Xu <howeyxu@tencent.com>
---
fs/io-wq.c | 98 ++++++++++++++++++++++++++++++++++++++++++++++++------
1 file changed, 87 insertions(+), 11 deletions(-)

diff --git a/fs/io-wq.c b/fs/io-wq.c
index 35ce622f77ba..ac8faf1f7a0a 100644
--- a/fs/io-wq.c
+++ b/fs/io-wq.c
@@ -26,6 +26,7 @@ enum {
IO_WORKER_F_RUNNING = 2, /* account as running */
IO_WORKER_F_FREE = 4, /* worker on free list */
IO_WORKER_F_BOUND = 8, /* is doing bounded work */
+ IO_WORKER_F_FIXED = 16, /* is a fixed worker */
IO_WORKER_F_EXIT = 32, /* worker is exiting */
};

@@ -37,6 +38,61 @@ enum {
IO_ACCT_STALLED_BIT = 0, /* stalled on hash */
};

+struct io_wqe_acct {
+ /*
+ * union {
+ * 1) for normal worker
+ * struct {
+ * unsigned nr_workers;
+ * unsigned max_workers;
+ * struct io_wq_work_list work_list;
+ * };
+ * 2) for fixed worker
+ * struct {
+ * unsigned nr_workers; // not meaningful
+ * unsigned max_workers; // not meaningful
+ * unsigned nr_fixed;
+ * unsigned max_works;
+ * struct io_worker **fixed_workers;
+ * };
+ * 3) for fixed worker's private acct
+ * struct {
+ * unsigned nr_works;
+ * unsigned max_works;
+ * struct io_wq_work_list work_list;
+ * };
+ *};
+ */
+ union {
+ unsigned nr_workers;
+ unsigned nr_works;
+ };
+ unsigned max_workers;
+ unsigned nr_fixed;
+ unsigned max_works;
+ union {
+ struct io_wq_work_list work_list;
+ struct io_worker **fixed_workers;
+ };
+ /*
+ * nr_running is not meaningful for fixed worker
+ * but still keep the same logic for it for the
+ * convinence for now. So do nr_workers and
+ * max_workers.
+ */
+ atomic_t nr_running;
+ /*
+ * For 1), it protects the work_list, the other two member nr_workers
+ * and max_workers are protected by wqe->lock.
+ * For 2), it protects nr_fixed, max_works, fixed_workers
+ * For 3), it protects nr_works, max_works and work_list.
+ */
+ raw_spinlock_t lock;
+ int index;
+ unsigned long flags;
+ bool fixed_worker_registered;
+};
+
/*
* One for each thread in a wqe pool
*/
@@ -62,6 +118,8 @@ struct io_worker {
struct rcu_head rcu;
struct work_struct work;
};
+ int index;
+ struct io_wqe_acct acct;
};

#if BITS_PER_LONG == 64
@@ -72,16 +130,6 @@ struct io_worker {

#define IO_WQ_NR_HASH_BUCKETS (1u << IO_WQ_HASH_ORDER)

-struct io_wqe_acct {
- unsigned nr_workers;
- unsigned max_workers;
- int index;
- atomic_t nr_running;
- raw_spinlock_t lock;
- struct io_wq_work_list work_list;
- unsigned long flags;
-};
-
enum {
IO_WQ_ACCT_BOUND,
IO_WQ_ACCT_UNBOUND,
@@ -94,6 +142,7 @@ enum {
struct io_wqe {
raw_spinlock_t lock;
struct io_wqe_acct acct[IO_WQ_ACCT_NR];
+ struct io_wqe_acct fixed_acct[IO_WQ_ACCT_NR];

int node;

@@ -1205,6 +1254,31 @@ struct io_wq *io_wq_create(unsigned bounded, struct io_wq_data *data)
atomic_set(&acct->nr_running, 0);
INIT_WQ_LIST(&acct->work_list);
raw_spin_lock_init(&acct->lock);
+
+ acct = &wqe->fixed_acct[i];
+ acct->index = i;
+ INIT_WQ_LIST(&acct->work_list);
+ raw_spin_lock_init(&acct->lock);
+ /*
+ * nr_running for a fixed worker is meaningless
+ * for now, init it to 1 to wround around the
+ * io_wqe_dec_running logic
+ */
+ atomic_set(&acct->nr_running, 1);
+ /*
+ * max_workers for a fixed worker is meaningless
+ * for now, init it so since number of fixed workers
+ * should be controlled by users.
+ */
+ acct->max_workers = task_rlimit(current, RLIMIT_NPROC);
+ raw_spin_lock_init(&acct->lock);
+ /*
+ * For fixed worker, not necessary
+ * but do it explicitly for clearity
+ */
+ acct->nr_fixed = 0;
+ acct->max_works = 0;
+ acct->fixed_workers = NULL;
}
wqe->wq = wq;
raw_spin_lock_init(&wqe->lock);
@@ -1287,7 +1361,7 @@ static void io_wq_exit_workers(struct io_wq *wq)

static void io_wq_destroy(struct io_wq *wq)
{
- int node;
+ int i, node;

cpuhp_state_remove_instance_nocalls(io_wq_online, &wq->cpuhp_node);

@@ -1299,6 +1373,8 @@ static void io_wq_destroy(struct io_wq *wq)
};
io_wqe_cancel_pending_work(wqe, &match);
free_cpumask_var(wqe->cpu_mask);
+ for (i = 0; i < IO_WQ_ACCT_NR; i++)
+ kfree(wqe->fixed_acct[i].fixed_workers);
kfree(wqe);
}
io_wq_put_hash(wq->hash);
--
2.36.0