Merge branch 'for-4.17' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq
authorLinus Torvalds <torvalds@linux-foundation.org>
Wed, 4 Apr 2018 01:00:13 +0000 (18:00 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Wed, 4 Apr 2018 01:00:13 +0000 (18:00 -0700)
Pull workqueue updates from Tejun Heo:
 "rcu_work addition and a couple trivial changes"

* 'for-4.17' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq:
  workqueue: remove the comment about the old manager_arb mutex
  workqueue: fix the comments of nr_idle
  fs/aio: Use rcu_work instead of explicit rcu and work item
  cgroup: Use rcu_work instead of explicit rcu and work item
  RCU, workqueue: Implement rcu_work

1  2 
include/linux/cgroup-defs.h
include/linux/workqueue.h
kernel/cgroup/cgroup.c
kernel/workqueue.c

index f8e76d01a5ade411c231c926e55e59a71dde6cc5,92d7640632ef4a790e01a9ee7f9c12a3a8fd68e0..dc5b70449dc60ec5163ba891005283525acda40c
@@@ -151,8 -151,8 +151,8 @@@ struct cgroup_subsys_state 
        atomic_t online_cnt;
  
        /* percpu_ref killing and RCU release */
-       struct rcu_head rcu_head;
        struct work_struct destroy_work;
+       struct rcu_work destroy_rwork;
  
        /*
         * PI: the parent css.  Placed here for cache proximity to following
@@@ -755,13 -755,13 +755,13 @@@ struct sock_cgroup_data 
   * updaters and return part of the previous pointer as the prioidx or
   * classid.  Such races are short-lived and the result isn't critical.
   */
 -static inline u16 sock_cgroup_prioidx(struct sock_cgroup_data *skcd)
 +static inline u16 sock_cgroup_prioidx(const struct sock_cgroup_data *skcd)
  {
        /* fallback to 1 which is always the ID of the root cgroup */
        return (skcd->is_data & 1) ? skcd->prioidx : 1;
  }
  
 -static inline u32 sock_cgroup_classid(struct sock_cgroup_data *skcd)
 +static inline u32 sock_cgroup_classid(const struct sock_cgroup_data *skcd)
  {
        /* fallback to 0 which is the unconfigured default classid */
        return (skcd->is_data & 1) ? skcd->classid : 0;
index 0c3301421c57746c086996e67401a167c82fe98c,d026f8f818cc95dad3c8c3db6d0b77a4ca0e1b91..39a0e215022a458e21ed57af697ba8e544510bfc
@@@ -13,6 -13,7 +13,7 @@@
  #include <linux/threads.h>
  #include <linux/atomic.h>
  #include <linux/cpumask.h>
+ #include <linux/rcupdate.h>
  
  struct workqueue_struct;
  
@@@ -120,6 -121,14 +121,14 @@@ struct delayed_work 
        int cpu;
  };
  
+ struct rcu_work {
+       struct work_struct work;
+       struct rcu_head rcu;
+       /* target workqueue ->rcu uses to queue ->work */
+       struct workqueue_struct *wq;
+ };
  /**
   * struct workqueue_attrs - A struct for workqueue attributes.
   *
@@@ -151,6 -160,11 +160,11 @@@ static inline struct delayed_work *to_d
        return container_of(work, struct delayed_work, work);
  }
  
+ static inline struct rcu_work *to_rcu_work(struct work_struct *work)
+ {
+       return container_of(work, struct rcu_work, work);
+ }
  struct execute_work {
        struct work_struct work;
  };
@@@ -266,6 -280,12 +280,12 @@@ static inline unsigned int work_static(
  #define INIT_DEFERRABLE_WORK_ONSTACK(_work, _func)                    \
        __INIT_DELAYED_WORK_ONSTACK(_work, _func, TIMER_DEFERRABLE)
  
+ #define INIT_RCU_WORK(_work, _func)                                   \
+       INIT_WORK(&(_work)->work, (_func))
+ #define INIT_RCU_WORK_ONSTACK(_work, _func)                           \
+       INIT_WORK_ONSTACK(&(_work)->work, (_func))
  /**
   * work_pending - Find out whether a work item is currently pending
   * @work: The work item in question
@@@ -447,6 -467,7 +467,7 @@@ extern bool queue_delayed_work_on(int c
                        struct delayed_work *work, unsigned long delay);
  extern bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq,
                        struct delayed_work *dwork, unsigned long delay);
+ extern bool queue_rcu_work(struct workqueue_struct *wq, struct rcu_work *rwork);
  
  extern void flush_workqueue(struct workqueue_struct *wq);
  extern void drain_workqueue(struct workqueue_struct *wq);
@@@ -456,12 -477,15 +477,14 @@@ extern int schedule_on_each_cpu(work_fu
  int execute_in_process_context(work_func_t fn, struct execute_work *);
  
  extern bool flush_work(struct work_struct *work);
 -extern bool cancel_work(struct work_struct *work);
  extern bool cancel_work_sync(struct work_struct *work);
  
  extern bool flush_delayed_work(struct delayed_work *dwork);
  extern bool cancel_delayed_work(struct delayed_work *dwork);
  extern bool cancel_delayed_work_sync(struct delayed_work *dwork);
  
+ extern bool flush_rcu_work(struct rcu_work *rwork);
  extern void workqueue_set_max_active(struct workqueue_struct *wq,
                                     int max_active);
  extern struct work_struct *current_work(void);
diff --combined kernel/cgroup/cgroup.c
index 4bfb2908ec157204692424bc1b1a32a7ef185b29,4c5d4ca0d4e40a1e8dde79dc5f37e9286e6540fb..a662bfcbea0e79725023dd9a5c9118d2e3fcdada
@@@ -3183,16 -3183,6 +3183,16 @@@ static int cgroup_enable_threaded(struc
        if (cgroup_is_threaded(cgrp))
                return 0;
  
 +      /*
 +       * If @cgroup is populated or has domain controllers enabled, it
 +       * can't be switched.  While the below cgroup_can_be_thread_root()
 +       * test can catch the same conditions, that's only when @parent is
 +       * not mixable, so let's check it explicitly.
 +       */
 +      if (cgroup_is_populated(cgrp) ||
 +          cgrp->subtree_control & ~cgrp_dfl_threaded_ss_mask)
 +              return -EOPNOTSUPP;
 +
        /* we're joining the parent's domain, ensure its validity */
        if (!cgroup_is_valid_domain(dom_cgrp) ||
            !cgroup_can_be_thread_root(dom_cgrp))
@@@ -4524,10 -4514,10 +4524,10 @@@ static struct cftype cgroup_base_files[
   * and thus involve punting to css->destroy_work adding two additional
   * steps to the already complex sequence.
   */
- static void css_free_work_fn(struct work_struct *work)
+ static void css_free_rwork_fn(struct work_struct *work)
  {
-       struct cgroup_subsys_state *css =
-               container_of(work, struct cgroup_subsys_state, destroy_work);
+       struct cgroup_subsys_state *css = container_of(to_rcu_work(work),
+                               struct cgroup_subsys_state, destroy_rwork);
        struct cgroup_subsys *ss = css->ss;
        struct cgroup *cgrp = css->cgroup;
  
        }
  }
  
- static void css_free_rcu_fn(struct rcu_head *rcu_head)
- {
-       struct cgroup_subsys_state *css =
-               container_of(rcu_head, struct cgroup_subsys_state, rcu_head);
-       INIT_WORK(&css->destroy_work, css_free_work_fn);
-       queue_work(cgroup_destroy_wq, &css->destroy_work);
- }
  static void css_release_work_fn(struct work_struct *work)
  {
        struct cgroup_subsys_state *css =
  
        mutex_unlock(&cgroup_mutex);
  
-       call_rcu(&css->rcu_head, css_free_rcu_fn);
+       INIT_RCU_WORK(&css->destroy_rwork, css_free_rwork_fn);
+       queue_rcu_work(cgroup_destroy_wq, &css->destroy_rwork);
  }
  
  static void css_release(struct percpu_ref *ref)
@@@ -4765,7 -4747,8 +4757,8 @@@ static struct cgroup_subsys_state *css_
  err_list_del:
        list_del_rcu(&css->sibling);
  err_free_css:
-       call_rcu(&css->rcu_head, css_free_rcu_fn);
+       INIT_RCU_WORK(&css->destroy_rwork, css_free_rwork_fn);
+       queue_rcu_work(cgroup_destroy_wq, &css->destroy_rwork);
        return ERR_PTR(err);
  }
  
