Question

as stated in: http://www.kernel.org/doc/htmldocs/kernel-hacking.html#routines-copy this functions “can” sleep.

So, do I always have to do a lock (e.g. with mutexes) when using this functions or are there exceptions?

I’m currently working on a module and saw some Kernel Oops at my system, but cannot reproduce them. I have a feeling they are fired because I’m currently do no locking around copy_[to/from]_user(). Maybe I’m wrong, but it smells like it has something to do with it.

I have something like:

static unsigned char user_buffer[BUFFER_SIZE];
static ssize_t mcom_write (struct file *file, const char *buf, size_t length, loff_t *offset) {
    ssize_t retval;
    size_t writeCount = (length < BUFFER_SIZE) ? length : BUFFER_SIZE;
    memset((void*)&user_buffer, 0x00, sizeof user_buffer);
    if (copy_from_user((void*)&user_buffer, buf, writeCount)) {
        retval = -EFAULT;
        return retval;
    }
    *offset += writeCount;
    retval = writeCount;        
    cleanupNewline(user_buffer);    
    dispatch(user_buffer);
    return retval;
}

Is this save to do so or do I need locking it from other accesses, while copy_from_user is running?

It’s a char device I read and write from, and if a special packet in the network is received, there can be concurrent access to this buffer.

Answer 1

You need to do locking iff the kernel side data structure that you are copying to or from might go away otherwise – but it is that data structure you should be taking a lock on.