Skip to content

sysfs nodes

This is the reference for the sysfs entries that ha.ko creates. For each device, the driver creates the telemetry nodes and the debug node bypass_range_check under /sys/class/ha/haN/, and it registers one hwmon device under the PCI device. Module-wide information is in /sys/module/ha/. Telemetry explains when values are refreshed and why unknown appears.


Paths

Path Description
/sys/class/ha/haN/ The nodes of device haN. N is 0–7 and is the same number as the device node /dev/haN
/sys/class/ha/haN/device Link to the PCI device directory of that device
/sys/class/ha/haN/device/hwmon/hwmonM/ The hwmon device of that device (hwmon)
/sys/module/ha/version The loaded driver version
/sys/module/ha/parameters/ The current values of the module parameters

Common rules

  • All telemetry nodes have the permissions 0444. Every user can read them but cannot write to them. Only bypass_range_check differs.
  • The output is one line with the value and a newline. The nodes that output multiple lines are temp_blocks, rails, util, peer_map, peer_route, peer_sram, dmabuf_exports, and help.
  • If the value cannot be trusted, the node outputs a single unknown line. peer_route and peer_sram decide line by line and output unknown in the value position of that line. A node does not re-output an expired value or fill in 0. For the conditions and causes, see Conditions under which unknown appears.
  • A - in a field of last_hang or peer_sram is a value that has never been recorded or does not apply.
  • Counters are unsigned 32-bit decimal numbers. They only increase after the driver probes the device, and they do not return to 0 when the device is reset. When the driver probes the device again, they start counting from 0 again.
  • The numbers and addresses in this document are examples.
  • If the driver fails to register the telemetry nodes, telemetry sysfs unavailable is logged in the kernel log and the telemetry nodes are not created. The device node /dev/haN is not affected.

Summary

The Refresh column has the following meanings.

  • Fixed: Does not change.
  • Cached: Read once after the firmware is ready, and read again after a reset.
  • Periodic refresh: The background monitor refreshes the value every ha_sysmon_poll_ms (default 200 ms). If the last valid sample is older than 5 seconds, the value is unknown.
  • On read: Computed from the driver's host-side state on every read. The device is not accessed.
  • Device: Read directly from the device on every read.
Node Unit Refresh Description
fw_version - Cached Firmware version
hw_version - Fixed PCI Revision ID
serial - Cached Unique chip number
dram_size bytes Fixed Total DRAM capacity
dram_used bytes On read Allocated DRAM
dram_free bytes On read Remaining DRAM
sram_size bytes Fixed Total size of the host-shared SRAM
sram_used bytes On read Allocated host-shared SRAM
sram_free bytes On read Remaining host-shared SRAM
temp °C Periodic refresh Highest chip die temperature
temp_avg °C Periodic refresh Average temperature of the block sensors
temp_blocks °C Periodic refresh Temperature per block sensor
power_mw mW Periodic refresh Sum of rail power
rails mV, mA Periodic refresh Voltage and current per rail
util % Periodic refresh Utilization per IP
inflight count On read Number of unfinished jobs
stream_count count On read Number of streams with remaining jobs
devcmd_timeouts occurrences On read Device command response timeouts
devcmd_fw_errors occurrences On read Firmware error responses
hdma_timeouts occurrences On read DMA transfer timeouts
abi_prefetch_stats occurrences On read Cumulative input copy prefetch counts
last_hang - On read Last firmware error and hang diagnostics
health - On read One-word status verdict
fw_update_progress 4 KiB sectors Device Firmware update progress
peer_map - On read State of the DMA mapping to other cards
peer_route - On read Verdict on the PCIe route to other cards
peer_sram - On read SRAM access address per LPU
tw_window_size Bytes Fixed Size of one translation window
dmabuf_exports - On read Reserved dma-buf export windows
help - Fixed Human-readable summary of the nodes
bypass_range_check 0 or 1 - Debug setting

Identification

fw_version

The firmware version. The format is major.minor.patch.

