Comment puis-je allouer de la mémoire dans le noyau Linux pour un char* type de chaîne?

Je suis en train d'allouer de la mémoire pour un char* comme suit.

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;
}

"data" est déclarée dans un fichier d'en-tête comme

char *data;

Lorsque j'appelle la fonction d'écriture, le "kmalloc l'échec de la ligne n'est pas atteint, ce qui m'amène à croire que le kmalloc réussi, cependant, les données ne sont pas affichées lorsque je tente de lire à partir de la "data" variable de nouveau.

Plus de prêter à confusion, si je me débarrasser de la kmalloc bits au total, les données peuvent être lues à partir du pilote. Bien que le problème est ensuite elle est suivie par la charge des autres données car je n'ai pas la possibilité de memset() il.

Suis-je à l'aide de kmalloc correctement? Sans doute pas. Comment dois-je faire cela?

De plus, ma fonction de lecture est comme suit.

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;
}

Grâce.

  • Merci pour ces deux grandes réponses, c'est vraiment d'une grande aide! J'avais marquer à la fois comme la réponse choisie si je pouvais, même si je vais prendre la caf parce qu'il/elle verrouillage fourni et a moins de réputation :p Merci encore!
InformationsquelleAutor cheesysam | 2010-01-20
  1. 11

    Vous devriez être en utilisant strlen_user() sur l'espace utilisateur aiguille, au lieu de strlen() - et vous ne devez faire qu'une seule fois, et de le garder autour de lui (autrement, vous avez un potentiel à exploiter de noyau, car une seconde de l'espace utilisateur thread pourrait modifier la mémoire tampon pendant que vous travaillez sur elle).

    Sinon, vous pouvez utiliser strncpy_from_user().

    En dehors de cela, la kmalloc semble OK.

    (Mais vraiment, comme ephemient dit, vous devez repenser votre approche et l'utilisation de la count argument au lieu de les traiter comme un string).

    Puisque vous ne pouvez pas compter sur les données écrites dans un fichier en cours de nul chaînes terminées, vous aurez besoin de garder un data_len de paramètres de longueur autour des côtés de la data. Ensuite, votre read/write implémentations serait le long de ces lignes:

    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;
}
    • J'ai pensé à ça, mais sans doute c'est dans un write gestionnaire... alors pourquoi ne pas utiliser le count argument? Il ne devrait pas être une garantie que buf est NUL de terminaison.
    • Tout à fait vrai - j'ai mis à jour la réponse à être d'accord avec cela (mais pas supprimé la réponse, parce que je pense que les autres informations que j'ai ajouté est indépendamment utile).
    • Maintenant que vous avez mentionné, en utilisant le comte argument fait beaucoup plus de sens.
    • Ah, nous avons tous deux s'en alla et fit la même chose 🙂 la tienne a le "verrouillage et d'autres précautions de sécurité" que je mets en garde sont manquants dans la mienne.
    • Je ne suis pas sûr que le mien est totalement sûr, pour être honnête, le mélange de loff_t, ssize_t et size_t rend ma peau ramper, il y a très probablement subtile les problèmes de débordement de là.
    InformationsquelleAutor caf
  2. 5

    N'oubliez pas de kfree(data) dans votre cas d'erreur...

    Dans tous les cas, buf est un pointeur vers la mémoire utilisateur, afin de NE PAS les appeler strlen(buf). Vous devez copy_from_user premier. Pourquoi ne pas

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

    ?

    Lire votre gestionnaire suppose que data est un NUL de terminaison de chaîne. Quand vous étiez à l'aide d'un tableau, ce qui peut avoir été le cas par accident, mais vous n'avez jamais réellement assurer écrire gestionnaire. Ma conjecture est que copy_to_user échoue.

    Voici un exemple de travail d'une "note de service" module que j'ai écrit jusqu'à maintenant, à l'aide de 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");

    Bien sûr, ce manque de verrouillage et d'autres précautions de sécurité, mais j'espère que cette aide.

    • J'ai essayé cela, cependant, je vais avoir le même problème. Rien de ce que j'écris à mon pilote n'est pas réfléchi quand j'utilise "cat /dev/myDriver" pour voir ce qui est là. Même s'il le fait si je me suis débarrassé de la kmalloc complètement trucs.
    • Il y a probablement aussi un bug dans votre lecture de code, c'est juste de travail par accident, vous pourriez mettre à jour votre question avec votre lecture de la mise en œuvre trop.
    InformationsquelleAutor ephemient