Quelle est la différence entre devm_kzalloc() et kzalloc (sous linux), la programmation du pilote

J'ai trouvé devm_kzalloc() et kzalloc() dans le pilote de périphérique programmong. Mais je ne sais pas quand et où utiliser ces fonctions. Quelqu'un peut-veuillez préciser l'importance de ces fonctions et de leur utilisation.

Salut, Si nous utilisons devm_kzalloc() alors pas besoin de libérer cette mémoire (réf: lien). Donc, peut-on remplacer tous les kzalloc() fonctionne avec devm_kzalloc() dans les programmes, étant donné que nous pouvons réduire le fardeau de la libération de la mémoire allouée dynamiquement..?
Je crois que devres.txt la plupart des questions réponses. L' 'devres.txt' doit être à jour pour votre version de Linux (à partir de 2.6.31+).

OriginalL'auteur RajKumar Rampelli | 2012-09-04

  1. 26

    kzalloc() alloue de la mémoire du noyau comme kmalloc(), mais aussi zéro-initialise la mémoire allouée. devm_kzalloc() est géré kzalloc(). La mémoire allouée avec la gestion des fonctions est associé à l'appareil. Lorsque l'appareil est détachée du système ou le pilote de l'appareil est déchargé, que la mémoire est libérée automatiquement. Si plusieurs ressources gérées (mémoire ou une autre ressource) ont été alloués pour l'appareil, les ressources allouées dernier est libéré de la première.

    Géré les ressources sont très utiles pour assurer un fonctionnement correct du conducteur, les deux pour l'initialisation de l'échec à tout point et à la réussite de l'initialisation suivie par le retrait du périphérique.

    Veuillez noter que les ressources gérées (si c'est de la mémoire ou de toute autre ressource) sont destinés à être utilisés dans le code responsable de la détection de l'appareil. Ils sont généralement un mauvais choix pour le code utilisé pour l'ouverture de l'appareil, que l'appareil peut être fermé sans être déconnecté du système. La fermeture de l'appareil nécessite de libérer les ressources manuellement, ce qui est contraire au but de la gestion des ressources.

    La mémoire allouée avec kzalloc() doit être libérée avec kfree(). La mémoire allouée avec devm_kzalloc() est libérée automatiquement. Il peut être libéré avec devm_kfree(), mais c'est habituellement un signe que la gestion de l'allocation de la mémoire n'est pas un bon ajustement pour la tâche.

    Cela vaut vraiment la peine de mentionner que le cas d'utilisation de gestion de ressources est ->probe() ou comme rappel. Il serait mauvais, mauvaise idée pour les utiliser dans les rappels comme ->open(). Il y a aussi un problème avec le temps de vie des objets en cas d'opérations sur les fichiers en cours d'utilisation.
    J'ai élargi ma réponse à le mentionner, je vous remercie. Si il y a d'autres raisons pour éviter de ressources gérées dans open(), merci de poster un lien.

    OriginalL'auteur

  2. 1

    En mots simples devm_kzalloc() et kzalloc() les deux sont utilisés pour l'allocation de mémoire dans le pilote de périphérique mais la différence est que si vous allouer de la mémoire par kzalloc() que vous avez pour libérer de la mémoire lorsque le cycle de vie de pilote de périphérique est terminé ou lorsqu'il est déchargé de noyau, mais si vous faites la même chose avec devm_kzalloc() vous n'avez pas besoin de s'inquiéter à propos de la libération de la mémoire,cette mémoire est libérée automatiquement par l'appareil de la bibliothèque elle-même.

    Deux d'entre eux fait exactement la même chose mais en utilisant devm_kzalloc peu de surcharge de libérer de la mémoire est libérée par les programmeurs

    Laissez-vous expliquer, en donnant l'exemple, le premier exemple en utilisant 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 ce en fonction de pxa3xx_u2d_remove(),
    kfree(u2d)(ligne 3) est là pour libérer la mémoire allouée par u2d
    voyons maintenant le même code à l'aide de 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 la fonction libre parce que le même est fait par devm_kzalloc()

    OriginalL'auteur