Qual è la differenza tra devm_kzalloc() e kzalloc() nella programmazione del driver linux

Question

Ho trovato devm_kzalloc() e kzalloc() nel programma di programmazione del driver del dispositivo. Ma non so quando/dove usare queste funzioni. Qualcuno può specificare l'importanza di queste funzioni e il loro utilizzo.

Answer 1

kzalloc() alloca la memoria del kernel come kmalloc(), ma azzera anche la memoria allocata. devm_kzalloc() è gestito kzalloc(). La memoria allocata con funzioni gestite è associata al dispositivo. Quando il dispositivo viene scollegato dal sistema o il driver per il dispositivo viene scaricato, tale memoria viene liberata automaticamente. Se sono state allocate più risorse gestite (memoria o altra risorsa) per il dispositivo, la risorsa allocata per ultima viene liberata per prima.

Le risorse gestite sono molto utili per garantire il corretto funzionamento del driver sia per l'inizializzazione non riuscita in qualsiasi punto e per l'inizializzazione corretta seguita dalla rimozione del dispositivo.

Si noti che le risorse gestite (che si tratti di memoria o di altre risorse) devono essere utilizzate nel codice responsabile della verifica del dispositivo. In genere sono una scelta sbagliata per il codice utilizzato per l'apertura del dispositivo, in quanto il dispositivo può essere chiuso senza essere disconnesso dal sistema. La chiusura del dispositivo richiede la liberazione manuale delle risorse, che vanifica lo scopo delle risorse gestite.

La memoria allocata con kzalloc() deve essere liberata con kfree(). La memoria allocata con devm_kzalloc() viene liberata automaticamente. Può essere liberato con devm_kfree(), ma di solito è un segno che l'allocazione della memoria gestita non è adatta per l'attività.

Answer 2

In parole semplici devm_kzalloc() e kzalloc() vengono entrambi utilizzati per l'allocazione di memoria nel driver di periferica, ma la differenza è se si assegna memoria a kzalloc() di quella necessaria per liberare quella memoria quando il ciclo di vita di quel driver di dispositivo è terminato o quando viene scaricato dal kernel ma se si fa lo stesso con devm_kzalloc() non è necessario preoccuparsi di liberare memoria, quella memoria viene automaticamente liberata dalla libreria del dispositivo stesso.

Entrambi di loro fa esattamente la stessa cosa, ma utilizzando devm_kzalloc poco overhead di memoria liberando viene rilasciato dai programmatori

farvi spiegare dando esempio, primo esempio utilizzando 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; 
} 

In questo esempio è possibile in questo funtion pxa3xx_u2d_remove(), kfree (U2D) (linea indicata con 3) v'è per liberare memoria allocata da U2D ora vedere lo stesso codice utilizzando 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; 
} 

non c'è kfree() per funzione libera perché lo stesso è fatto da devm_kzalloc()