1
1.0.5
  • Refresh: Cached. While the value has not been read yet, each read checks again whether the firmware is ready.
  • unknown: The firmware is not ready. The version register is 0 or was read as all bits set to 1. The driver has confirmed that the firmware did not return to the ready state after a reset.
  • Because this is a value that the driver has already read, it does not tell you whether the firmware is responding now. After a firmware update, the value changes only after the card boots with the new firmware and the driver reads it again.

hw_version

The PCI Revision ID of the device. The node outputs 0x followed by two hexadecimal digits.

1
0x00
  • Refresh: Fixed.
  • unknown: Never appears.

serial

The chip serial number, output in UUID format. It differs from card to card and does not change, so it is used to identify the card.

1
HA-1a2b3c4d-5e6f-7a8b-9c0d-1e2f00000000
  • The format is HA- followed by 8-4-4-4-12 hexadecimal digits. To fit the 96 bits to the UUID length, the last 8 digits are always padded with 00000000.
  • Refresh: Cached. While fw_version has not been read yet, each read checks again whether the firmware is ready.
  • unknown: The firmware is not ready. The firmware has not exposed the number. No number has been recorded on the chip (the value is all 0).

If serial is unknown, distinguish cards by PCI address

The haN number can change depending on the card configuration or the probe order, so do not use it as a card identifier. Get the PCI address from the device link (Standard kernel entries).


Memory

*_used and *_free are device-wide values that add up the allocations of all processes that use the device.

dram_size

The total capacity of the device DRAM (in bytes).

1
137438953472
  • Refresh: Fixed. Calculated from the driver's memory configuration.

dram_used, dram_free

The allocated amount and the remaining amount of the device DRAM (in bytes).

1
grep -H . /sys/class/ha/ha0/dram_used /sys/class/ha/ha0/dram_free
1
2
/sys/class/ha/ha0/dram_used:4294967296
/sys/class/ha/ha0/dram_free:133143986176
  • Refresh: On read.
  • dram_used plus dram_free equals dram_size.
  • dram_free is the total of the remaining amount, not the largest contiguous region that can be allocated at once. If the remaining space is fragmented, even an allocation smaller than dram_free can fail.
  • When the device is reset, all allocations are reclaimed and dram_used becomes 0.

sram_size

The total size (in bytes) of the system SRAM region shared with the host. It is not the per-core compute SRAM.

1
4194304
  • Refresh: Fixed.

sram_used, sram_free

The allocated amount and the remaining amount of the host-shared SRAM (in bytes).

  • Refresh: On read.
  • The sum of sram_used and sram_free is smaller than sram_size. The front part of the region is reserved for the firmware and the driver to use as command queues and so on, and cannot be allocated.
  • sram_free is also the total of the remaining amount, and when the device is reset, sram_used becomes 0.

Temperature, power, and utilization

All nodes in this section are monitoring nodes. The common unknown condition is that there is no first sample yet or the last valid sample is older than 5 seconds (during a reset, FATAL, monitoring stopped, the firmware has not opened the monitoring channel, and so on). Each node lists only the conditions other than this one.

temp

The highest chip die temperature (°C, integer). It is the highest value among the 13 block sensors.

1
47

temp_avg

The average temperature of the 13 block sensors (°C, integer).

1
45

temp_blocks

The node outputs one line <block> <temperature> per block sensor and appends the highest value (peak) and the average (avg) at the end. The temperature is an integer in °C and the line order is fixed. Use it to find which block temp comes from. cg0–cg7 are core groups 0–7, and the rest are sensors of the chip block that the name indicates.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
ca53 44
cg0 47
cg1 46
cg2 46
cg3 47
cg4 45
cg5 46
cg6 45
cg7 45
lpddr5x 43
pcie 44
pvt 44
vdpuctrl 43
peak 47
avg 45

Temperatures are approximate

