Index: sys/dev/sysmon/sysmon

Index: sys/dev/sysmon/sysmon_envsys.c
===================================================================
RCS file: /cvsroot/src/sys/dev/sysmon/sysmon_envsys.c,v
retrieving revision 1.143
diff -p -u -r1.143 sysmon_envsys.c
--- sys/dev/sysmon/sysmon_envsys.c 26 May 2018 21:15:46 -0000 1.143
+++ sys/dev/sysmon/sysmon_envsys.c 26 Nov 2018 23:17:24 -0000
@@ -84,12 +84,17 @@ __KERNEL_RCSID(0, "$NetBSD: sysmon_envsy
#include <dev/sysmon/sysmon_envsysvar.h>
#include <dev/sysmon/sysmon_taskq.h>

-kmutex_t sme_global_mtx;
+static kmutex_t sme_global_mtx;
+static kcondvar_t sme_global_cv;
+static bool sme_global_busy;

prop_dictionary_t sme_propd;

struct sysmon_envsys_lh sysmon_envsys_list;

+static int sysmon_envsys_lock(bool);
+static void sysmon_envsys_unlock(void);
+
static uint32_t sysmon_envsys_next_sensor_index;
static struct sysmon_envsys *sysmon_envsys_find_40(u_int);

@@ -118,6 +123,7 @@ sme_preinit(void)

LIST_INIT(&sysmon_envsys_list);
mutex_init(&sme_global_mtx, MUTEX_DEFAULT, IPL_NONE);
+ cv_init(&sme_global_cv, "smeglobal");
sme_propd = prop_dictionary_create();

return 0;
@@ -150,14 +156,45 @@ sysmon_envsys_fini(void)
else
error = sysmon_attach_minor(SYSMON_MINOR_ENVSYS, NULL);

- if (error == 0)
+ if (error == 0) {
+ cv_destroy(&sme_global_cv);
mutex_destroy(&sme_global_mtx);
+ }

// XXX: prop_dictionary ???

return error;
}

