On Tue, Apr 20, 2021 at 12:54:49AM +0800, Jonathan Cameron wrote:
> +
> +static int pci_doe_send_req(struct pci_doe *doe, struct pci_doe_exchange *ex)
> +{
> + struct pci_dev *pdev = doe->pdev;
> + u32 val;
> + int i;
> +
> + /*
> + * Check the DOE busy bit is not set. If it is set, this could indicate
> + * someone other than Linux (e.g. firmware) is using the mailbox. Note
> + * it is expected that firmware and OS will negotiate access rights via
> + * an, as yet to be defined method.
> + */
> + pci_read_config_dword(pdev, doe->cap + PCI_DOE_STATUS, &val);
> + if (FIELD_GET(PCI_DOE_STATUS_BUSY, val))
> + return -EBUSY;
In discussion with Dan we believe that user space could also be issuing
commands and would potentially cause us to be locked out.
We agree that firmware should be out of the way here and if it is blocking
the OS there is not much we can do about it.
However, if user space is using the mailbox we need to synchronize with them
via pci_cfg_access_[try]lock(). This should avoid this EBUSY condition.
[snip]
> +
> +static int pci_doe_recv_resp(struct pci_doe *doe, struct pci_doe_exchange *ex)
> +{
> + struct pci_dev *pdev = doe->pdev;
> + size_t length;
> + u32 val;
> + int i;
> +
> + /* Read the first two dwords to get the length and protocol */
> + pci_read_config_dword(pdev, doe->cap + PCI_DOE_READ, &val);
> + if ((FIELD_GET(PCI_DOE_DATA_OBJECT_HEADER_1_VID, val) != ex->vid) ||
> + (FIELD_GET(PCI_DOE_DATA_OBJECT_HEADER_1_TYPE, val) != ex->protocol)) {
> + pci_err(pdev,
> + "Expected [VID, Protocol] = [%x, %x], got [%x, %x]\n",
> + ex->vid, ex->protocol,
> + FIELD_GET(PCI_DOE_DATA_OBJECT_HEADER_1_VID, val),
> + FIELD_GET(PCI_DOE_DATA_OBJECT_HEADER_1_TYPE, val));
> + return -EIO;
> + }
> +
> + pci_write_config_dword(pdev, doe->cap + PCI_DOE_READ, 0);
I'm quite unfamiliar with the spec here: but it seems like this needs to be
done before the above if statement indicate we got the value?
[snip]
> +
> +static void doe_statemachine_work(struct work_struct *work)
> +{
> + struct delayed_work *w = to_delayed_work(work);
> + struct pci_doe *doe = container_of(w, struct pci_doe, statemachine);
> + struct pci_dev *pdev = doe->pdev;
> + struct pci_doe_task *task;
> + bool abort;
> + u32 val;
> + int rc;
> +
> + mutex_lock(&doe->tasks_lock);
> + task = list_first_entry_or_null(&doe->tasks, struct pci_doe_task, h);
> + abort = doe->abort;
> + doe->abort = false;
> + mutex_unlock(&doe->tasks_lock);
> +
> + if (abort) {
> + /*
> + * Currently only used during init - care needed if we want to
> + * generally expose pci_doe_abort() as it would impact queries
> + * in flight.
> + */
> + WARN_ON(task);
> + doe->state = DOE_WAIT_ABORT;
> + pci_doe_abort_start(doe);
> + return;
> + }
> +
> + switch (doe->state) {
> + case DOE_IDLE:
> + if (task == NULL)
> + return;
> +
> + /* Nothing currently in flight so queue a task */
> + rc = pci_doe_send_req(doe, task->ex);
> + /*
> + * The specification does not provide any guidance on how long
> + * some other entity could keep the DOE busy, so try for 1
> + * second then fail. Busy handling is best effort only, because
> + * there is no way of avoiding racing against another user of
> + * the DOE.
> + */
> + if (rc == -EBUSY) {
> + doe->busy_retries++;
> + if (doe->busy_retries == PCI_DOE_BUSY_MAX_RETRIES) {
> + /* Long enough, fail this request */
> + doe->busy_retries = 0;
> + goto err_busy;
With the addition of pci_cfg_access_[try]lock():
Should we have some sort of WARN_ON() here to indicate that the system is
behaving badly?
[snip]
> + case DOE_WAIT_ABORT:
> + case DOE_WAIT_ABORT_ON_ERR:
> + pci_read_config_dword(pdev, doe->cap + PCI_DOE_STATUS, &val);
> +
> + if (!FIELD_GET(PCI_DOE_STATUS_ERROR, val) &&
> + !FIELD_GET(PCI_DOE_STATUS_BUSY, val)) {
> + /* Back to normal state - carry on */
> + mutex_lock(&doe->tasks_lock);
> + if (!list_empty(&doe->tasks))
> + schedule_delayed_work(w, 0);
> + mutex_unlock(&doe->tasks_lock);
> +
> + /*
> + * For deliberately triggered abort, someone is
> + * waiting.
> + */
> + if (doe->state == DOE_WAIT_ABORT)
> + complete(&doe->abort_c);
> + doe->state = DOE_IDLE;
> +
> + return;
> + }
> + if (time_after(jiffies, doe->timeout_jiffies)) {
> + struct pci_doe_task *t, *n;
> +
> + /* We are dead - abort all queued tasks */
> + pci_err(pdev, "DOE ABORT timed out\n");
> + mutex_lock(&doe->tasks_lock);
> + doe->dead = true;
> + list_for_each_entry_safe(t, n, &doe->tasks, h) {
> + t->rv = -EIO;
> + t->cb(t->private);
> + list_del(&t->h);
> + }
> +
> + mutex_unlock(&doe->tasks_lock);
> + if (doe->state == DOE_WAIT_ABORT)
> + complete(&doe->abort_c);
> + }
> + return;
> + }
> +
> +err_abort:
> + pci_doe_abort_start(doe);
> + doe->state = DOE_WAIT_ABORT_ON_ERR;
Should this be before pci_doe_abort_start() to ensure that state is set when
the statemachine runs?
[snip]
> +
> +/**
> + * struct pci_doe - State to support use of DOE mailbox
> + * @cap: Config space offset to base of DOE capability.
> + * @pdev: PCI device that hosts this DOE.
> + * @abort_c: Completion used for initial abort handling.
> + * @irq: Interrupt used for signaling DOE ready or abort.
> + * @prots: Cache of identifiers for protocols supported.
> + * @num_prots: Size of prots cache.
> + * @h: Used for DOE instance lifetime management.
> + * @wq: Workqueue used to handle state machine and polling / timeouts.
> + * @tasks: List of task in flight + pending.
> + * @tasks_lock: Protect the tasks list.
This protects more than just the task list. It appears to protect abort and
dead as well. I'm not sure if it is worth mentioning but...
> + * @statemachine: Work item for the DOE state machine.
> + * @state: Current state of this DOE.
> + * @timeout_jiffies: 1 second after GO set.
> + * @busy_retries: Count of retry attempts.
> + * @abort: Request a manual abort (e.g. on init).
> + * @dead: Used to mark a DOE for which an ABORT has timed out. Further messages
> + * will immediately be aborted with error.
> + */
> +struct pci_doe {
> + int cap;
> + struct pci_dev *pdev;
> + struct completion abort_c;
> + int irq;
> + struct pci_doe_prot *prots;
> + int num_prots;
> + struct list_head h;
> +
> + struct workqueue_struct *wq;
> + struct list_head tasks;
> + struct mutex tasks_lock;
> + struct delayed_work statemachine;
> + enum pci_doe_state state;
> + unsigned long timeout_jiffies;
> + unsigned int busy_retries;
> + unsigned int abort:1;
> + unsigned int dead:1;
> +};
[snip]
Ira
