Question

披露：我对C很新。如果你能详细解释任何答案，我将不胜感激。

我正在编写一个linux内核模块，在我写的一个函数中，我需要将一个结构复制到用户空间，如下所示：

typedef struct
{
    uint32_t  someProperty;
    uint32_t  numOfFruits;
    uint32_t  *arrayOfFruits;
} ObjectCapabilities;

我正在实现的API具有将arrayOfFruits成员描述为“大小为numOfFruits的数组的文档，其中每个元素都是FRUIT_TYPE常量。”鉴于arrayOfFruits是一个指针，我很困惑如何做到这一点。当我copy_to_user ObjectCapabilities结构时，它只会将指针 arrayOfFruits复制到用户空间。

用户空间如何连续访问数组的元素？这是我的尝试：

ObjectCapabilities caps;
caps.someProperty = 1024;
caps.numOfFruits  = 3;
uint32_t localArray[] = {
        FRUIT_TYPE_APPLE,
        FRUIT_TYPE_ORANGE,
        FRUIT_TYPE_BANANA
};
caps.arrayOfFruits = localArray;

然后复制......我可以这样做吗？

copy_to_user((void *)destination, &caps, (sizeof(caps) + (sizeof(localArray) / sizeof((localArray)[0]))));

Answer 1

使用copy_to_user，您可以向用户执行两次复制。

//copy the struct
copy_to_user((void *)destination, &caps, sizeof(caps));
//copy the array.
copy_to_user((void *)destination->array, localArray, sizeof(localArray);

Answer 2

您无法复制原始指针，因为指向内核空间的指针对用户空间没有意义（如果取消引用，则会出现段错误。）

执行此类操作的典型方法是请求用户空间代码分配内存并将指向该内存的指针传入系统调用。如果程序没有传入足够大的缓冲区，则会因错误而失败（例如EFAULT）。如果程序无法事先知道它需要多少内存，那么通常你会在传递NULL指针时返回所需的数据量。

来自用户空间的示例用法：

// Fixed-size data
typedef struct
{
    uint32_t  someProperty;
    uint32_t  numOfFruits;
} ObjectCapabilities;

// First query the number of fruits we need
ObjectCapabilities caps;
int r = sys_get_fruit(&caps, NULL, 0);
if (r != 0) { /* Handle error */ }

// Now allocate memory and query the fruit
uint32_t *arrayOfFruits = malloc(caps.numOfFruits * sizeof(uint32_t));
r = sys_get_fruit(&caps, arrayOfFruits, caps.numOfFruits);
if (r != 0) { /* Handle error */ }

以下是相应代码在系统调用另一端的内核空间中的外观：

int sys_get_fruit(ObjectCapabilities __user *userCaps, uint32_t __user *userFruit, uint32_t numFruits)
{
    ObjectCapabilities caps;
    caps.someProperty = 1024;
    caps.numOfFruits  = 3;

    // Copy out fixed-size data
    int r = copy_to_user(userCaps, &caps, sizeof(caps));
    if (r != 0)
        return r;

    uint32_t localArray[] = {
        FRUIT_TYPE_APPLE,
        FRUIT_TYPE_ORANGE,
        FRUIT_TYPE_BANANA
    };

    // Attempt to copy variable-sized data.  Check the size first.
    if (numFruits * sizeof(uint32_t) < sizeof(localArray))
        return -EFAULT;
    return copy_to_user(userFruit, localArray, sizeof(localArray));
}

Answer 3

用户需要为所有被复制的数据提供足够的空间。理想情况下，他会告诉你他提供了多少空间，并检查一切是否合适。

复制出的数据应该（通常）不包含任何指针，因为它们是“本地”到不同的“进程”（内核可以被视为一个单独的进程，就像它和内核/用户一样）交互涉及进程到进程的IPC，类似于通过本地甚至Internet连接的套接字发送内容。

由于内核对进程有非常深入的了解，因此您可以稍微考虑这些规则，例如，您可以计算用户指针的内容，并复制出原始数据的副本，并适当地修改指针。但这有点浪费。或者，您可以复制内核指针，而不是在用户代码中使用它，但现在您正在“泄漏数据”，“坏人”有时可以通过各种方式利用它。在安全 - 人们说话中，你已经离开了一个开放的“隐蔽通道”。

最后，“正确”的做法往往是这样的：

struct user_interface_version_of_struct {
    int property;
    int count;
    int data[]; /* of size "count" */
};

用户代码malloc（或以其他方式安排有足够的空间）“用户界面版本”并对内核进行一些系统调用（read，receive，{{ 1}}，rcvmsg，无论如何，只要它涉及执行“读取”类型的操作）并告诉内核：“这是保存结构的内存，这里有多大”（以字节为单位，或者最大ioctl值，或者其他：用户和内核只需要就协议达成一致）。然后，内核端代码以某种适当的方式验证用户的值，然而复制输出最方便，或者返回错误。

“最方便”有时是两个单独的复制操作或一些count调用，例如，如果内核端具有您显示的数据结构，您可能会这样做：

put_user

但是，您可能会遇到一些非常好的界面。

修改：如果您要添加自己的系统调用（例如，而不是绑定到/* let's say ulen is the user supplied length in bytes, and uaddr is the user-supplied address */ struct user_interface_version_of_struct *p; needed = sizeof(*p) + 3 * sizeof(int); if (needed > ulen) return -ENOMEM; /* user did not supply enough space */ p = uaddr; error = put_user(1024, &p->property); if (error == 0) error = put_user(3, &p->count); if (error == 0 && copy_to_user(&p->data, localArray, 3 * sizeof(int)) error = -EFAULT;或read），则可以将标题和数据分开，如Adam Rosenfield's answer中所示

copy_to_user包含数组（指针）的结构

3 个答案: