kernel mutex vs wait_event_interruptible_exclusive - c

Question

I want to write a simple char driver that implement consuming read and write, it holds a buffer and two global pointers to the buffer for the read and write offsets. Every process should read or write exclusively and also readers have to wait until there is at least 512 bytes to read. Just for the exercise I want to do it with wait_event_interruptible_exclusive instead of mutexes. My read and write are:
static ssize_t
my_read(struct file *file, char __user *buf, size_t lbuf, loff_t *ppos)
{
int nbytes;
wait_event_interruptible_exclusive(wq, atomic_read(&data_sz) >=512 && (atomic_xchg(&data_sz,-1) || 1) );
nbytes = simple_read_from_buffer(buf, lbuf, &read_pos, my_buff, my_buff_size);
*ppos = read_pos;
atomic_set(&data_sz,write_pos-read_pos);
wake_up_interruptible(&wq);
return nbytes;
}
static ssize_t
my_write(struct file *file, const char __user *buf, size_t lbuf,
loff_t *ppos)
{
int nbytes;
wait_event_interruptible_exclusive(wq, atomic_read(&data_sz) != -1 && (atomic_xchg(&data_sz,-1) || 1));
nbytes = simple_write_to_buffer(my_buff, my_buff_size, &write_pos, buf, lbuf);
*ppos = write_pos;
atomic_set(&data_sz,write_pos-read_pos);
wake_up_interruptible(&wq);
return nbytes;
}
Is it ok to do it like that ? Is it possible to replace every usage of mutex with something like that ?
Also, since my offsets for the buffer are global, the ppos parameter of the read and write is ignored by the driver , and wonder if the lines *ppos=read_pos and *ppos=write_pos are needed ?

Answer 1

While atomic operation is executed indivisibly from the view of all processes, combination (e.g. with && operation) of atomic operations has no longer indivisible.
In your code, two readers at the same time may find atomic_read(&data_sz) >=512 to be true, and then execute atomic_xchg(&data_sz,-1) (the second reader would execute this operation with data_sz equal to -1).
For indivisibility of condition, you may protect its evaluation with spinlock. In that case, atomic variables are not needed. Example below uses spinlock provided by the waitqueue itself:
loff_t read_pos = 0, write_pos = 0;
size_t data_sz = 0;
DECLARE_WAIT_QUEUE_HEAD(wq);
static ssize_t
my_read(struct file *file, char __user *buf, size_t lbuf, loff_t *ppos)
{
int nbytes;
spin_lock(&wq.lock); // Take the lock before checking condition
// Next call will drop the lock while waiting and reacquire it on wake up.
wait_event_interruptible_exclusive_locked(&wq, data_sz >= 512);
// TODO: Interruptible wait may wakeup premature; check its return value.
data_sz = -1; // Prevent other waiters to enter read/write section
spin_unlock(&wq.lock);
nbytes = simple_read_from_buffer(buf, lbuf, &read_pos, my_buff, my_buff_size);
*ppos = read_pos;
spin_lock(&wq.lock); // Take the lock before updating data_sz
data_sz = write_pos - read_pos;
// There is no 'wake_up_interruptible_locked',
// but "normal" wakeup works with interruptible waits too.
wake_up_locked(&wq);
spin_unlock(&wq.lock);
return nbytes;
}