The temperature sensors may use default calibration values, so the absolute values are not accurate. Use them to watch trends or to compare devices with each other, and do not compare them directly with the limits in the datasheet. If the temperature is high, check the differences between blocks with temp_blocks and check the cooling first. For the conditions under which the firmware lowers the core clock when a compute-group temperature is high, see Firmware clock control.

power_mw

The power (mW, integer) obtained by multiplying the voltage and current that the firmware measured on each power rail of the board and adding up the products.

1
82600
  • It is not the board input power. Regulator losses and rails that are not measured are not included, and the board input power is not measured. If this sum exceeds 350000 mW (350 W), the firmware may halve the core clock. See Firmware clock control.
  • unknown: No rail is measured.

rails

The node outputs one line <name> <voltage> mV <current> mA per measured rail.

1
2
3
4
top_core 850 mV 12000 mA
ddr_core 1100 mV 3000 mA
lpu_core 750 mV 90000 mA
vdpu_core 800 mV 2000 mA
Name rail
top_core Chip top-level domain
ddr_core DRAM
lpu_core LPU compute core
vdpu_core VDPU domain
  • A rail that is not measured has no line. If no rail is measured, the node outputs none.
  • If V_ERR is appended to the end of a line, the voltage of that rail could not be read; if I_ERR is appended, the current could not be read. Do not use the corresponding number.
  • If a measured value exists in the fifth or a later position, the name appears as rail.

util

The node outputs the utilization of each IP block, one per line, as <IP> <percentage>%. The percentage is 0.0–100.0 with one decimal place.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
core 11.5%
mpu 9.8%
vpu 2.1%
spu 0.0%
cdma 3.4%
axibrg 1.2%
rsh 0.0%
smp 0.0%
cgbrg 0.7%
cgdma 4.0%
  • The line order is fixed as shown above.
  • The value aggregates each IP as a whole across the device. For core through cgbrg, the value is the ratio of samples during the measurement interval in which that IP was active, and cgdma is the occupancy of the core group DMA, which is calculated differently.
  • The firmware samples the first core of each core group. For a job that does not use that core, the utilization of the corresponding core group appears low, so 0% does not necessarily mean idle.
  • unknown: The firmware has not yet finished the first measurement interval. The firmware's measurement has not progressed for more than 5 seconds. A value above 100% was received for at least one IP.

Jobs and errors

inflight

The number of jobs that the driver has accepted but that have not finished yet, counted per stream. It includes both running streams and streams that are waiting for their turn or for an event. If an input copy prefetch (abi_prefetch_stats) is in progress, it is also counted as one.

1
2
  • Refresh: On read.
  • If 0, no jobs accepted through streams remain.

stream_count

The number of streams that still have jobs remaining. Streams that have not yet received their turn to run because they are waiting for jobs of other streams to finish are not counted.

1
1
  • Refresh: On read.
  • It is counted by a different criterion than inflight, so the two values can differ.

devcmd_timeouts

The number of times the device did not respond to a command within the response wait ceiling. The ceiling is normally ha_devcmd_ceiling_ms (default 12000 ms), and commands that take a long time are given correspondingly more time. For a command whose time limit the application sets directly, that limit is the ceiling. A firmware update that does not respond within its deadline is also counted.

1
0
  • Refresh: On read.
  • When it increases, the progress information and the verdict in last_hang are updated and hang diagnostics are logged in the kernel log.

devcmd_fw_errors

The number of times the firmware responded to a command with an error. It includes execution timeouts that the firmware determined by itself, and it also counts error responses to invalid requests sent by the application.

1
0
  • Refresh: On read.
  • Each time it increases, rc, cmd_idx, and opcode in last_hang change to the values of that error, and Firmware error: resq[...] is logged in the kernel log (the log output is rate-limited).

hdma_timeouts

The number of times a single data transfer performed by the device's DMA engine (between the host and a device, or between devices) did not finish within 5 seconds.

1
0
  • Refresh: On read.

last_hang

The node outputs, in a single line, the last firmware error and the progress state of the device when a hang was last observed. It is not a metric to collect periodically but diagnostic information to read when you investigate the cause after a counter has increased.

