1 /* 2 * Copyright (c) 2019 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include "qdf_periodic_work.h" 20 #include "qdf_status.h" 21 #include "qdf_trace.h" 22 #include "qdf_types.h" 23 24 #ifdef WLAN_PERIODIC_WORK_DEBUG 25 #include "qdf_tracker.h" 26 27 #define qdf_pwork_tracker_bits 2 /* 4 buckets */ 28 static qdf_tracker_declare(qdf_pwork_tracker, qdf_pwork_tracker_bits, 29 "periodic work leaks", "periodic work create", 30 "periodic work destroy"); 31 32 void qdf_periodic_work_feature_init(void) 33 { 34 qdf_tracker_init(&qdf_pwork_tracker); 35 } 36 37 void qdf_periodic_work_feature_deinit(void) 38 { 39 qdf_tracker_deinit(&qdf_pwork_tracker); 40 } 41 42 void qdf_periodic_work_check_for_leaks(void) 43 { 44 qdf_tracker_check_for_leaks(&qdf_pwork_tracker); 45 } 46 47 static inline QDF_STATUS qdf_pwork_dbg_track(struct qdf_periodic_work *pwork, 48 const char *func, uint32_t line) 49 { 50 return qdf_tracker_track(&qdf_pwork_tracker, pwork, func, line); 51 } 52 53 static inline void qdf_pwork_dbg_untrack(struct qdf_periodic_work *pwork, 54 const char *func, uint32_t line) 55 { 56 qdf_tracker_untrack(&qdf_pwork_tracker, pwork, func, line); 57 } 58 #else 59 static inline QDF_STATUS qdf_pwork_dbg_track(struct qdf_periodic_work *pwork, 60 const char *func, uint32_t line) 61 { 62 return QDF_STATUS_SUCCESS; 63 } 64 65 static inline void qdf_pwork_dbg_untrack(struct qdf_periodic_work *pwork, 66 const char *func, uint32_t line) 67 { } 68 #endif /* WLAN_PERIODIC_WORK_DEBUG */ 69 70 static void __qdf_periodic_work_handler(struct work_struct *work) 71 { 72 struct qdf_periodic_work *pwork = 73 container_of(work, struct qdf_periodic_work, dwork.work); 74 uint32_t msec; 75 76 pwork->callback(pwork->context); 77 78 /* this is intentionally racy; see qdf_periodic_work_stop_sync() */ 79 msec = pwork->msec; 80 if (msec) 81 schedule_delayed_work(&pwork->dwork, msecs_to_jiffies(msec)); 82 } 83 84 QDF_STATUS __qdf_periodic_work_create(struct qdf_periodic_work *pwork, 85 qdf_periodic_work_cb callback, 86 void *context, 87 const char *func, uint32_t line) 88 { 89 QDF_STATUS status; 90 91 QDF_BUG(pwork); 92 QDF_BUG(callback); 93 if (!pwork || !callback) 94 return QDF_STATUS_E_INVAL; 95 96 status = qdf_pwork_dbg_track(pwork, func, line); 97 if (QDF_IS_STATUS_ERROR(status)) 98 return status; 99 100 INIT_DELAYED_WORK(&pwork->dwork, __qdf_periodic_work_handler); 101 pwork->callback = callback; 102 pwork->context = context; 103 pwork->msec = 0; 104 105 return QDF_STATUS_SUCCESS; 106 } 107 108 void __qdf_periodic_work_destroy(struct qdf_periodic_work *pwork, 109 const char *func, uint32_t line) 110 { 111 qdf_periodic_work_stop_sync(pwork); 112 qdf_pwork_dbg_untrack(pwork, func, line); 113 } 114 115 bool qdf_periodic_work_start(struct qdf_periodic_work *pwork, uint32_t msec) 116 { 117 QDF_BUG(msec); 118 if (!msec) 119 return false; 120 121 pwork->msec = msec; 122 123 return schedule_delayed_work(&pwork->dwork, msecs_to_jiffies(msec)); 124 } 125 126 bool qdf_periodic_work_stop_async(struct qdf_periodic_work *pwork) 127 { 128 bool pending = pwork->msec != 0; 129 130 pwork->msec = 0; 131 cancel_delayed_work(&pwork->dwork); 132 133 return pending; 134 } 135 136 bool qdf_periodic_work_stop_sync(struct qdf_periodic_work *pwork) 137 { 138 bool pending = pwork->msec != 0; 139 140 /* To avoid using a lock, signal that the work shouldn't be restarted, 141 * and cancel_sync in a loop. There is a very small race window, and 142 * thus the work may ocassionally need to be cancelled more than once. 143 */ 144 pwork->msec = 0; 145 while (cancel_delayed_work_sync(&pwork->dwork)) 146 ; /* no-op*/ 147 148 return pending; 149 } 150 151