diff --combined kernel/workqueue.c
index 254e636a3d6b221eb96cc7c83be737578fd563f2,636c6d702b933084d74e1070bed4473dc21d8aca..ca7959be8aaa1bf4bd6f540c54db614974db8586
@@@ -153,10 -153,9 +153,9 @@@ struct worker_pool 
        unsigned long           watchdog_ts;    /* L: watchdog timestamp */
  
        struct list_head        worklist;       /* L: list of pending works */
-       int                     nr_workers;     /* L: total number of workers */
  
-       /* nr_idle includes the ones off idle_list for rebinding */
-       int                     nr_idle;        /* L: currently idle ones */
+       int                     nr_workers;     /* L: total number of workers */
+       int                     nr_idle;        /* L: currently idle workers */
  
        struct list_head        idle_list;      /* X: list of idle workers */
        struct timer_list       idle_timer;     /* L: worker idle timeout */
        DECLARE_HASHTABLE(busy_hash, BUSY_WORKER_HASH_ORDER);
                                                /* L: hash of busy workers */
  
-       /* see manage_workers() for details on the two manager mutexes */
        struct worker           *manager;       /* L: purely informational */
        struct mutex            attach_mutex;   /* attach/detach exclusion */
        struct list_head        workers;        /* A: attached workers */