1
rc=- cmd_idx=- opcode=- batch_seq=41->42 exec_index=0 resq_tail=0 verdict=stuck-in-command
Field Meaning
rc Result code of the last firmware error (hexadecimal)
cmd_idx Position of the command that caused the error within the command batch (decimal, counted from 0)
opcode Firmware command code of that command (hexadecimal)
batch_seq Sequence number of the firmware command batch. <before sending the command>-><at observation>
exec_index Number of the command the firmware was executing at the time of observation (from 0). none if no command was executing
resq_tail Response position that the firmware had written up to the time of observation
verdict Verdict made from the progress information (table below)
  • rc, cmd_idx, and opcode are recorded when devcmd_fw_errors increases. If there has been no firmware error yet, they are -.
  • batch_seq, exec_index, resq_tail, and verdict are recorded when a hang is observed. This happens when a command does not respond within the ceiling time (devcmd_timeouts increases), when a wait that the application requested to be without a ceiling exceeds the ceiling time and issues a warning (the warning repeats every 10 seconds and the fields are recorded again each time), and when a firmware update exceeds its deadline. If verdict is none or unsupported, batch_seq, exec_index, and resq_tail are -.
  • The first three fields and the last four fields can be records of different events.
  • It is not cleared by a device reset, and it returns to the initial state when the driver probes the device again.
verdict Meaning
none No hang has been observed yet
unsupported The firmware does not expose the progress information needed for the verdict, or a verdict cannot be made from the values that were read
rebooted The device rebooted while waiting
not-picked-up The firmware did not pick up the command batch
picked-up-no-dispatch The firmware picked up the command batch but did not start any command
stuck-in-command The firmware started a command but did not finish it
completed-irq-lost All commands finished and only the completion notification (interrupt) did not reach the host. The device itself did not stop

verdict is for diagnostics. The driver handles a response timeout the same way regardless of the verdict. Other output examples are as follows.

1
2
rc=- cmd_idx=- opcode=- batch_seq=- exec_index=- resq_tail=- verdict=none
rc=0x5 cmd_idx=3 opcode=0x2 batch_seq=- exec_index=- resq_tail=- verdict=none

For how to interpret it and collect diagnostics, see Hang detection and the watchdog.

health

The one-word status verdict that the driver makes. The node outputs one of ok, degraded, faulted, and unknown.

1
ok
Value Condition
faulted The device is in the FATAL state, or the last reset (an SDK reset or the automatic reset) failed
degraded At least one of devcmd_timeouts, devcmd_fw_errors, and hdma_timeouts is not 0
ok None of the above conditions applies
unknown The driver cannot read the state. It does not appear after the device probe finishes
  • Refresh: On read. The verdict is made in order from the top of the table.
  • Whether the firmware is ready, the temperature, the power, and the monitoring state are not included in the verdict.
  • For when each value is cleared and how to interpret it, see health verdict.

abi_prefetch_stats

The driver starts the host→device copy at the very beginning of the next job in the same stream ahead of time, while the preceding kernel is running on the device, so that the two overlap. This node counts how many times that optimization was applied and the reasons it was not applied. This feature is turned on and off with the module parameter ha_abi_prefetch (on by default).

