Question

I am reading the Linux kernel code for copy_fom_user, which is architecture dependent and I focus on x86 architectures.

But I got two pieces of implementation for it.

One is here (in arch/x86/lib/usercopy_32.c), while the other is here (in include/asm-generic/uaccess.h).

Which one will be finally compiled into the kernel. I guess the former is the real one, but I am not sure. What is more strange is that the former has the function name _copy_from_user instead of copy_from_user

I always have this kind of confusions when reading the kernel code. For example, due to the conditional compiling, the same function may have multiple implementation and I cannot determine which one will be used in general. Is there any tool that, given a complied kernel and a function of interest, tells you the corresponding binary code, so that you can disassemble it? Or it would be even better if it can tell you the source code that the binary code corresponds to.

Answer 1

Generally, if there is a module present in the architecture-specific subdirectory, that is the one being used. Otherwise, the generic one is it.

For the modules given, the .c is the correct one. Rarely is there any executable code in a .h. I have 2.6.27.8’s uaccess.h handy:

#ifndef _ASM_GENERIC_UACCESS_H_
#define _ASM_GENERIC_UACCESS_H_

/*
 * This macro should be used instead of __get_user() when accessing
 * values at locations that are not known to be aligned.
 */
#define __get_user_unaligned(x, ptr)                                    \
({                                                                      \
        __typeof__ (*(ptr)) __x;                                        \
        __copy_from_user(&__x, (ptr), sizeof(*(ptr))) ? -EFAULT : 0;    \
        (x) = __x;                                                      \
})


/*
 * This macro should be used instead of __put_user() when accessing
 * values at locations that are not known to be aligned.
 */
#define __put_user_unaligned(x, ptr)                                    \
({                                                                      \
        __typeof__ (*(ptr)) __x = (x);                                  \
        __copy_to_user((ptr), &__x, sizeof(*(ptr))) ? -EFAULT : 0;      \
})

#endif /* _ASM_GENERIC_UACCESS_H */

Look at that carefully. These are macro wrappers to call the underlying __copy_from_user() and __copy_to_user() functions, which are implemented differently on each architecture.