Calling poll() with iio_buffer_get_poll_fd() hangs with certain profiles

[pfeatherstone]

I'm using a Bytepipe x9002 with a Yocto Linux image and meta-adi. I'm also using a CMOS build. I'm building a software application where I want to use poll() on the file descriptor returned by iio_buffer_get_poll_fd() on an RX buffer to wait on incoming data, leaving my application room to do other stuff in the background, then call iio_buffer_refill() to read the data. I've had some success with this when using profiles where both RX and TX use a common sample rate and are fairly low, i.e. < 1Msps. When i use a profile where RX rate is 20Msps and TX rate is < 2Msps, a call to poll() will indefinitely hang. I've tried setting the buffer in both blocking and non-blocking mode, it makes no difference.

If i do a synchronous read, i.e. buffer is in blocking mode and just call iio_buffer_refill() it works. The problem is when i call poll().
My profile is:

250311FddRx15MHz20MspsNCO9926kHzTx31p25kHz1250kspsMCSCmosApi68p13p7.bin.txt
250311FddRx15MHz20MspsNCO9926kHzTx31p25kHz1250kspsMCSCmosApi68p13p7.json.txt
250311FddRx15MHz20MspsNCO9926kHzTx31p25kHz1250kspsMCSCmosApi68p13p7.taxidi.txt

[pfeatherstone]

Looking at this code in local.c:

static ssize_t local_get_buffer(const struct iio_device *dev,
		void **addr_ptr, size_t bytes_used,
		uint32_t *mask, size_t words)
{
	struct block block;
	struct iio_device_pdata *pdata = dev->pdata;
	struct timespec start;
	char err_str[1024];
	int f = pdata->fd;
	ssize_t ret;

	if (!WITH_LOCAL_MMAP_API || !pdata->is_high_speed)
		return -ENOSYS;
	if (f == -1)
		return -EBADF;
	if (!addr_ptr)
		return -EINVAL;

	if (pdata->last_dequeued >= 0) {
		struct block *last_block = &pdata->blocks[pdata->last_dequeued];

		if (pdata->cyclic) {
			if (pdata->cyclic_buffer_enqueued)
				return -EBUSY;
			pdata->blocks[0].flags |= BLOCK_FLAG_CYCLIC;
			pdata->cyclic_buffer_enqueued = true;
		}

		last_block->bytes_used = bytes_used;
		ret = (ssize_t) ioctl_nointr(f,
				BLOCK_ENQUEUE_IOCTL, last_block);
		if (ret) {
			iio_strerror(-ret, err_str, sizeof(err_str));
			IIO_ERROR("Unable to enqueue block: %s\n", err_str);
			return ret;
		}

		if (pdata->cyclic) {
			*addr_ptr = pdata->addrs[pdata->last_dequeued];
			return (ssize_t) last_block->bytes_used;
		}

		pdata->last_dequeued = -1;
	}

	clock_gettime(CLOCK_MONOTONIC, &start);

	do {
		ret = (ssize_t) device_check_ready(dev, POLLIN | POLLOUT, &start);
		if (ret < 0)
			return ret;

		memset(&block, 0, sizeof(block));
		ret = (ssize_t) ioctl_nointr(f, BLOCK_DEQUEUE_IOCTL, &block);
	} while (pdata->blocking && ret == -EAGAIN);

	if (ret) {
		if ((!pdata->blocking && ret != -EAGAIN) ||
				(pdata->blocking && ret != -ETIMEDOUT)) {
			iio_strerror(-ret, err_str, sizeof(err_str));
			IIO_ERROR("Unable to dequeue block: %s\n", err_str);
		}
		return ret;
	}

	pdata->last_dequeued = block.id;
	*addr_ptr = pdata->addrs[block.id];
	return (ssize_t) block.bytes_used;
}

Inside the if (pdata->last_dequeued >= 0) {...} block, is the point of that code to release the last DMA block, leaving room for the next one? This allows the next call to device_check_read() which in turn calls poll() on the file descriptor to wake up? If you manually call poll() externally like i'm doing you don't have that dequeuing mechanism

[pfeatherstone]

I have a workaround. I basically need to manually enqueue blocks after every call to iio_buffer_refill(). so i've added the following:

in iio-backend.h:

struct iio_backend_ops {
...
ssize_t (*release_buffer)(const struct iio_device *dev, void **addr_ptr, size_t bytes_used);
};

In buffer.c:

ssize_t iio_buffer_release(struct iio_buffer *buffer)
{
	const struct iio_device *dev = buffer->dev;
	ssize_t ret = 0;
	if (buffer->dev_is_high_speed && dev->ctx->ops->release_buffer) {
		ret = dev->ctx->ops->release_buffer(dev, &buffer->buffer, buffer->length);
	}
	return ret;
}

In local.c:

static ssize_t local_release_buffer(const struct iio_device *dev,
		void **addr_ptr, size_t bytes_used)
{
	struct iio_device_pdata *pdata = dev->pdata;
	char err_str[1024];
	int f = pdata->fd;
	ssize_t ret;

	if (!WITH_LOCAL_MMAP_API || !pdata->is_high_speed)
		return -ENOSYS;
	if (pdata->cyclic)
		return -ENOSYS;
	if (f == -1)
		return -EBADF;
	if (!addr_ptr)
		return -EINVAL;

	if (pdata->last_dequeued >= 0) {
		printf("local_release_buffer() - last_dequeued >= 0 - re-enqueuing something...?\n");
		struct block *last_block = &pdata->blocks[pdata->last_dequeued];
		last_block->bytes_used = bytes_used;
		ret = (ssize_t) ioctl_nointr(f, BLOCK_ENQUEUE_IOCTL, last_block);
		if (ret) {
			iio_strerror(-ret, err_str, sizeof(err_str));
			IIO_ERROR("Unable to enqueue block: %s\n", err_str);
			return ret;
		}
		pdata->last_dequeued = -1;
	}
	return 0;
}

static const struct iio_backend_ops local_ops = {
...
    .release_buffer = local_release_buffer,
...
}

Then after i've called iio_buffer_refill() i call iio_buffer_release() giving the buffer back to the kernel. I appreciate this is already done inside local_get_buffer(), however i'm having to manually call it so that when calling poll() externally it doesn't block

[pfeatherstone]

I'm looking at the libiio V1 API to see if upgrading to that will be a better solution. But i'm getting very confused. First of all it looks like the only way libiio exposes a file descriptor is iio_block_get_dmabuf_fd() which means it doesn't work with the MMAP API unlike in v0.26. That seems to be a limitation. There also seems to be two file descriptors: iio_block::dmabuf_fd and iio_event_stream_pdata::fd. The latter seems to map to iio_device_pdata::fd in v0.26.

[pfeatherstone]

#1365