1
issued=1200 consumed=1195 declined=0 refused_block=0 refused_range=3 refused_scan=0 refused_pend=0 refused_owner=0 refused_dup=0 refused_busy=5
Field Meaning
issued Number of times a copy was started ahead of time
consumed Number of times the job in the original order took over a copy that was started ahead of time
declined Number of times a prefetched copy was canceled because the copy source was found to have changed just before the copy started
refused_block Number of times prefetch was not applied because the commands still remaining in the running job include a command whose access range cannot be known
refused_range Number of times prefetch was not applied because a command still remaining in the running job overlaps the copy target region
refused_scan Number of times prefetch was not applied because too many commands remained in the running job to check
refused_pend Number of times prefetch was not applied because it overlapped a command whose completion had not been confirmed, or exceeded the tracking limit
refused_owner Number of times prefetch was not applied because the device command queue still held commands of another job or commands whose completion had not been confirmed
refused_dup Number of times prefetch was not applied because there were two job entries for the same stream
refused_busy Number of times prefetch was decided on but the copy could not be started at that moment (the copy resource was in use, another copy was waiting, the stream ended, a reset, FATAL, and so on)
  • Refresh: On read. Each value is a counter.
  • In a single attempt, only the first reason that applies is counted. Because counting is per attempt, the same job can be counted multiple times.
  • Because the fields are read one at a time, a line is not a snapshot of a single moment.
  • If issued does not increase relative to the amount of work, this optimization is not being applied, and which refused_* counter increases is the reason. Include this line when you report a performance problem.
  • If you turn ha_abi_prefetch off, the values stop increasing once the prefetches that were in progress finish. See Parameter reference.

Firmware update

fw_update_progress

The node outputs the firmware update progress as <finished sectors> <total sectors>. A sector is 4 KiB.

1
289 672
  • When the firmware boots, the value starts at 0 0. During an update, the firmware updates the value each time it finishes one sector, and a sector that was skipped because its contents are the same is also counted as finished. Therefore the progress of a nearly identical image reaches the maximum quickly.
  • Refresh: Device. Every read goes directly to the device, so do not include it in continuous collection. Do not read it on an unresponsive device (a device where health is faulted or the telemetry monitor has stopped).
  • unknown: The firmware is not ready. The firmware does not support progress reporting. The value could not be read from the device.
  • While ha-fw-update is updating, it displays the progress using this value. See Firmware update.

Multiple devices

What the nodes in this section mean in each configuration is explained in Multiple devices.

peer_map

For each other card registered with the driver, the node outputs one line that tells whether the address mapping required for device-to-device DRAM transfers from this card to that card is ready. If there is no other card, the node outputs none.

1
2
peer1 mapped
peer2 unmapped
  • The M in peer<M> is the haM number of the other card.
  • mapped means that a mapping exists. If unmapped, device-to-device DRAM transfers from this card to that card cannot be used.
  • The mapping is directional. The value on haN shows only the direction from haN to the other card, so check both cards.
  • A mapping does not mean that the PCIe route works. Check it together with peer_route.
  • Refresh: On read. The mapping is determined when the driver probes the device.

peer_route

The node outputs the verdict on the PCIe route between this card and each other card, one line per other card. If there is no other card, the node outputs none.

1
2
peer1 direct
peer2 host-mem
Value Meaning
direct Both cards are under the same PCIe switch, and the bridges on the path do not redirect traffic between the cards upstream
host-mem Traffic between the cards goes through the root complex. The two cards are under different root ports (including different sockets) or different PCI domains, or a bridge on the path redirects traffic upstream because of its ACS settings
unknown The bridge settings on the path could not be read, or the verdict has not been made yet. A bridge that could not be read is logged in the kernel log as ACS state unreadable
  • It is for observation. The mapping is not blocked because of this verdict.
  • Refresh: On read. The verdict is made once when the driver probes the device, so even if you change the PCIe settings afterward, it does not change until the driver probes the device again.

peer_sram

For each installed LPU, the node outputs one line with the address that the device kernel running on this card uses to access the SRAM of that LPU. It includes this card itself, and the lines are in PCI address order.

1
2
3
ha3 0000:ae:00.0 base=0xf800000000 (bar0=0x1f8040000000 route=remap:14)
ha2 0000:d8:00.0 base=- (bar0=0x1fc040000000 route=self)
- 0001:d8:00.0 base=- (bar0=0x21c040000000 route=none:not-bound)
Field Meaning
First field The haN name of that LPU. - if the LPU is not registered with this driver
PCI address domain:bus:device.function
base The base address that the kernel on this card uses to access the SRAM of that LPU. - if there is no address to use, unknown if it cannot be trusted now
bar0 The BAR0 PCIe address of that LPU (for reference). - if there is no usable BAR0
route How this card reaches that LPU (table below)

