tree 6bc7e0c395725048188bc0563c4128870a906349
parent a0683a889a12bf665595ccdcb349c5f4ab321eea
author Lei YU <yulei.sh@bytedance.com> 1608703648 +0800
committer Ed Tanous <ed@tanous.net> 1615352325 +0000

psusensor: Fix incorrect event sensors

The event sensors are expected to track the sysfs paths that are in
limitEventMatch.
However, the code incorrectly adds paths like `tempx_max` into the event
sensors because it replace `input` with `xxx_alarm` and check if the
path exists or not.
When the path does not include `input`, it is not changed at all and the
path does exist, thus it is added into the event sensors incorrectly.

Fix it by checking the above case and skip such path.

Tested: Verify the sensors like `temp1_max` is not added into the event
        sensors anymore.

Signed-off-by: Lei YU <yulei.sh@bytedance.com>
Change-Id: I219cb8ef966fc00c121359b0b1bcfc2b68cf0216
