Как я могу выделить память в ядре Linux для строки типа char *?

Question

Я пытаюсь выделить немного памяти для символа * следующим образом.

static ssize_t memo_write(struct file *filp, const char __user *buf, 
   size_t count, loff_t *f_pos){
    ssize_t retval = -ENOMEM;
    printk("write function\n");

    if((data = kmalloc(strlen(buf), GFP_KERNEL)) == NULL)
        printk("kmalloc fail\n");

    if(copy_from_user(data, buf, strlen(buf))){
        retval = -EFAULT;
        goto out;
    }
    *f_pos += strlen(buf);
    retval = strlen(buf);

    out:
        return retval;
}

'данные' объявлены в заголовочном файле как

char *data;

Когда я вызываю функцию записи, строка 'kmalloc fail' не достигается, что заставляет меня думать, что kmalloc успешно, но данные не отображаются, когда я снова пытаюсь прочитать из переменной 'data'.

Еще более запутанно, если я избавлюсь от бита kmalloc, данные можно будет прочитать из драйвера. Хотя проблема заключается в том, что за ним следует загрузка других данных, потому что у меня нет возможности использовать memset ().

Правильно ли я использую kmalloc? Предположительно нет. Как я должен это делать?

Кроме того, моя функция чтения выглядит следующим образом.

static ssize_t memo_read(struct file *f, char __user *buf, 
    size_t count, loff_t *f_pos){
    ssize_t retval = 0;

    printk("read function\n");
    printk("data = %s\n", data);

    if(*f_pos >= strlen(data)){
        printk("EOF\n");
        goto out;
    }

    if(copy_to_user(buf, data, strlen(data))){
        retval = -EFAULT;
        goto out;
    }
    printk("copy_to_user success\n");
    *f_pos += strlen(data);
    retval = strlen(data);
    out:
        return retval;
}

Спасибо.

Answer 1

Вы должны использовать strlen_user() в указателе пользовательского пространства вместо strlen() - и вы должны вызывать его только один раз и сохранить результат (в противном случае у вас есть потенциальная уязвимость ядра, потому что второй поток пользовательского пространства можетизмените буфер во время работы над ним).

В качестве альтернативы вы можете использовать strncpy_from_user().

Кроме этого, kmalloc выглядит нормально.

---

(Но на самом деле, как говорит ephemient , вам следует переосмыслить весь свой подход и использовать аргумент count вместо того, чтобы рассматривать ввод как строку).

---

Так какВы не можете полагаться на данные, записанные в файл как строки с нулевым символом в конце, вам нужно хранить параметр длины data_len рядом с data.Тогда ваши реализации read / write будут выглядеть следующим образом:

static char *data = NULL;
static size_t data_len;
static DEFINE_MUTEX(data_mutex);

static ssize_t memo_read(struct file *f, char __user *buf, size_t count, loff_t *f_pos
{
    ssize_t retval = 0;
    char *start;

    mutex_lock(&data_mutex);

    if (!data)
    {
        retval = -EINVAL; /* Or whatever you want to do here... */
        goto out;
    }

    if (*f_pos >= data_len)
        goto out; /* EOF */

    start = data + *f_pos;
    retval = data_len - *f_pos;

    if (retval > count)
        retval = count;

    if (copy_to_user(buf, start, retval))
    {
        retval = -EFAULT;
        goto out;
    }

    *f_pos += retval;

out:
    mutex_unlock(&data_mutex);
    return retval;
}

static ssize_t memo_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
    ssize_t retval = -ENOMEM;

    mutex_lock(&data_mutex);

    if (data)
        kfree(data);

    data = kmalloc(count, GFP_KERNEL);

    if (!data)
        goto out;

    if (copy_from_user(data, buf, count))
    {
        kfree(data);
        retval = -EFAULT;
        goto out;
    }

    *f_pos = count;
    retval = count;
    data_len = count;

out:
    mutex_unlock(&data_mutex);
    return retval;
}

Answer 2

Не забывайте kfree(data) в ваших случаях ошибки ...

В любом случае, buf - это указатель на пользовательскую память, поэтому НЕ вызывайте strlen(buf).Сначала вы должны copy_from_user.Почему бы не

data = kmalloc(count);
copy_from_user(data, buf, count);

?

---

Ваш обработчик чтения предполагает, что data является строкой с нулевым символом в конце.Когда вы использовали массив, это могло произойти случайно, но вы никогда не гарантировали этого в своем обработчике записи.Я предполагаю, что copy_to_user терпит неудачу.

Вот рабочий пример модуля "memo", который я только что написал, используя kmalloc:

#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/uaccess.h>

static char *data;
static size_t len;

static ssize_t
memo_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
        ssize_t copy_len = min(len - min(len, *ppos), count);
        ssize_t retval;

        if (copy_to_user(buf, data + *ppos, copy_len)) {
                retval = -EFAULT;
                goto out;
        }

        *ppos += copy_len;
        retval = copy_len;

out:
        return retval;
}

static ssize_t
memo_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
        ssize_t retval;
        char *newdata;

        newdata = kmalloc(count, GFP_KERNEL);
        if (!newdata) {
                retval = -ENOMEM;
                goto out;
        }

        if (copy_from_user(newdata, buf, count)) {
                retval = -EFAULT;
                goto out;
        }

        kfree(data);
        data = newdata;
        newdata = NULL;
        retval = len = count;

out:
        kfree(newdata);
        return retval;
}

static const struct file_operations memo_fops = {
        .owner = THIS_MODULE,
        .llseek = no_llseek,
        .read = memo_read,
        .write = memo_write,
};

static struct miscdevice memo_misc = { MISC_DYNAMIC_MINOR, "memo", &memo_fops };

static int __init memo_init(void)
{
        int result;

        result = misc_register(&memo_misc);
        if (result < 0)
                return -ENODEV;

        return 0;
}

static void __exit memo_exit(void)
{
        misc_deregister(&memo_misc);
        kfree(data);
        return;
}

module_init(memo_init);
module_exit(memo_exit);
MODULE_AUTHOR("ephemient");
MODULE_LICENSE("GPL");

Конечно, этоотсутствует блокировка и другие меры предосторожности, но я надеюсь, что это поможет.