TWxSoftware/twx-linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge tag 'hwmon-for-v6.16-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging

Browse Source 
Pull hwmon fixes from Guenter Roeck:

 - ltc4282: Avoid repeated register write operation

 - occ: Fix unaligned accesses, and rework attribute registration to
   reduce stack usage

 - ftsteutates: Fix TOCTOU race

* tag 'hwmon-for-v6.16-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging:
  hwmon: (ltc4282) avoid repeated register write
  hwmon: (occ) fix unaligned accesses
  hwmon: (occ) Rework attribute registration for stack usage
  hwmon: (ftsteutates) Fix TOCTOU race in fts_read()
This commit is contained in:
Linus Torvalds
2025-06-19 09:09:40 -07:00
parent fb4d33ab45 c25892b7a1
commit 24770983cc
3 changed files with 103 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files
drivers/hwmon/ftsteutates.c
+6 -3
View File
@@ -423,13 +423,16 @@ static int fts_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
break;
case hwmon_pwm:
switch (attr) {
case hwmon_pwm_auto_channels_temp:
if (data->fan_source[channel] == FTS_FAN_SOURCE_INVALID)
case hwmon_pwm_auto_channels_temp: {
u8 fan_source = data->fan_source[channel];
if (fan_source == FTS_FAN_SOURCE_INVALID || fan_source >= BITS_PER_LONG)
*val = 0;
else
*val = BIT(data->fan_source[channel]);
*val = BIT(fan_source);
return 0;
}
default:
break;
}
drivers/hwmon/ltc4282.c
-7
View File
@@ -1511,13 +1511,6 @@ static int ltc4282_setup(struct ltc4282_state *st, struct device *dev)
return ret;
}
if (device_property_read_bool(dev, "adi,fault-log-enable")) {
ret = regmap_set_bits(st->map, LTC4282_ADC_CTRL,
LTC4282_FAULT_LOG_EN_MASK);
if (ret)
return ret;
}
if (device_property_read_bool(dev, "adi,fault-log-enable")) {
ret = regmap_set_bits(st->map, LTC4282_ADC_CTRL, LTC4282_FAULT_LOG_EN_MASK);
if (ret)
drivers/hwmon/occ/common.c
+97 -141
View File
@@ -459,12 +459,10 @@ static ssize_t occ_show_power_1(struct device *dev,
return sysfs_emit(buf, "%llu\n", val);
}
static u64 occ_get_powr_avg(u64 *accum, u32 *samples)
static u64 occ_get_powr_avg(u64 accum, u32 samples)
{
u64 divisor = get_unaligned_be32(samples);
return (divisor == 0) ? 0 :
div64_u64(get_unaligned_be64(accum) * 1000000ULL, divisor);
return (samples == 0) ? 0 :
mul_u64_u32_div(accum, 1000000UL, samples);
}
static ssize_t occ_show_power_2(struct device *dev,
@@ -489,8 +487,8 @@ static ssize_t occ_show_power_2(struct device *dev,
get_unaligned_be32(&power->sensor_id),
power->function_id, power->apss_channel);
case 1:
val = occ_get_powr_avg(&power->accumulator,
&power->update_tag);
val = occ_get_powr_avg(get_unaligned_be64(&power->accumulator),
get_unaligned_be32(&power->update_tag));
break;
case 2:
val = (u64)get_unaligned_be32(&power->update_tag) *
@@ -527,8 +525,8 @@ static ssize_t occ_show_power_a0(struct device *dev,
return sysfs_emit(buf, "%u_system\n",
get_unaligned_be32(&power->sensor_id));
case 1:
val = occ_get_powr_avg(&power->system.accumulator,
&power->system.update_tag);
val = occ_get_powr_avg(get_unaligned_be64(&power->system.accumulator),
get_unaligned_be32(&power->system.update_tag));
break;
case 2:
val = (u64)get_unaligned_be32(&power->system.update_tag) *
@@ -541,8 +539,8 @@ static ssize_t occ_show_power_a0(struct device *dev,
return sysfs_emit(buf, "%u_proc\n",
get_unaligned_be32(&power->sensor_id));
case 5:
val = occ_get_powr_avg(&power->proc.accumulator,
&power->proc.update_tag);
val = occ_get_powr_avg(get_unaligned_be64(&power->proc.accumulator),
get_unaligned_be32(&power->proc.update_tag));
break;
case 6:
val = (u64)get_unaligned_be32(&power->proc.update_tag) *
@@ -555,8 +553,8 @@ static ssize_t occ_show_power_a0(struct device *dev,
return sysfs_emit(buf, "%u_vdd\n",
get_unaligned_be32(&power->sensor_id));
case 9:
val = occ_get_powr_avg(&power->vdd.accumulator,
&power->vdd.update_tag);
val = occ_get_powr_avg(get_unaligned_be64(&power->vdd.accumulator),
get_unaligned_be32(&power->vdd.update_tag));
break;
case 10:
val = (u64)get_unaligned_be32(&power->vdd.update_tag) *
@@ -569,8 +567,8 @@ static ssize_t occ_show_power_a0(struct device *dev,
return sysfs_emit(buf, "%u_vdn\n",
get_unaligned_be32(&power->sensor_id));
case 13:
val = occ_get_powr_avg(&power->vdn.accumulator,
&power->vdn.update_tag);
val = occ_get_powr_avg(get_unaligned_be64(&power->vdn.accumulator),
get_unaligned_be32(&power->vdn.update_tag));
break;
case 14:
val = (u64)get_unaligned_be32(&power->vdn.update_tag) *
@@ -747,28 +745,29 @@ static ssize_t occ_show_extended(struct device *dev,
}
/*
* Some helper macros to make it easier to define an occ_attribute. Since these
* are dynamically allocated, we shouldn't use the existing kernel macros which
* A helper to make it easier to define an occ_attribute. Since these
* are dynamically allocated, we cannot use the existing kernel macros which
* stringify the name argument.
*/
#define ATTR_OCC(_name, _mode, _show, _store) { \
.attr = { \
.name = _name, \
.mode = VERIFY_OCTAL_PERMISSIONS(_mode), \
}, \
.show = _show, \
.store = _store, \
}
static void occ_init_attribute(struct occ_attribute *attr, int mode,
ssize_t (*show)(struct device *dev, struct device_attribute *attr, char *buf),
ssize_t (*store)(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count),
int nr, int index, const char *fmt, ...)
{
va_list args;
#define SENSOR_ATTR_OCC(_name, _mode, _show, _store, _nr, _index) { \
.dev_attr = ATTR_OCC(_name, _mode, _show, _store), \
.index = _index, \
.nr = _nr, \
}
va_start(args, fmt);
vsnprintf(attr->name, sizeof(attr->name), fmt, args);
va_end(args);
#define OCC_INIT_ATTR(_name, _mode, _show, _store, _nr, _index) \
((struct sensor_device_attribute_2) \
SENSOR_ATTR_OCC(_name, _mode, _show, _store, _nr, _index))
attr->sensor.dev_attr.attr.name = attr->name;
attr->sensor.dev_attr.attr.mode = mode;
attr->sensor.dev_attr.show = show;
attr->sensor.dev_attr.store = store;
attr->sensor.index = index;
attr->sensor.nr = nr;
}
/*
* Allocate and instatiate sensor_device_attribute_2s. It's most efficient to
@@ -855,14 +854,15 @@ static int occ_setup_sensor_attrs(struct occ *occ)
sensors->extended.num_sensors = 0;
}
occ->attrs = devm_kzalloc(dev, sizeof(*occ->attrs) * num_attrs,
occ->attrs = devm_kcalloc(dev, num_attrs, sizeof(*occ->attrs),
GFP_KERNEL);
if (!occ->attrs)
return -ENOMEM;
/* null-terminated list */
occ->group.attrs = devm_kzalloc(dev, sizeof(*occ->group.attrs) *
num_attrs + 1, GFP_KERNEL);
occ->group.attrs = devm_kcalloc(dev, num_attrs + 1,
sizeof(*occ->group.attrs),
GFP_KERNEL);
if (!occ->group.attrs)
return -ENOMEM;
@@ -872,43 +872,33 @@ static int occ_setup_sensor_attrs(struct occ *occ)
s = i + 1;
temp = ((struct temp_sensor_2 *)sensors->temp.data) + i;
snprintf(attr->name, sizeof(attr->name), "temp%d_label", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_temp, NULL,
0, i);
occ_init_attribute(attr, 0444, show_temp, NULL,
0, i, "temp%d_label", s);
attr++;
if (sensors->temp.version == 2 &&
temp->fru_type == OCC_FRU_TYPE_VRM) {
snprintf(attr->name, sizeof(attr->name),
"temp%d_alarm", s);
occ_init_attribute(attr, 0444, show_temp, NULL,
1, i, "temp%d_alarm", s);
} else {
snprintf(attr->name, sizeof(attr->name),
"temp%d_input", s);
occ_init_attribute(attr, 0444, show_temp, NULL,
1, i, "temp%d_input", s);
}
attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_temp, NULL,
1, i);
attr++;
if (sensors->temp.version > 1) {
snprintf(attr->name, sizeof(attr->name),
"temp%d_fru_type", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
show_temp, NULL, 2, i);
occ_init_attribute(attr, 0444, show_temp, NULL,
2, i, "temp%d_fru_type", s);
attr++;
snprintf(attr->name, sizeof(attr->name),
"temp%d_fault", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
show_temp, NULL, 3, i);
occ_init_attribute(attr, 0444, show_temp, NULL,
3, i, "temp%d_fault", s);
attr++;
if (sensors->temp.version == 0x10) {
snprintf(attr->name, sizeof(attr->name),
"temp%d_max", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
show_temp, NULL,
4, i);
occ_init_attribute(attr, 0444, show_temp, NULL,
4, i, "temp%d_max", s);
attr++;
}
}
@@ -917,14 +907,12 @@ static int occ_setup_sensor_attrs(struct occ *occ)
for (i = 0; i < sensors->freq.num_sensors; ++i) {
s = i + 1;
snprintf(attr->name, sizeof(attr->name), "freq%d_label", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_freq, NULL,
0, i);
occ_init_attribute(attr, 0444, show_freq, NULL,
0, i, "freq%d_label", s);
attr++;
snprintf(attr->name, sizeof(attr->name), "freq%d_input", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_freq, NULL,
1, i);
occ_init_attribute(attr, 0444, show_freq, NULL,
1, i, "freq%d_input", s);
attr++;
}
@@ -940,32 +928,24 @@ static int occ_setup_sensor_attrs(struct occ *occ)
s = (i * 4) + 1;
for (j = 0; j < 4; ++j) {
snprintf(attr->name, sizeof(attr->name),
"power%d_label", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
show_power, NULL,
nr++, i);
occ_init_attribute(attr, 0444, show_power,
NULL, nr++, i,
"power%d_label", s);
attr++;
snprintf(attr->name, sizeof(attr->name),
"power%d_average", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
show_power, NULL,
nr++, i);
occ_init_attribute(attr, 0444, show_power,
NULL, nr++, i,
"power%d_average", s);
attr++;
snprintf(attr->name, sizeof(attr->name),
"power%d_average_interval", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
show_power, NULL,
nr++, i);
occ_init_attribute(attr, 0444, show_power,
NULL, nr++, i,
"power%d_average_interval", s);
attr++;
snprintf(attr->name, sizeof(attr->name),
"power%d_input", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
show_power, NULL,
nr++, i);
occ_init_attribute(attr, 0444, show_power,
NULL, nr++, i,
"power%d_input", s);
attr++;
s++;
@@ -977,28 +957,20 @@ static int occ_setup_sensor_attrs(struct occ *occ)
for (i = 0; i < sensors->power.num_sensors; ++i) {
s = i + 1;
snprintf(attr->name, sizeof(attr->name),
"power%d_label", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
show_power, NULL, 0, i);
occ_init_attribute(attr, 0444, show_power, NULL,
0, i, "power%d_label", s);
attr++;
snprintf(attr->name, sizeof(attr->name),
"power%d_average", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
show_power, NULL, 1, i);
occ_init_attribute(attr, 0444, show_power, NULL,
1, i, "power%d_average", s);
attr++;
snprintf(attr->name, sizeof(attr->name),
"power%d_average_interval", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
show_power, NULL, 2, i);
occ_init_attribute(attr, 0444, show_power, NULL,
2, i, "power%d_average_interval", s);
attr++;
snprintf(attr->name, sizeof(attr->name),
"power%d_input", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
show_power, NULL, 3, i);
occ_init_attribute(attr, 0444, show_power, NULL,
3, i, "power%d_input", s);
attr++;
}
@@ -1006,56 +978,43 @@ static int occ_setup_sensor_attrs(struct occ *occ)
}
if (sensors->caps.num_sensors >= 1) {
snprintf(attr->name, sizeof(attr->name), "power%d_label", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
0, 0);
occ_init_attribute(attr, 0444, show_caps, NULL,
0, 0, "power%d_label", s);
attr++;
snprintf(attr->name, sizeof(attr->name), "power%d_cap", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1, 0);
occ_init_attribute(attr, 0444, show_caps, NULL,
1, 0, "power%d_cap", s);
attr++;
snprintf(attr->name, sizeof(attr->name), "power%d_input", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
2, 0);
occ_init_attribute(attr, 0444, show_caps, NULL,
2, 0, "power%d_input", s);
attr++;
snprintf(attr->name, sizeof(attr->name),
"power%d_cap_not_redundant", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
3, 0);
occ_init_attribute(attr, 0444, show_caps, NULL,
3, 0, "power%d_cap_not_redundant", s);
attr++;
snprintf(attr->name, sizeof(attr->name), "power%d_cap_max", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
4, 0);
occ_init_attribute(attr, 0444, show_caps, NULL,
4, 0, "power%d_cap_max", s);
attr++;
snprintf(attr->name, sizeof(attr->name), "power%d_cap_min", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
5, 0);
occ_init_attribute(attr, 0444, show_caps, NULL,
5, 0, "power%d_cap_min", s);
attr++;
snprintf(attr->name, sizeof(attr->name), "power%d_cap_user",
s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0644, show_caps,
occ_store_caps_user, 6, 0);
occ_init_attribute(attr, 0644, show_caps, occ_store_caps_user,
6, 0, "power%d_cap_user", s);
attr++;
if (sensors->caps.version > 1) {
snprintf(attr->name, sizeof(attr->name),
"power%d_cap_user_source", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
show_caps, NULL, 7, 0);
occ_init_attribute(attr, 0444, show_caps, NULL,
7, 0, "power%d_cap_user_source", s);
attr++;
if (sensors->caps.version > 2) {
snprintf(attr->name, sizeof(attr->name),
"power%d_cap_min_soft", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
show_caps, NULL,
8, 0);
occ_init_attribute(attr, 0444, show_caps, NULL,
8, 0,
"power%d_cap_min_soft", s);
attr++;
}
}
@@ -1064,19 +1023,16 @@ static int occ_setup_sensor_attrs(struct occ *occ)
for (i = 0; i < sensors->extended.num_sensors; ++i) {
s = i + 1;
snprintf(attr->name, sizeof(attr->name), "extn%d_label", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
occ_show_extended, NULL, 0, i);
occ_init_attribute(attr, 0444, occ_show_extended, NULL,
0, i, "extn%d_label", s);
attr++;
snprintf(attr->name, sizeof(attr->name), "extn%d_flags", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
occ_show_extended, NULL, 1, i);
occ_init_attribute(attr, 0444, occ_show_extended, NULL,
1, i, "extn%d_flags", s);
attr++;
snprintf(attr->name, sizeof(attr->name), "extn%d_input", s);
attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
occ_show_extended, NULL, 2, i);
occ_init_attribute(attr, 0444, occ_show_extended, NULL,
2, i, "extn%d_input", s);
attr++;
}