The new set of functions to access user space may look disappointing at first, but they are meant to ultimately make life easier for the programmer. With Linux 2.1, there’s no longer a need to explicitly check user space; access_ok won’t usually need to be called. The code using the new interface can just go ahead and transfer its data. The _ret functions, then, turn out to be very useful when implementing system calls, because a failure in user-space access usually results in a failure in the system call with -EFAULT.

The typical read implementation, therefore, will look like this:

long new_read(struct inode *inode, struct file *filp,
              char *buf, unsigned long count);
{
/* identify your data (device-specific code) */

if (__copy_to_user(buf, new_data, count))
    return -EFAULT;
return count;
}

Note that the non-checking __copy_to_user function is used because the caller already checked the user address before dispatching data transfer to the file operations. This is just like 2.0, where read and write didn’t need to call verify_area.

Similarly, the typical ioctl implementation will look like the following:

int new_ioctl(struct inode *inode, struct file *filp,
              unsigned int cmd, unsigned long arg);
{
/* device-specific checks, if needed */

switch(cmd) {
    case NEW_GETVALUE:
        put_user_ret(new_value,(int *)arg,-EFAULT);
        break;

    case NEW_SETVALUE:
        get_user_ret(new_value,(int *)arg,-EFAULT);
        break;
    default
        return -EINVAL;
    }
return 0;
}

Unlike the version 2.0 equivalent, this function doesn’t need to check its arguments before the switch statement, because each get_user or put_user does the checking. An alternative implementation is the following one:

int another_ioctl(struct inode *inode, struct file *filp,
              unsigned int cmd, unsigned long arg);
{
int retval = -EINVAL, size = _IOC_SIZE(cmd);

if (_IOC_DIR(cmd) & _IOC_READ) {
    if (!access_ok(VERIFY_WRITE, (void *)arg, size))
        retturn -EFAULT;
    }
else if (_IOC_DIR(cmd) & _IOC_WRITE) {
    if (!access_ok(VERIFY_READ, (void *)arg, size))
        return -EFAULT

switch(cmd) {
    case NEW_GETVALUE:
        retval = __put_user(another_value,arg);
        break;
    case NEW_SETVALUE:
        retval = __get_user(another_value,arg);
        break;
    }
return retval;
}

When you want to write code that compiles with both 2.0 and 2.1, on the other hand, things become slightly more complicated, as you can’t use the C preprocessor to fake the new behavior with older kernels. You can’t just #define a get_user macro that receives two arguments, because the actual get_user implementation in version 2.0 is already a macro.

My own choice for writing code that is both portable and efficient is to set up sysdep-2.1.h to provide source code with the following functions. Only the functions that read data are listed; functions that write data behave in exactly the same way.

This way of implementing compatibility is my personal preference, but it’s not the only way to do it. In my sample code, verify_area_20 must be called before any user-space access (excluding the buffer for read and write, which is already checked in advance). An alternative would be to be more faithful to 2.1 semantics and automatically generate a verify_area at each get_user or copy_from_user when 2.0 is used. This choice would be cleaner at the source level, but rather inefficient when compiled with version 2.0, both in code size and execution time.

Sample code that compiles with both 2.0 and 2.1 is, for example, the scull module, as found in the directory v2.1/scull. I don’t feel the code is interesting enough to show it here.