¿Cuál es la diferencia entre devm_kzalloc() y kzalloc() en la programación del controlador de Linux

Question

He encontrado devm_kzalloc() y kzalloc() en el controlador de dispositivo programmong. Pero no sé cuándo/dónde usar estas funciones. ¿Alguien puede especificar la importancia de estas funciones y su uso?

Answer 1

kzalloc() asigna memoria de kernel como kmalloc(), pero también inicializa a cero la memoria asignada. devm_kzalloc() es administrado kzalloc(). La memoria asignada con funciones administradas está asociada con el dispositivo. Cuando el dispositivo se desconecta del sistema o el controlador del dispositivo se descarga, esa memoria se libera automáticamente. Si se asignaron varios recursos administrados (memoria u otro recurso) para el dispositivo, el último recurso asignado se libera primero.

Los recursos administrados son muy útiles para garantizar el correcto funcionamiento del controlador tanto para la falla de inicialización en cualquier punto como para una inicialización exitosa seguida de la eliminación del dispositivo.

Tenga en cuenta que los recursos administrados (ya sea memoria u otro recurso) están destinados a ser utilizados en el código responsable de la prueba del dispositivo. En general, son una opción incorrecta para el código utilizado para abrir el dispositivo, ya que el dispositivo se puede cerrar sin desconectarse del sistema. Cerrar el dispositivo requiere liberar los recursos manualmente, lo que frustra el propósito de los recursos administrados.

La memoria asignada con kzalloc() debe liberarse con kfree(). La memoria asignada con devm_kzalloc() se libera automáticamente. Se puede liberar con devm_kfree(), pero generalmente es una señal de que la asignación de memoria administrada no es adecuada para la tarea.

Answer 2

En palabras simples, devm_kzalloc() y kzalloc() se utilizan para la asignación de memoria en el controlador del dispositivo pero la diferencia es si asigna memoria por kzalloc() que debe liberar esa memoria cuando el ciclo de vida del dispositivo finaliza o cuando se descarga desde kernel, pero si haces lo mismo con devm_kzalloc() no tienes que preocuparte de liberar memoria, esa memoria se libera automáticamente por la propia biblioteca del dispositivo.

Ambos se hace el exactamente lo mismo pero utilizando devm_kzalloc poca sobrecarga de la memoria libera se libera de los programadores

permiten explicar dando ejemplo, primer ejemplo mediante el uso 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; 
} 

En este ejemplo se puede pxa3xx_u2d_remove esto en funcion(), kfree (U2D) (línea indicada por 3) está ahí para liberar memoria asignada por U2D ahora ver el mismo código utilizando 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; 
} 

no hay kfree() a función libre debido a que el mismo se hace por devm_kzalloc()