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. Onlybypass_range_checkdiffers. - 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, andhelp. - If the value cannot be trusted, the node outputs a single
unknownline.peer_routeandpeer_sramdecide line by line and outputunknownin 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 oflast_hangorpeer_sramis 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 unavailableis logged in the kernel log and the telemetry nodes are not created. The device node/dev/haNis 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 isunknown. - 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 | |
- 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 | |
- 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 | |
- 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 with00000000. - Refresh: Cached. While
fw_versionhas 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 | |
- 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 | |
1 2 | |
- Refresh: On read.
dram_usedplusdram_freeequalsdram_size.dram_freeis 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 thandram_freecan fail.- When the device is reset, all allocations are reclaimed and
dram_usedbecomes 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 | |
- 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_usedandsram_freeis smaller thansram_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_freeis also the total of the remaining amount, and when the device is reset,sram_usedbecomes 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 | |
temp_avg¶
The average temperature of the 13 block sensors (°C, integer).
1 | |
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 | |
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 | |
- 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 | |
| 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_ERRis appended to the end of a line, the voltage of that rail could not be read; ifI_ERRis 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 | |
- The line order is fixed as shown above.
- The value aggregates each IP as a whole across the device. For
corethroughcgbrg, the value is the ratio of samples during the measurement interval in which that IP was active, andcgdmais 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 | |
- 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 | |
- 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 | |
- Refresh: On read.
- When it increases, the progress information and the verdict in
last_hangare 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 | |
- Refresh: On read.
- Each time it increases,
rc,cmd_idx, andopcodeinlast_hangchange to the values of that error, andFirmware 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 | |
- 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 | |
| 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, andopcodeare recorded whendevcmd_fw_errorsincreases. If there has been no firmware error yet, they are-.batch_seq,exec_index,resq_tail, andverdictare recorded when a hang is observed. This happens when a command does not respond within the ceiling time (devcmd_timeoutsincreases), 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. Ifverdictisnoneorunsupported,batch_seq,exec_index, andresq_tailare-.- 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 | |
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 | |
| 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 | |
| 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
issueddoes not increase relative to the amount of work, this optimization is not being applied, and whichrefused_*counter increases is the reason. Include this line when you report a performance problem. - If you turn
ha_abi_prefetchoff, 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 | |
- 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
healthisfaultedor 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-updateis 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 | |
- The
Minpeer<M>is thehaMnumber of the other card. mappedmeans that a mapping exists. Ifunmapped, device-to-device DRAM transfers from this card to that card cannot be used.- The mapping is directional. The value on
haNshows only the direction fromhaNto 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 | |
| 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 | |
| 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
unknownline, the route information of this card is not ready. - For how to calculate per-core SRAM addresses from
baseand 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 | |
- The value above is an example; the value depends on the card's hardware.
- It is
unknownonly 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 | |
| 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),
pidandcommare-. - The node outputs a single
unknownline only if the driver could not set up its translation windows. - It is not reflected in the
healthverdict. 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 | |
- 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 | |
| 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 | |
1 | |
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
_labelfile 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_inputreturns a read error if no rail is measured. - The
V_ERRandI_ERRmarkers ofrailsdo not carry over to the voltage and current channels. If a value looks suspicious, check inrailswhether a marker is attached to that rail. - The fifth and later positions that appear in
railsunder the namerailhave no channel in hwmon. - If the hwmon device cannot be registered on a kernel that supports it,
hwmon register failedis 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 | |
1 | |
/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¶
- Telemetry — refresh behavior,
unknown,healthverdict, monitoring integration - Hang detection and the watchdog — diagnosis using
last_hang - FATAL and recovery
- Multiple devices — interpreting
peer_map,peer_route, andpeer_sram - Firmware update —
fw_update_progress - Parameter reference
- hyperaccel-smi
- Kernel log messages