+static int
+sysmon_envsys_lock(bool sig)
+{
+ int error = 0;
+
+ mutex_enter(&sme_global_mtx);
+ while (sme_global_busy && !error) {
+ if (sig)
+ error = cv_wait_sig(&sme_global_cv, &sme_global_mtx);
+ else
+ cv_wait(&sme_global_cv, &sme_global_mtx);
+ }
+ if (!error)
+ sme_global_busy = true;
+ mutex_exit(&sme_global_mtx);
+
+ return error;
+}
+
+static void
+sysmon_envsys_unlock(void)
+{
+
+ mutex_enter(&sme_global_mtx);
+ sme_global_busy = false;
+ cv_signal(&sme_global_cv);
+ mutex_exit(&sme_global_mtx);
+}
+
/*
* sysmonopen_envsys:
*
@@ -204,7 +241,8 @@ sysmonioctl_envsys(dev_t dev, u_long cmd
* Update dictionaries on all sysmon envsys devices
* registered.
*/
- mutex_enter(&sme_global_mtx);
+ if ((error = sysmon_envsys_lock(true)) != 0)
+ break;
LIST_FOREACH(sme, &sysmon_envsys_list, sme_list) {
sysmon_envsys_acquire(sme, false);
error = sme_update_dictionary(sme);
@@ -212,12 +250,12 @@ sysmonioctl_envsys(dev_t dev, u_long cmd
DPRINTF(("%s: sme_update_dictionary, "
"error=%d\n", __func__, error));
sysmon_envsys_release(sme, false);
- mutex_exit(&sme_global_mtx);
+ sysmon_envsys_unlock();
return error;
}
sysmon_envsys_release(sme, false);
}
- mutex_exit(&sme_global_mtx);
+ sysmon_envsys_unlock();
/*
* Copy global dictionary to userland.
*/
@@ -402,9 +440,9 @@ sysmonioctl_envsys(dev_t dev, u_long cmd

if (tred->sensor < sme->sme_nsensors) {
if ((sme->sme_flags & SME_POLL_ONLY) == 0) {
- mutex_enter(&sme->sme_mtx);
+ sysmon_envsys_acquire(sme, false);
sysmon_envsys_refresh_sensor(sme, edata);
- mutex_exit(&sme->sme_mtx);
+ sysmon_envsys_release(sme, false);
}

/*
@@ -531,7 +569,6 @@ sysmon_envsys_create(void)
TAILQ_INIT(&sme->sme_sensors_list);
LIST_INIT(&sme->sme_events_list);
mutex_init(&sme->sme_mtx, MUTEX_DEFAULT, IPL_NONE);
- mutex_init(&sme->sme_work_mtx, MUTEX_DEFAULT, IPL_NONE);
cv_init(&sme->sme_condvar, "sme_wait");

return sme;
@@ -555,7 +592,6 @@ sysmon_envsys_destroy(struct sysmon_envs
TAILQ_REMOVE(&sme->sme_sensors_list, edata, sensors_head);
}
mutex_destroy(&sme->sme_mtx);
- mutex_destroy(&sme->sme_work_mtx);
cv_destroy(&sme->sme_condvar);
kmem_free(sme, sizeof(*sme));
}
@@ -587,12 +623,10 @@ sysmon_envsys_sensor_attach(struct sysmo
if (strlen(edata->desc) == 0)
return EINVAL;

- mutex_enter(&sme->sme_mtx);
- sysmon_envsys_acquire(sme, true);
+ sysmon_envsys_acquire(sme, false);
TAILQ_FOREACH(oedata, &sme->sme_sensors_list, sensors_head) {
if (strcmp(oedata->desc, edata->desc) == 0) {
- sysmon_envsys_release(sme, true);
- mutex_exit(&sme->sme_mtx);
+ sysmon_envsys_release(sme, false);
return EEXIST;
}
}
@@ -606,8 +640,7 @@ sysmon_envsys_sensor_attach(struct sysmo
*/
edata->sensor = sme->sme_nsensors;
sme->sme_nsensors++;
- sysmon_envsys_release(sme, true);
- mutex_exit(&sme->sme_mtx);
+ sysmon_envsys_release(sme, false);

DPRINTF(("%s: attached #%d (%s), units=%d (%s)\n",
__func__, edata->sensor, edata->desc,
@@ -634,8 +667,7 @@ sysmon_envsys_sensor_detach(struct sysmo
/*
* Check the sensor is already on the list.
*/
- mutex_enter(&sme->sme_mtx);
- sysmon_envsys_acquire(sme, true);
+ sysmon_envsys_acquire(sme, false);
TAILQ_FOREACH(oedata, &sme->sme_sensors_list, sensors_head) {
if (oedata->sensor == edata->sensor) {
found = true;
@@ -644,8 +676,7 @@ sysmon_envsys_sensor_detach(struct sysmo
}

if (!found) {
- sysmon_envsys_release(sme, true);
- mutex_exit(&sme->sme_mtx);
+ sysmon_envsys_release(sme, false);
return EINVAL;
}

@@ -662,8 +693,7 @@ sysmon_envsys_sensor_detach(struct sysmo
}
TAILQ_REMOVE(&sme->sme_sensors_list, edata, sensors_head);
sme->sme_nsensors--;
- sysmon_envsys_release(sme, true);
- mutex_exit(&sme->sme_mtx);
+ sysmon_envsys_release(sme, false);

if (destroy)
sme_events_destroy(sme);
@@ -705,14 +735,15 @@ sysmon_envsys_register(struct sysmon_env
* Check if requested sysmon_envsys device is valid
* and does not exist already in the list.
*/
- mutex_enter(&sme_global_mtx);
+ if ((error = sysmon_envsys_lock(true)) != 0)
+ return error;
LIST_FOREACH(lsme, &sysmon_envsys_list, sme_list) {
if (strcmp(lsme->sme_name, sme->sme_name) == 0) {
- mutex_exit(&sme_global_mtx);
+ sysmon_envsys_unlock();
return EEXIST;
}
}
- mutex_exit(&sme_global_mtx);
+ sysmon_envsys_unlock();

/*
* sanity check: if SME_DISABLE_REFRESH is not set,
@@ -797,10 +828,13 @@ sysmon_envsys_register(struct sysmon_env
* <array>
* ...
*/
- mutex_enter(&sme_global_mtx);
+ if ((error = sysmon_envsys_lock(true)) != 0) {
+ DPRINTF(("%s: global dictionary lock aborted\n", __func__));
+ goto out;
+ }
if (!prop_dictionary_set(sme_propd, sme->sme_name, array)) {
error = EINVAL;
- mutex_exit(&sme_global_mtx);
+ sysmon_envsys_unlock();
DPRINTF(("%s: prop_dictionary_set for '%s'\n", __func__,
sme->sme_name));
goto out;
@@ -812,7 +846,7 @@ sysmon_envsys_register(struct sysmon_env
LIST_INSERT_HEAD(&sysmon_envsys_list, sme, sme_list);
sme->sme_fsensor = sysmon_envsys_next_sensor_index;
sysmon_envsys_next_sensor_index += sme->sme_nsensors;
- mutex_exit(&sme_global_mtx);
+ sysmon_envsys_unlock();

out:
/*
@@ -984,14 +1018,14 @@ sysmon_envsys_unregister(struct sysmon_e
* for remaining devices in the list (only used for compatibility
* with previous API), and remove the device from the list.
*/
- mutex_enter(&sme_global_mtx);
+ sysmon_envsys_lock(false);
sysmon_envsys_next_sensor_index -= sme->sme_nsensors;
LIST_FOREACH(osme, &sysmon_envsys_list, sme_list) {
if (osme->sme_fsensor >= sme->sme_fsensor)
osme->sme_fsensor -= sme->sme_nsensors;
}
LIST_REMOVE(sme, sme_list);
- mutex_exit(&sme_global_mtx);
+ sysmon_envsys_unlock();

TAILQ_FOREACH(edata, &sme->sme_sensors_list, sensors_head) {
sysmon_envsys_sensor_detach(sme, edata);
@@ -1007,9 +1041,9 @@ sysmon_envsys_unregister(struct sysmon_e
*/
array = prop_dictionary_get(sme_propd, sme->sme_name);
if (array && prop_object_type(array) == PROP_TYPE_ARRAY) {
- mutex_enter(&sme_global_mtx);
+ sysmon_envsys_lock(false);
prop_dictionary_remove(sme_propd, sme->sme_name);
- mutex_exit(&sme_global_mtx);
+ sysmon_envsys_unlock();
sysmon_envsys_destroy_plist(array);
}
/*
@@ -1029,14 +1063,14 @@ sysmon_envsys_find(const char *name)
{
struct sysmon_envsys *sme;

- mutex_enter(&sme_global_mtx);
+ sysmon_envsys_lock(false);
LIST_FOREACH(sme, &sysmon_envsys_list, sme_list) {
if (strcmp(sme->sme_name, name) == 0) {
sysmon_envsys_acquire(sme, false);
break;
}
}
- mutex_exit(&sme_global_mtx);
+ sysmon_envsys_unlock();

return sme;
}
@@ -1049,7 +1083,7 @@ sysmon_envsys_find_40(u_int idx)
{
struct sysmon_envsys *sme;

- mutex_enter(&sme_global_mtx);
+ sysmon_envsys_lock(false);
LIST_FOREACH(sme, &sysmon_envsys_list, sme_list) {
if (idx >= sme->sme_fsensor &&
idx < (sme->sme_fsensor + sme->sme_nsensors)) {
@@ -1057,7 +1091,7 @@ sysmon_envsys_find_40(u_int idx)
break;
}
}
- mutex_exit(&sme_global_mtx);
+ sysmon_envsys_unlock();

return sme;
}
@@ -1074,6 +1108,7 @@ sysmon_envsys_acquire(struct sysmon_envs
KASSERT(sme != NULL);

if (locked) {
+ KASSERT(mutex_owned(&sme->sme_mtx));
while (sme->sme_flags & SME_FLAG_BUSY)
cv_wait(&sme->sme_condvar, &sme->sme_mtx);
sme->sme_flags |= SME_FLAG_BUSY;
@@ -1098,6 +1133,7 @@ sysmon_envsys_release(struct sysmon_envs
KASSERT(sme != NULL);

if (locked) {
+ KASSERT(mutex_owned(&sme->sme_mtx));
sme->sme_flags &= ~SME_FLAG_BUSY;
cv_broadcast(&sme->sme_condvar);
} else {
@@ -1121,12 +1157,10 @@ sme_initial_refresh(void *arg)
struct sysmon_envsys *sme = arg;
envsys_data_t *edata;

- mutex_enter(&sme->sme_mtx);
- sysmon_envsys_acquire(sme, true);
+ sysmon_envsys_acquire(sme, false);
TAILQ_FOREACH(edata, &sme->sme_sensors_list, sensors_head)
sysmon_envsys_refresh_sensor(sme, edata);
- sysmon_envsys_release(sme, true);
- mutex_exit(&sme->sme_mtx);
+ sysmon_envsys_release(sme, false);
}

/*
@@ -1178,7 +1212,7 @@ sme_remove_userprops(void)
uint32_t props;
int ptype;

- mutex_enter(&sme_global_mtx);
+ sysmon_envsys_lock(false);
LIST_FOREACH(sme, &sysmon_envsys_list, sme_list) {
sysmon_envsys_acquire(sme, false);
array = prop_dictionary_get(sme_propd, sme->sme_name);
@@ -1336,7 +1370,7 @@ sme_remove_userprops(void)
sysmon_envsys_release(sme, true);
mutex_exit(&sme->sme_mtx);
}
- mutex_exit(&sme_global_mtx);
+ sysmon_envsys_unlock();
}

/*
@@ -1550,7 +1584,7 @@ sysmon_envsys_get_max_value(bool (*predi
uint32_t maxv, v;

maxv = 0;
- mutex_enter(&sme_global_mtx);
+ sysmon_envsys_lock(false);
LIST_FOREACH(sme, &sysmon_envsys_list, sme_list) {
sysmon_envsys_acquire(sme, false);
v = sme_get_max_value(sme, predicate, refresh);
@@ -1558,7 +1592,7 @@ sysmon_envsys_get_max_value(bool (*predi
if (v > maxv)
maxv = v;
}
- mutex_exit(&sme_global_mtx);
+ sysmon_envsys_unlock();
return maxv;
}

@@ -1581,9 +1615,9 @@ sme_get_max_value(struct sysmon_envsys *
/*
* refresh sensor data
*/
- mutex_enter(&sme->sme_mtx);
+ sysmon_envsys_acquire(sme, false);
sysmon_envsys_refresh_sensor(sme, edata);
- mutex_exit(&sme->sme_mtx);
+ sysmon_envsys_release(sme, false);

v = edata->value_cur;
if (v > maxv)
@@ -1655,9 +1689,7 @@ sme_update_dictionary(struct sysmon_envs
/*
* refresh sensor data via sme_envsys_refresh_sensor
*/
- mutex_enter(&sme->sme_mtx);
sysmon_envsys_refresh_sensor(sme, edata);
- mutex_exit(&sme->sme_mtx);

/*
* retrieve sensor's dictionary.
@@ -1923,19 +1955,17 @@ sme_userset_dictionary(struct sysmon_env
/*
* Update the object in dictionary.
*/
- mutex_enter(&sme->sme_mtx);
error = sme_sensor_upstring(dict,
"description",
blah);
if (error) {
- mutex_exit(&sme->sme_mtx);
+ sysmon_envsys_release(sme, false);
goto out;
}

DPRINTF(("%s: sensor%d changed desc to: %s\n",
__func__, edata->sensor, blah));
edata->upropset |= PROP_DESC;
- mutex_exit(&sme->sme_mtx);
}

/*
@@ -1945,10 +1975,8 @@ sme_userset_dictionary(struct sysmon_env
if (obj2 && prop_object_type(obj2) == PROP_TYPE_NUMBER) {
targetfound = true;
if (edata->flags & ENVSYS_FCHANGERFACT) {
- mutex_enter(&sme->sme_mtx);
edata->rfact = prop_number_integer_value(obj2);
edata->upropset |= PROP_RFACT;
- mutex_exit(&sme->sme_mtx);
DPRINTF(("%s: sensor%d changed rfact to %d\n",
__func__, edata->sensor, edata->rfact));
} else {
@@ -2086,22 +2114,23 @@ sysmon_envsys_foreach_sensor(sysmon_envs
struct sysmon_envsys *sme;
envsys_data_t *sensor;

- mutex_enter(&sme_global_mtx);
+ if (sysmon_envsys_lock(true))
+ return;
LIST_FOREACH(sme, &sysmon_envsys_list, sme_list) {

sysmon_envsys_acquire(sme, false);
TAILQ_FOREACH(sensor, &sme->sme_sensors_list, sensors_head) {
if (refresh) {
- mutex_enter(&sme->sme_mtx);
+ sysmon_envsys_acquire(sme, false);
sysmon_envsys_refresh_sensor(sme, sensor);
- mutex_exit(&sme->sme_mtx);
+ sysmon_envsys_release(sme, false);
}
if (!(*func)(sme, sensor, arg))
break;
}
sysmon_envsys_release(sme, false);
}
- mutex_exit(&sme_global_mtx);
+ sysmon_envsys_unlock();
}

/*
Index: sys/dev/sysmon/sysmon_envsys_events.c
===================================================================
RCS file: /cvsroot/src/sys/dev/sysmon/sysmon_envsys_events.c,v
retrieving revision 1.121
diff -p -u -r1.121 sysmon_envsys_events.c
--- sys/dev/sysmon/sysmon_envsys_events.c 11 Sep 2017 06:02:09 -0000 1.121
+++ sys/dev/sysmon/sysmon_envsys_events.c 26 Nov 2018 23:17:24 -0000
@@ -169,7 +169,7 @@ sme_event_register(prop_dictionary_t sdi
* check if the event is already on the list and return
* EEXIST if value provided hasn't been changed.
*/
- mutex_enter(&sme->sme_mtx);
+ sysmon_envsys_acquire(sme, false);
LIST_FOREACH(osee, &sme->sme_events_list, see_list) {
if (strcmp(edata->desc, osee->see_pes.pes_sensname) != 0)
continue;
@@ -221,7 +221,7 @@ sme_event_register(prop_dictionary_t sdi
break;
}
if (crittype == PENVSYS_EVENT_NULL && see != NULL) {
- mutex_exit(&sme->sme_mtx);
+ sysmon_envsys_release(sme, false);
return EEXIST;
}

@@ -328,7 +328,7 @@ out:
if ((error == 0 || error == EEXIST) && osee == NULL)
LIST_INSERT_HEAD(&sme->sme_events_list, see, see_list);

- mutex_exit(&sme->sme_mtx);
+ sysmon_envsys_release(sme, false);

return error;
}
@@ -561,7 +561,6 @@ sme_events_init(struct sysmon_envsys *sm
int error = 0;

KASSERT(sme != NULL);
- KASSERT(mutex_owned(&sme->sme_mtx));

error = workqueue_create(&sme->sme_wq, sme->sme_name,
sme_events_worker, sme, PRI_NONE, IPL_SOFTCLOCK, WQ_MPSAFE);
@@ -571,7 +570,9 @@ sme_events_init(struct sysmon_envsys *sm
callout_init(&sme->sme_callout, CALLOUT_MPSAFE);
callout_setfunc(&sme->sme_callout, sme_events_check, sme);
sme->sme_callout_state = SME_CALLOUT_READY;
+ mutex_enter(&sme->sme_mtx);
sme_schedule_callout(sme);
+ mutex_exit(&sme->sme_mtx);
DPRINTF(("%s: events framework initialized for '%s'\n",
__func__, sme->sme_name));

@@ -736,14 +737,13 @@ sme_events_check(void *arg)

KASSERT(sme != NULL);

- mutex_enter(&sme->sme_work_mtx);
+ mutex_enter(&sme->sme_mtx);
if (sme->sme_busy > 0) {
log(LOG_WARNING, "%s: workqueue busy: updates stopped\n",
sme->sme_name);
- mutex_exit(&sme->sme_work_mtx);
+ mutex_exit(&sme->sme_mtx);
return;
}
- mutex_enter(&sme->sme_mtx);
LIST_FOREACH(see, &sme->sme_events_list, see_list) {
workqueue_enqueue(sme->sme_wq, &see->see_wk, NULL);
see->see_edata->flags |= ENVSYS_FNEED_REFRESH;
@@ -752,7 +752,6 @@ sme_events_check(void *arg)
if (!sysmon_low_power)
sme_schedule_callout(sme);
mutex_exit(&sme->sme_mtx);
- mutex_exit(&sme->sme_work_mtx);
}

/*
@@ -772,7 +771,7 @@ sme_events_worker(struct work *wk, void
KASSERT(sme != NULL);
KASSERT(edata != NULL);

- mutex_enter(&sme->sme_mtx);
+ sysmon_envsys_acquire(sme, false);
see->see_flags |= SEE_EVENT_WORKING;
/*
* sme_events_check marks the sensors to make us refresh them here.
@@ -829,11 +828,10 @@ sme_events_worker(struct work *wk, void

out:
see->see_flags &= ~SEE_EVENT_WORKING;
- cv_broadcast(&sme->sme_condvar);
- mutex_enter(&sme->sme_work_mtx);
+ mutex_enter(&sme->sme_mtx);
KASSERT(sme->sme_busy > 0);
sme->sme_busy--;
- mutex_exit(&sme->sme_work_mtx);
+ sysmon_envsys_release(sme, true);
mutex_exit(&sme->sme_mtx);
}

@@ -850,7 +848,7 @@ sysmon_envsys_sensor_event(struct sysmon
{
sme_event_t *see;

- mutex_enter(&sme->sme_mtx);
+ sysmon_envsys_acquire(sme, false);
LIST_FOREACH(see, &sme->sme_events_list, see_list) {
if (edata != see->see_edata)
continue;
@@ -861,7 +859,7 @@ sysmon_envsys_sensor_event(struct sysmon
break;
}
}
- mutex_exit(&sme->sme_mtx);
+ sysmon_envsys_release(sme, false);
}

/*
Index: sys/dev/sysmon/sysmon_envsysvar.h
===================================================================
RCS file: /cvsroot/src/sys/dev/sysmon/sysmon_envsysvar.h,v
retrieving revision 1.47
diff -p -u -r1.47 sysmon_envsysvar.h
--- sys/dev/sysmon/sysmon_envsysvar.h 23 Nov 2014 10:00:20 -0000 1.47
+++ sys/dev/sysmon/sysmon_envsysvar.h 26 Nov 2018 23:17:24 -0000
@@ -101,10 +101,9 @@ struct sme_descr_entry {
const char *desc;
};

-/*
+/*
* common stuff.
*/
-extern kmutex_t sme_global_mtx; /* for the sme linked list and dict */
extern prop_dictionary_t sme_propd; /* the global sensor dictionary */

/*
Index: sys/dev/sysmon/sysmonvar.h
===================================================================
RCS file: /cvsroot/src/sys/dev/sysmon/sysmonvar.h,v
retrieving revision 1.50
diff -p -u -r1.50 sysmonvar.h
--- sys/dev/sysmon/sysmonvar.h 11 Sep 2017 06:02:09 -0000 1.50
+++ sys/dev/sysmon/sysmonvar.h 26 Nov 2018 23:17:24 -0000
@@ -212,11 +212,8 @@ struct sysmon_envsys {
/*
* Locking/synchronization.
*/
- int sme_busy; /* number of items on workqueue,
- sme_mtx or sme_work_mtx to read,
- both to write */
+ int sme_busy; /* number of items on workqueue */
kmutex_t sme_mtx;
- kmutex_t sme_work_mtx;
kcondvar_t sme_condvar;
};