The CWE-190 vulnerability at line 97 is due to an integer overflow that can occur when calculating the index for the `pde_encode_bo` function.

The expression `map_ofs + (level - 1) *` can overflow if the value of `level` is large enough, causing the result to wrap around and become a small value. This can lead to an incorrect index being passed to the `pde_encode_bo` function, potentially causing a buffer overflow or other unexpected behavior.

The root cause of this vulnerability is the lack of bounds checking and integer overflow protection in the calculation of the index. To fix this vulnerability, the code should be modified to check for potential overflows and ensure that the calculated index is within the valid range.

Here are some possible ways to fix this vulnerability:

1. **Check for integer overflow**: Before calculating the index, check if the value of `level` is within a safe range that will not cause an overflow.
2. **Use a larger integer type**: Consider using a larger integer type, such as `u64`, to store the index and perform the calculation. This can help prevent overflows.
3. **Add bounds checking**: After calculating the index, check if it is within the valid range of the buffer or array being accessed.

Here is an example of how the code could be modified to add bounds checking:
```c
if (level - 1 >= num_level) {
    // Handle error: level is out of range
}

entry = vm->pt_ops->pde_encode_bo(bo, map_ofs + (level - 1) * ...);
```
Alternatively, the code could be modified to use a larger integer type and check for overflows:
```c
u64 index = (u64)map_ofs + (u64)(level - 1) * ...;
if (index < map_ofs || index > ... /* max valid index */) {
    // Handle error: index is out of range
}

entry = vm->pt_ops->pde_encode_bo(bo, (u32)index);
```
Note that the exact fix will depend on the specific requirements and constraints of the code.