Пример #1
0
static ssize_t pfsWrite(struct file *file, const char *buffer, size_t count, loff_t *pffset)	{
    int ret;
    unsigned int copied;
    ret = kfifo_from_user(&myfifo, buffer, count, &copied);

    wc+=1;
    return ret?ret:copied;
}
Пример #2
0
static ssize_t fifo_write(struct file *file, const char __user *buf,
						size_t count, loff_t *ppos)
{
	int ret;
	unsigned int copied;

	if (mutex_lock_interruptible(&write_lock))
		return -ERESTARTSYS;

	ret = kfifo_from_user(&test, buf, count, &copied);

	mutex_unlock(&write_lock);

	return ret ? ret : copied;
}
Пример #3
0
static int iio_kfifo_write(struct iio_buffer *r, size_t n,
	const char __user *buf)
{
	struct iio_kfifo *kf = iio_to_kfifo(r);
	int ret, copied;

	mutex_lock(&kf->user_lock);
	if (!kfifo_initialized(&kf->kf) || n < kfifo_esize(&kf->kf))
		ret = -EINVAL;
	else
		ret = kfifo_from_user(&kf->kf, buf, n, &copied);
	mutex_unlock(&kf->user_lock);
	if (ret)
		return ret;

	return copied;
}
Пример #4
0
ssize_t prod_write(struct file *filp, const char __user *buf, size_t count,
		loff_t *f_pos)
{
	int ret;
	int copied;
	pr_info("%s() : FIFO size = %d, count = %d\n", __func__,
			(int)kfifo_len(&fifo), (int)count);
	if (down_interruptible(&prod_sem))
		return -ERESTARTSYS;
	while ((int)kfifo_avail(&fifo) <= 0) { /* full */
		up(&prod_sem);
		if (filp->f_flags & O_NONBLOCK)
			return -EAGAIN;
		pr_info("%s() : \"%s\" going to sleep\n", __func__,
				current->comm);
		if (wait_event_interruptible(prod_que,\
					(((int)kfifo_avail(&fifo)) > 0))) {
			pr_info("%s() wait_event_interruptible() : signal: "
				"tell the fs layer to handle it\n", __func__);
			return -ERESTARTSYS;
			/* signal: inform the fs layer to handle it */
		}
		if (down_interruptible(&prod_sem))
			return -ERESTARTSYS;
		pr_info("%s() : \"%s\" waken from sleep\n", __func__,
				current->comm);
	}
	count = min((int)count, (int)kfifo_avail(&fifo));
	pr_info("%s() : \"%s\" data to copy = %li bytes\n",
		__func__, current->comm, (long)count);
	ret = kfifo_from_user(&fifo, buf, count, &copied);
	up(&prod_sem);
	if (ret < 0)
		return -EFAULT;
	pr_info("%s() : \"%s\" copied %d bytes.FIFO new SIZE = %d\n", __func__,
				current->comm, copied, (int)kfifo_len(&fifo));
	pr_info("%s() : \"%s\" waking up consumer processes\n", __func__,
				current->comm);
	wake_up_interruptible(&cons_que);
	return ret ? ret : copied;
}
Пример #5
0
static ssize_t
pi433_write(struct file *filp, const char __user *buf,
	    size_t count, loff_t *f_pos)
{
	struct pi433_instance	*instance;
	struct pi433_device	*device;
	int                     retval;
	unsigned int		required, available, copied;

	instance = filp->private_data;
	device = instance->device;

	/*
	 * check, whether internal buffer (tx thread) is big enough
	 * for requested size
	 */
	if (count > MAX_MSG_SIZE)
		return -EMSGSIZE;

	/*
	 * write the following sequence into fifo:
	 * - tx_cfg
	 * - size of message
	 * - message
	 */
	mutex_lock(&device->tx_fifo_lock);

	required = sizeof(instance->tx_cfg) + sizeof(size_t) + count;
	available = kfifo_avail(&device->tx_fifo);
	if (required > available) {
		dev_dbg(device->dev, "write to fifo failed: %d bytes required but %d available",
			required, available);
		mutex_unlock(&device->tx_fifo_lock);
		return -EAGAIN;
	}

	retval = kfifo_in(&device->tx_fifo, &instance->tx_cfg,
			  sizeof(instance->tx_cfg));
	if (retval != sizeof(instance->tx_cfg))
		goto abort;

	retval = kfifo_in(&device->tx_fifo, &count, sizeof(size_t));
	if (retval != sizeof(size_t))
		goto abort;

	retval = kfifo_from_user(&device->tx_fifo, buf, count, &copied);
	if (retval || copied != count)
		goto abort;

	mutex_unlock(&device->tx_fifo_lock);

	/* start transfer */
	wake_up_interruptible(&device->tx_wait_queue);
	dev_dbg(device->dev, "write: generated new msg with %d bytes.", copied);

	return copied;

abort:
	dev_warn(device->dev,
		 "write to fifo failed, non recoverable: 0x%x", retval);
	mutex_unlock(&device->tx_fifo_lock);
	return -EAGAIN;
}