@@@ -1604,6 -1602,40 +1602,40 @@@ bool mod_delayed_work_on(int cpu, struc
  }
  EXPORT_SYMBOL_GPL(mod_delayed_work_on);
  
+ static void rcu_work_rcufn(struct rcu_head *rcu)
+ {
+       struct rcu_work *rwork = container_of(rcu, struct rcu_work, rcu);
+       /* read the comment in __queue_work() */
+       local_irq_disable();
+       __queue_work(WORK_CPU_UNBOUND, rwork->wq, &rwork->work);
+       local_irq_enable();
+ }
+ /**
+  * queue_rcu_work - queue work after a RCU grace period
+  * @wq: workqueue to use
+  * @rwork: work to queue
+  *
+  * Return: %false if @rwork was already pending, %true otherwise.  Note
+  * that a full RCU grace period is guaranteed only after a %true return.
+  * While @rwork is guarnateed to be executed after a %false return, the
+  * execution may happen before a full RCU grace period has passed.
+  */
+ bool queue_rcu_work(struct workqueue_struct *wq, struct rcu_work *rwork)
+ {
+       struct work_struct *work = &rwork->work;
+       if (!test_and_set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))) {
+               rwork->wq = wq;
+               call_rcu(&rwork->rcu, rcu_work_rcufn);
+               return true;
+       }
+       return false;
+ }
+ EXPORT_SYMBOL(queue_rcu_work);
  /**
   * worker_enter_idle - enter idle state
   * @worker: worker which is entering idle state
@@@ -3001,6 -3033,26 +3033,26 @@@ bool flush_delayed_work(struct delayed_
  }
  EXPORT_SYMBOL(flush_delayed_work);
  
+ /**
+  * flush_rcu_work - wait for a rwork to finish executing the last queueing
+  * @rwork: the rcu work to flush
+  *
+  * Return:
+  * %true if flush_rcu_work() waited for the work to finish execution,
+  * %false if it was already idle.
+  */
+ bool flush_rcu_work(struct rcu_work *rwork)
+ {
+       if (test_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(&rwork->work))) {
+               rcu_barrier();
+               flush_work(&rwork->work);
+               return true;
+       } else {
+               return flush_work(&rwork->work);
+       }
+ }
+ EXPORT_SYMBOL(flush_rcu_work);
  static bool __cancel_work(struct work_struct *work, bool is_dwork)
  {
        unsigned long flags;
        return ret;
  }
  
 -/*
 - * See cancel_delayed_work()
 - */
 -bool cancel_work(struct work_struct *work)
 -{
 -      return __cancel_work(work, false);
 -}
 -
  /**
   * cancel_delayed_work - cancel a delayed work
   * @dwork: delayed_work to cancel
@@@ -5329,7 -5389,7 +5381,7 @@@ int workqueue_sysfs_register(struct wor
  
        ret = device_register(&wq_dev->dev);
        if (ret) {
 -              kfree(wq_dev);
 +              put_device(&wq_dev->dev);
                wq->wq_dev = NULL;
                return ret;
        }
@@@ -5573,13 -5633,12 +5625,13 @@@ static void __init wq_numa_init(void
  int __init workqueue_init_early(void)
  {
        int std_nice[NR_STD_WORKER_POOLS] = { 0, HIGHPRI_NICE_LEVEL };
 +      int hk_flags = HK_FLAG_DOMAIN | HK_FLAG_WQ;
        int i, cpu;
  
        WARN_ON(__alignof__(struct pool_workqueue) < __alignof__(long long));
  
        BUG_ON(!alloc_cpumask_var(&wq_unbound_cpumask, GFP_KERNEL));
 -      cpumask_copy(wq_unbound_cpumask, housekeeping_cpumask(HK_FLAG_DOMAIN));
 +      cpumask_copy(wq_unbound_cpumask, housekeeping_cpumask(hk_flags));
  
        pwq_cache = KMEM_CACHE(pool_workqueue, SLAB_PANIC);