Claude review: accel/neutron: Add logging support

[Claude Code Review Bot <claude-review@example.com>]

Patch Review

**No locking on log buffer access (data race):**

`fw_log_read` (debugfs) and `neutron_shutdown` both call `neutron_read_log`, which modifies `ndev->log.buf`, `ndev->log.buf_count`, and the hardware HEAD register. There is no lock protecting any of this:

```c
static ssize_t fw_log_read(struct file *f, char __user *buf, size_t count, loff_t *pos)
{
    ...
    if (ndev->flags & NEUTRON_BOOTED)
        neutron_read_log(ndev, count);

    return simple_read_from_buffer(buf, count, pos, ndev->log.buf,
                                   ndev->log.buf_count);
}
```

Multiple concurrent readers of the debugfs file will race, and `neutron_shutdown` calling `neutron_read_log` while a debugfs read is in progress will corrupt the buffer. A mutex should protect the entire read-then-consume sequence.

**`neutron_init_logging` uses `devm_kfree`/`devm_kmalloc` from runtime resume path:**

```c
devm_kfree(ndev->dev, ndev->log.buf);
ndev->log.buf = devm_kmalloc(ndev->dev, ndev->log.size, GFP_KERNEL);
```

`neutron_init_logging` is called from `neutron_boot`, which is called from `neutron_runtime_resume`. Using devm allocation in a runtime PM callback is unusual -- devm resources are freed on driver unbind, not on runtime suspend. If the log size changes between boot cycles (unlikely but possible), old buffers accumulate until driver removal. Consider using plain `kfree`/`kmalloc` with explicit cleanup in `neutron_remove`.

**`neutron_read_log` advances the hardware HEAD pointer as a side-effect of reading:**

```c
head = (head + ndev->log.buf_count) % ndev->log.size;
writel_relaxed(head, NEUTRON_REG(ndev, HEAD));
```

This means each read consumes log data from the ring buffer. If a process reads a few bytes at a time via `simple_read_from_buffer`, the first `read()` call drains the ring buffer into `ndev->log.buf`, advances HEAD, and subsequent reads just read from the kernel buffer via `*pos`. This works for sequential reads from one process, but is confusing if the file is opened/read by multiple processes simultaneously, since they share the ring buffer consumer.

---
Generated by Claude Code Patch Reviewer