Quelle est la différence entre devm_kzalloc() et kzalloc() dans la programmation des pilotes linux ?

Question

J'ai trouvé devm_kzalloc() y kzalloc() dans la programmation des pilotes de périphériques. Mais je ne sais pas quand/où utiliser ces fonctions. Quelqu'un peut-il préciser l'importance de ces fonctions et leur utilisation ?

Answer 1

kzalloc() alloue la mémoire du noyau comme kmalloc() mais il réinitialise également la mémoire allouée. devm_kzalloc() est géré kzalloc() . La mémoire allouée aux fonctions gérées est associée à l'appareil. Lorsque le périphérique est détaché du système ou que son pilote est déchargé, cette mémoire est libérée automatiquement. Si plusieurs ressources gérées (mémoire ou autre ressource) ont été allouées au périphérique, la dernière ressource allouée est libérée en premier.

Les ressources gérées sont très utiles pour garantir le bon fonctionnement du pilote, tant en cas d'échec de l'initialisation qu'en cas d'initialisation réussie suivie de la suppression du dispositif.

Veuillez noter que les ressources gérées (qu'il s'agisse de la mémoire ou d'une autre ressource) sont destinées à être utilisées dans le code chargé de sonder le périphérique. Elles sont généralement mal choisies pour le code utilisé pour ouvrir le périphérique, car celui-ci peut être fermé sans être déconnecté du système. La fermeture du dispositif nécessite de libérer les ressources manuellement, ce qui va à l'encontre de l'objectif des ressources gérées.

La mémoire allouée avec kzalloc() doit être libéré avec kfree() . La mémoire allouée avec devm_kzalloc() est libéré automatiquement. Il peut être libéré avec devm_kfree() mais c'est généralement le signe que l'allocation de mémoire gérée n'est pas adaptée à la tâche.

Answer 2

En termes simples, devm_kzalloc() et kzalloc() sont tous deux utilisés pour l'allocation de mémoire dans le pilote de périphérique, mais la différence est que si vous allouez de la mémoire par kzalloc(), vous devez libérer cette mémoire lorsque le cycle de vie de ce pilote de périphérique est terminé ou lorsqu'il est déchargé du noyau, alors que si vous faites la même chose avec devm_kzalloc(), vous n'avez pas à vous soucier de libérer la mémoire, celle-ci est libérée automatiquement par la bibliothèque de périphérique elle-même.

Les deux font exactement la même chose, mais en utilisant devm_kzalloc, le programmeur est libéré d'une petite partie de la charge de travail liée à la libération de la mémoire.

Nous allons vous expliquer en vous donnant un exemple, le premier exemple étant l'utilisation de kzalloc.

static int pxa3xx_u2d_probe(struct platform_device *pdev)
{
    int err;
    u2d = kzalloc(sizeof(struct pxa3xx_u2d_ulpi), GFP_KERNEL);     1
    if (!u2d)
         return -ENOMEM;
    u2d->clk = clk_get(&pdev->dev, NULL);
    if (IS_ERR(u2d->clk)) {
        err = PTR_ERR(u2d->clk);                                    2
        goto err_free_mem;
    }
...
    return 0;
err_free_mem:
    kfree(u2d);
    return err;
}
static int pxa3xx_u2d_remove(struct platform_device *pdev)
{
    clk_put(u2d->clk);               
    kfree(u2d);                                                     3
    return 0;
}

Dans cet exemple, vous pouvez utiliser la fonction pxa3xx_u2d_remove(), kfree(u2d)(ligne indiquée par 3) est là pour libérer la mémoire allouée par u2d voir maintenant le même code en utilisant devm_kzalloc()

static int pxa3xx_u2d_probe(struct platform_device *pdev)
{
    int err;
    u2d = devm_kzalloc(&pdev->dev, sizeof(struct pxa3xx_u2d_ulpi), GFP_KERNEL);
    if (!u2d)
        return -ENOMEM;
    u2d->clk = clk_get(&pdev->dev, NULL);
    if (IS_ERR(u2d->clk)) {
         err = PTR_ERR(u2d->clk);
         goto err_free_mem;
    }
...
    return 0;
err_free_mem:
    return err;
}
static int pxa3xx_u2d_remove(struct platform_device *pdev)
{
    clk_put(u2d->clk);
    return 0;
}

il n'y a pas de kfree() pour libérer la fonction car la même chose est faite par devm_kzalloc()