Problems with CDC and FreeRTOS streams

[bdill.1]

I'm experiencing a weird race condition / hangup with an application that I've built for my STM32F407VGTx. Basically I connect to the device via a USB cable and open a terminal to type commands on the device like a CLI. Everything works fine until I paste a large buffer into the console - at which point it locks up and seems to get frozen in some FreeRTOS related calls.

in my CDC callback i have this:

void CDCSystem::halalCDCReceiveFSCallback(uint8_t* data, uint32_t* length) {
  if (this->protocol == nullptr) {
    return;
  }
  this->protocol->handleIncoming(data, *length);
}

The `handleIncoming` method parses the incoming data and will likely print return characters to the console. I'm using a FreeRTOS stream buffer for the outgoing data, here's the write method:

void CDCSystem::write(uint8_t* data, std::size_t length) {
  std::size_t consumed = 0;
  while (consumed < length) {
    BaseType_t pxHigherPriorityTaskWoken;
    bool isr = halal_IS_ISR();
    auto crit = halal_ENTER_CRITICAL();
    if (isr) {
      consumed += xStreamBufferSendFromISR(outputBuffer, data + consumed, length - consumed, &pxHigherPriorityTaskWoken);
    } else {
      consumed += xStreamBufferSend(outputBuffer, data + consumed, length - consumed, 10);
    }
    halal_EXIT_CRITICAL(crit);
    halal_YIELD_FROM_ISR(pxHigherPriorityTaskWoken);
  }
;
}

I then have a FreeRTOS task that consumes the data written to this stream and writes it back out to the CDC device: 

void StartCDCSystemTask(void *argument) {
  auto cdcSystem = CDCSystem::getInstance();

  outputBuffer = xStreamBufferCreate(HALAL_CDC_SYSTEM_OUTPUT_BUFFER_SIZE, std::max(1, HALAL_CDC_SYSTEM_OUTPUT_BUFFER_SIZE / 2));
  uint8_t readBuffer[HALAL_CDC_SYSTEM_OUTPUT_BUFFER_READ_SIZE];

  while (true) {
    std::size_t read = xStreamBufferReceive(
        outputBuffer,
        &readBuffer[0],
        HALAL_CDC_SYSTEM_OUTPUT_BUFFER_READ_SIZE,
        10);
    if (read == 0) {
      continue;
    }

    uint8_t iterations = 0;
    uint8_t result;
    do {
      result = CDC_Transmit_FS(&readBuffer[0], read);
      iterations++;
    } while (result != USBD_OK
        && iterations < HALAL_USB_SERIAL_SYSTEM_MAX_SEND_ITERATIONS
        && cdcSystem->isUsbConnected());

    if (iterations >= HALAL_USB_SERIAL_SYSTEM_MAX_SEND_ITERATIONS) {
      app_fault_raise(APP_ERROR_MAX_ITERATIONS_DURING_SEND);
    }
  }

}

It seems to get stuck in the `write` method because it's unable to write all of the data to the stream (`xStreamBufferSendXXX` returns 0) - so my loop continues infinitely trying to write that data to the stream. I would expect that the task processing said stream would drain it enough so that eventually the `write` method would be able to put data into the stream.

The other thing I noticed is that when I pause the application in MXCubeIDE the `CDCSystemTask` seems to be stuck in the `write` method... (i can see that in the stack), but it should have never gotten to that method because it never does that... I assume this has something to do with YIELD and preemption?

 All of my `write` methods should be called from the CDC incoming ISR.