workqueue: Preserve OFFQ bits in cancel[_sync] paths

The cancel[_sync] paths acquire and release WORK_STRUCT_PENDING, and
manipulate WORK_OFFQ_CANCELING. However, they assume that all the OFFQ bit
values except for the pool ID are statically known and don't preserve them,
which is not wrong in the current code as the pool ID and CANCELING are the
only information carried. However, the planned disable/enable support will
add more fields and need them to be preserved.

This patch updates work data handling so that only the bits which need
updating are updated.

- struct work_offq_data is added along with work_offqd_unpack() and
  work_offqd_pack_flags() to help manipulating multiple fields contained in
  work->data. Note that the helpers look a bit silly right now as there
  isn't that much to pack. The next patch will add more.

- mark_work_canceling() which is used only by __cancel_work_sync() is
  replaced by open-coded usage of work_offq_data and
  set_work_pool_and_keep_pending() in __cancel_work_sync().

- __cancel_work[_sync]() uses offq_data helpers to preserve other OFFQ bits
  when clearing WORK_STRUCT_PENDING and WORK_OFFQ_CANCELING at the end.

- This removes all users of get_work_pool_id() which is dropped. Note that
  get_work_pool_id() could handle both WORK_STRUCT_PWQ and !WORK_STRUCT_PWQ
  cases; however, it was only being called after try_to_grab_pending()
  succeeded, in which case WORK_STRUCT_PWQ is never set and thus it's safe
  to use work_offqd_unpack() instead.

No behavior changes intended.

Signed-off-by: Tejun Heo <tj@kernel.org>
Reviewed-by: Lai Jiangshan <jiangshanlai@gmail.com>

diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index 158784dd189ab2a424b02fca0760f95f0af7de2d..ae7ae4a51499ce33457f0190b1ffd873b75c1c86 100644 (file)
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -97,6 +97,7 @@ enum wq_misc_consts {
 
 /* Convenience constants - of type 'unsigned long', not 'enum'! */
 #define WORK_OFFQ_CANCELING    (1ul << WORK_OFFQ_CANCELING_BIT)
+#define WORK_OFFQ_FLAG_MASK    (((1ul << WORK_OFFQ_FLAG_BITS) - 1) << WORK_OFFQ_FLAG_SHIFT)
 #define WORK_OFFQ_POOL_NONE    ((1ul << WORK_OFFQ_POOL_BITS) - 1)
 #define WORK_STRUCT_NO_POOL    (WORK_OFFQ_POOL_NONE << WORK_OFFQ_POOL_SHIFT)
 #define WORK_STRUCT_PWQ_MASK   (~((1ul << WORK_STRUCT_PWQ_SHIFT) - 1))

diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 0066c8f6c15442641889c87995410ac82d078423..d8f37cfa993504738089b95b2741f943382b34a8 100644 (file)
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -392,6 +392,11 @@ struct wq_pod_type {
        int                     *cpu_pod;       /* cpu -> pod */
 };
 
+struct work_offq_data {
+       u32                     pool_id;
+       u32                     flags;
+};
+
 static const char *wq_affn_names[WQ_AFFN_NR_TYPES] = {
        [WQ_AFFN_DFL]           = "default",
        [WQ_AFFN_CPU]           = "cpu",
@@ -892,29 +897,23 @@ static struct worker_pool *get_work_pool(struct work_struct *work)
        return idr_find(&worker_pool_idr, pool_id);
 }
 
-/**
- * get_work_pool_id - return the worker pool ID a given work is associated with
- * @work: the work item of interest
- *
- * Return: The worker_pool ID @work was last associated with.
- * %WORK_OFFQ_POOL_NONE if none.
- */
-static int get_work_pool_id(struct work_struct *work)
+static unsigned long shift_and_mask(unsigned long v, u32 shift, u32 bits)
 {
-       unsigned long data = atomic_long_read(&work->data);
+       return (v >> shift) & ((1 << bits) - 1);
+}
 
-       if (data & WORK_STRUCT_PWQ)
-               return work_struct_pwq(data)->pool->id;
+static void work_offqd_unpack(struct work_offq_data *offqd, unsigned long data)
+{
+       WARN_ON_ONCE(data & WORK_STRUCT_PWQ);
 
-       return data >> WORK_OFFQ_POOL_SHIFT;
+       offqd->pool_id = shift_and_mask(data, WORK_OFFQ_POOL_SHIFT,
+                                       WORK_OFFQ_POOL_BITS);
+       offqd->flags = data & WORK_OFFQ_FLAG_MASK;
 }
 
-static void mark_work_canceling(struct work_struct *work)
+static unsigned long work_offqd_pack_flags(struct work_offq_data *offqd)
 {
-       unsigned long pool_id = get_work_pool_id(work);
-
-       pool_id <<= WORK_OFFQ_POOL_SHIFT;
-       set_work_data(work, pool_id | WORK_STRUCT_PENDING | WORK_OFFQ_CANCELING);
+       return (unsigned long)offqd->flags;
 }
 
 static bool work_is_canceling(struct work_struct *work)
@@ -4271,6 +4270,7 @@ EXPORT_SYMBOL(flush_rcu_work);
 
 static bool __cancel_work(struct work_struct *work, u32 cflags)
 {
+       struct work_offq_data offqd;
        unsigned long irq_flags;
        int ret;
 
@@ -4281,19 +4281,26 @@ static bool __cancel_work(struct work_struct *work, u32 cflags)
        if (unlikely(ret < 0))
                return false;
 
-       set_work_pool_and_clear_pending(work, get_work_pool_id(work), 0);
+       work_offqd_unpack(&offqd, *work_data_bits(work));
+       set_work_pool_and_clear_pending(work, offqd.pool_id,
+                                       work_offqd_pack_flags(&offqd));
        local_irq_restore(irq_flags);
        return ret;
 }
 
 static bool __cancel_work_sync(struct work_struct *work, u32 cflags)
 {
+       struct work_offq_data offqd;
        unsigned long irq_flags;
        bool ret;
 
        /* claim @work and tell other tasks trying to grab @work to back off */
        ret = work_grab_pending(work, cflags, &irq_flags);
-       mark_work_canceling(work);
+
+       work_offqd_unpack(&offqd, *work_data_bits(work));
+       offqd.flags |= WORK_OFFQ_CANCELING;
+       set_work_pool_and_keep_pending(work, offqd.pool_id,
+                                      work_offqd_pack_flags(&offqd));
        local_irq_restore(irq_flags);
 
        /*
@@ -4303,12 +4310,16 @@ static bool __cancel_work_sync(struct work_struct *work, u32 cflags)
        if (wq_online)
                __flush_work(work, true);
 
+       work_offqd_unpack(&offqd, *work_data_bits(work));
+
        /*
         * smp_mb() at the end of set_work_pool_and_clear_pending() is paired
         * with prepare_to_wait() above so that either waitqueue_active() is
         * visible here or !work_is_canceling() is visible there.
         */
-       set_work_pool_and_clear_pending(work, WORK_OFFQ_POOL_NONE, 0);
+       offqd.flags &= ~WORK_OFFQ_CANCELING;
+       set_work_pool_and_clear_pending(work, WORK_OFFQ_POOL_NONE,
+                                       work_offqd_pack_flags(&offqd));
 
        if (waitqueue_active(&wq_cancel_waitq))
                __wake_up(&wq_cancel_waitq, TASK_NORMAL, 1, work);