kernel/drivers/staging/unisys/visorbus/periodic_work.c

   1 /* periodic_work.c
   2  *
   3  * Copyright (C) 2010 - 2015 UNISYS CORPORATION
   4  * All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  13  * NON INFRINGEMENT.  See the GNU General Public License for more
  14  * details.
  15  */
  16
  17 /*
  18  *  Helper functions to schedule periodic work in Linux kernel mode.
  19  */
  20 #include <linux/sched.h>
  21
  22 #include "periodic_work.h"
  23
  24 #define MYDRVNAME "periodic_work"
  25
  26 struct periodic_work {
  27         rwlock_t lock;
  28         struct delayed_work work;
  29         void (*workfunc)(void *);
  30         void *workfuncarg;
  31         bool is_scheduled;
  32         bool want_to_stop;
  33         ulong jiffy_interval;
  34         struct workqueue_struct *workqueue;
  35         const char *devnam;
  36 };
  37
  38 static void periodic_work_func(struct work_struct *work)
  39 {
  40         struct periodic_work *pw;
  41
  42         pw = container_of(work, struct periodic_work, work.work);
  43         (*pw->workfunc)(pw->workfuncarg);
  44 }
  45
  46 struct periodic_work *visor_periodic_work_create(ulong jiffy_interval,
  47                                         struct workqueue_struct *workqueue,
  48                                         void (*workfunc)(void *),
  49                                         void *workfuncarg,
  50                                         const char *devnam)
  51 {
  52         struct periodic_work *pw;
  53
  54         pw = kzalloc(sizeof(*pw), GFP_KERNEL | __GFP_NORETRY);
  55         if (!pw)
  56                 return NULL;
  57
  58         rwlock_init(&pw->lock);
  59         pw->jiffy_interval = jiffy_interval;
  60         pw->workqueue = workqueue;
  61         pw->workfunc = workfunc;
  62         pw->workfuncarg = workfuncarg;
  63         pw->devnam = devnam;
  64         return pw;
  65 }
  66 EXPORT_SYMBOL_GPL(visor_periodic_work_create);
  67
  68 void visor_periodic_work_destroy(struct periodic_work *pw)
  69 {
  70         kfree(pw);
  71 }
  72 EXPORT_SYMBOL_GPL(visor_periodic_work_destroy);
  73
  74 /** Call this from your periodic work worker function to schedule the next
  75  *  call.
  76  *  If this function returns false, there was a failure and the
  77  *  periodic work is no longer scheduled
  78  */
  79 bool visor_periodic_work_nextperiod(struct periodic_work *pw)
  80 {
  81         bool rc = false;
  82
  83         write_lock(&pw->lock);
  84         if (pw->want_to_stop) {
  85                 pw->is_scheduled = false;
  86                 pw->want_to_stop = false;
  87                 rc = true;  /* yes, true; see visor_periodic_work_stop() */
  88                 goto unlock;
  89         } else if (!queue_delayed_work(pw->workqueue, &pw->work,
  90                                        pw->jiffy_interval)) {
  91                 pw->is_scheduled = false;
  92                 rc = false;
  93                 goto unlock;
  94         }
  95         rc = true;
  96 unlock:
  97         write_unlock(&pw->lock);
  98         return rc;
  99 }
 100 EXPORT_SYMBOL_GPL(visor_periodic_work_nextperiod);
 101
 102 /** This function returns true iff new periodic work was actually started.
 103  *  If this function returns false, then no work was started
 104  *  (either because it was already started, or because of a failure).
 105  */
 106 bool visor_periodic_work_start(struct periodic_work *pw)
 107 {
 108         bool rc = false;
 109
 110         write_lock(&pw->lock);
 111         if (pw->is_scheduled) {
 112                 rc = false;
 113                 goto unlock;
 114         }
 115         if (pw->want_to_stop) {
 116                 rc = false;
 117                 goto unlock;
 118         }
 119         INIT_DELAYED_WORK(&pw->work, &periodic_work_func);
 120         if (!queue_delayed_work(pw->workqueue, &pw->work,
 121                                 pw->jiffy_interval)) {
 122                 rc = false;
 123                 goto unlock;
 124         }
 125         pw->is_scheduled = true;
 126         rc = true;
 127 unlock:
 128         write_unlock(&pw->lock);
 129         return rc;
 130 }
 131 EXPORT_SYMBOL_GPL(visor_periodic_work_start);
 132
 133 /** This function returns true iff your call actually stopped the periodic
 134  *  work.
 135  *
 136  *  -- PAY ATTENTION... this is important --
 137  *
 138  *  NO NO #1
 139  *
 140  *     Do NOT call this function from some function that is running on the
 141  *     same workqueue as the work you are trying to stop might be running
 142  *     on!  If you violate this rule, visor_periodic_work_stop() MIGHT work,
 143  *     but it also MIGHT get hung up in an infinite loop saying
 144  *     "waiting for delayed work...".  This will happen if the delayed work
 145  *     you are trying to cancel has been put in the workqueue list, but can't
 146  *     run yet because we are running that same workqueue thread right now.
 147  *
 148  *     Bottom line: If you need to call visor_periodic_work_stop() from a
 149  *     workitem, be sure the workitem is on a DIFFERENT workqueue than the
 150  *     workitem that you are trying to cancel.
 151  *
 152  *     If I could figure out some way to check for this "no no" condition in
 153  *     the code, I would.  It would have saved me the trouble of writing this
 154  *     long comment.  And also, don't think this is some "theoretical" race
 155  *     condition.  It is REAL, as I have spent the day chasing it.
 156  *
 157  *  NO NO #2
 158  *
 159  *     Take close note of the locks that you own when you call this function.
 160  *     You must NOT own any locks that are needed by the periodic work
 161  *     function that is currently installed.  If you DO, a deadlock may result,
 162  *     because stopping the periodic work often involves waiting for the last
 163  *     iteration of the periodic work function to complete.  Again, if you hit
 164  *     this deadlock, you will get hung up in an infinite loop saying
 165  *     "waiting for delayed work...".
 166  */
 167 bool visor_periodic_work_stop(struct periodic_work *pw)
 168 {
 169         bool stopped_something = false;
 170
 171         write_lock(&pw->lock);
 172         stopped_something = pw->is_scheduled && (!pw->want_to_stop);
 173         while (pw->is_scheduled) {
 174                 pw->want_to_stop = true;
 175                 if (cancel_delayed_work(&pw->work)) {
 176                         /* We get here if the delayed work was pending as
 177                          * delayed work, but was NOT run.
 178                          */
 179                         WARN_ON(!pw->is_scheduled);
 180                         pw->is_scheduled = false;
 181                 } else {
 182                         /* If we get here, either the delayed work:
 183                          * - was run, OR,
 184                          * - is running RIGHT NOW on another processor, OR,
 185                          * - wasn't even scheduled (there is a miniscule
 186                          *   timing window where this could be the case)
 187                          * flush_workqueue() would make sure it is finished
 188                          * executing, but that still isn't very useful, which
 189                          * explains the loop...
 190                          */
 191                 }
 192                 if (pw->is_scheduled) {
 193                         write_unlock(&pw->lock);
 194                         schedule_timeout_interruptible(msecs_to_jiffies(10));
 195                         write_lock(&pw->lock);
 196                 } else {
 197                         pw->want_to_stop = false;
 198                 }
 199         }
 200         write_unlock(&pw->lock);
 201         return stopped_something;
 202 }
 203 EXPORT_SYMBOL_GPL(visor_periodic_work_stop);