The only value that is used is base; the values in parentheses are for reference.

route Meaning
self This card itself. base is -
bus The BAR0 of that LPU is reached through the address window that the firmware sets up by default
iova The BAR0 of that LPU is reached through the address that the IOMMU assigned to it
remap:<k> The driver pointed address window number k of this card at the BAR0 of that LPU
none:<reason> The driver does not give the kernel on this card an address for that LPU. base is -
unknown This card or that LPU is being reset, is not ready, is FATAL, or is not responding so the telemetry monitor has stopped, and the address cannot be trusted now
none reason Meaning
other-driver That LPU is bound to another driver
not-bound No driver is bound to that LPU
unsupported The BAR0 of that LPU is not assigned or has a different size, or cannot be used in the address translation configuration of this card
peer-bar0-busy The BAR0 of that LPU is configured to point to something else
region-busy The required address window holds a value that the driver did not write. The driver does not overwrite that value
no-free-region No usable address window remains on this card
map-failed The IOMMU mapping failed
iova-above-240g The address that the IOMMU assigned is outside the range this card can reach (240 GiB)
  • Refresh: On read. The node re-verifies the route that the driver last calculated against the host-side state and outputs it.
  • If the whole output is a single unknown line, the route information of this card is not ready.
  • For how to calculate per-core SRAM addresses from base and for the trust boundary, see Multiple devices.

dma-buf export

For another PCIe device such as an RDMA NIC (the other device below) to read and write the card's DRAM directly, the application asks the driver for a dma-buf export. The driver reserves one of the card's translation windows for each chosen DRAM channel and lets the other device use it, so one export can use several windows. The reservation is released when the application closes the dma-buf it received and the other device lets go of it too (for RDMA, when the memory registration is released). The nodes in this section show the size of those windows and the windows currently reserved.

tw_window_size

Outputs the size of one translation window in bytes. This is the largest size one export can cover in each channel.

1
67108864
  • The value above is an example; the value depends on the card's hardware.
  • It is unknown only if the driver could not set up its translation windows.
  • Refresh: Fixed.

dmabuf_exports

Outputs the export windows currently reserved and the processes that requested the exports. The first line is a summary, followed by one line starting with region for each reserved window. If no window is reserved, only the first line appears.

1
2
3
4
used 3 max 8 pins 5 max 12
region 9 ch0 da 0xc000000040000000 size 0x4000000 live pid 4120 comm rdma_app
region 10 ch2 da 0xc000002040000000 size 0x4000000 live pid 4120 comm rdma_app
region 11 ch4 da 0xc000004040000000 size 0x4000000 disabled pid 4120 comm rdma_app
Field Meaning
used, first max Number of reserved export windows, and the card's limit
pins, second max Number of pinned translation windows and their limit. Export windows, device-to-device copies and other uses share this limit, so the windows an export holds are not available to device-to-device copies
region Number of the reserved translation window
ch DRAM channel number
da Start address (device address) of the DRAM range the window covers
size Size of that range (bytes, hexadecimal)
live, disabled State of the window (table below)
pid, comm PID and name of the process that requested the export, as of the export
State Meaning
live The driver has the window turned on. The other device can reach that DRAM range through it
disabled The card was reset or rebooted and the driver turned the window off, but the dma-buf has not been released yet, so the reservation remains
  • If the dma-buf is not released after the process ends, the line remains. The PID may then already belong to another process.
  • When read from a PID namespace other than the host's (such as a container), pid and comm are -.
  • The node outputs a single unknown line only if the driver could not set up its translation windows.
  • It is not reflected in the health verdict. An export that remains is not a fault.
  • Every user can read it. On a machine that several users share, the export addresses and sizes of other users are visible, and read on the host, the process names are visible too.
  • Refresh: On read.

Other

help

The node outputs a summary description of the telemetry nodes as human-readable text. It is an exception to the sysfs convention of one value per node, and is meant to be read with cat in a terminal.

1
cat /sys/class/ha/ha0/help
  • Refresh: Fixed. The contents can differ between driver versions, so do not parse it in a program.

bypass_range_check

A debug setting that turns off the range check of device memory access requests. It is not telemetry.

1
0
Item Description
Value 0 (checks) or 1 (does not check)
Initial value 0 when the driver probes the device
Permissions when created by the kernel 0644 (only root can write)
Actual permissions after installation 0666 (all users can write). The udev rule 99-ha.rules, which is installed with the driver, runs chmod a+rw on this file when a device is added or changed (add and change events)
Reset The value is kept when the device is reset

If 1, the driver does not check whether the address is within an allocated region when it inspects a device memory access request. A request that accesses an unallocated region is also not rejected.

Do not set it to 1 in a production environment

In the default installation, every user can change this value. On a machine used by multiple users, check regularly that the value is 0, and if it is 1, set it back with echo 0 > /sys/class/ha/haN/bypass_range_check. For the udev rule and how to make the file writable only by root, see Installation.


Standard kernel entries

The kernel also creates the following entries in every device directory. They are not values defined by the driver.

Item Description
dev The major:minor of the device node /dev/haN
device Link to the PCI device directory
subsystem Link to /sys/class/ha
uevent Device information that udev receives
power/ Power management entries (present depending on the kernel configuration)

Use the device link to get the PCI address of haN.

1
basename "$(readlink -f /sys/class/ha/ha0/device)"
1
0000:1a:00.0

The PCI device directory contains the standard PCI entries of the kernel (vendor, device, numa_node, current_link_speed, current_link_width, and so on) and the hwmon device.


hwmon

The driver registers one hwmon device for each device. It is created only when the kernel supports hwmon (CONFIG_HWMON); on a kernel that does not support it, it is not created, and nothing is logged.

Item Description
Location /sys/class/ha/haN/device/hwmon/hwmonM/ (the same device as /sys/class/hwmon/hwmonM)
name ha
Permissions All sensor and label files are 0444
Source of values The same cache as the monitoring nodes
When the value cannot be trusted Read error ENODATA (No data available). The conditions are the same as the unknown conditions of the monitoring nodes
File Label Value Unit Corresponding node
temp1_input peak Highest temperature m°C temp
temp2_input avg Average temperature m°C temp_avg
temp3_input ca53 Block temperature m°C temp_blocks
temp4_input–temp11_input cg0–cg7 Block temperature m°C temp_blocks
temp12_input lpddr5x Block temperature m°C temp_blocks
temp13_input pcie Block temperature m°C temp_blocks
temp14_input pvt Block temperature m°C temp_blocks
temp15_input vdpuctrl Block temperature m°C temp_blocks
in0_input–in3_input top_core, ddr_core, lpu_core, vdpu_core rail voltage mV rails
curr1_input–curr4_input top_core, ddr_core, lpu_core, vdpu_core rail current mA rails
power1_input total Sum of rail power µW power_mw
  • Labels are in the _label file with the same number (for example, temp1_label).
  • Voltage channel numbers start at 0 and the other channel numbers start at 1 (hwmon convention).
  • A voltage or current channel returns a read error if that rail is not measured. power1_input returns a read error if no rail is measured.
  • The V_ERR and I_ERR markers of rails do not carry over to the voltage and current channels. If a value looks suspicious, check in rails whether a marker is attached to that rail.
  • The fifth and later positions that appear in rails under the name rail have no channel in hwmon.
  • If the hwmon device cannot be registered on a kernel that supports it, hwmon register failed is logged in the kernel log. The sysfs nodes are not affected.

Module information

/sys/module/ha/version

The version of the loaded ha.ko.

1
cat /sys/module/ha/version
1
2.6.0

/sys/module/ha/parameters/

There is one file per module parameter, and every user can read the current value. For a parameter that can be changed at run time, root changes it by writing a value to this file. For the meaning and default value of the operational parameters, see Parameter reference; for how to change them, see Configuring and using parameters.


See also