แแแแแจแแก แแแฎแแแก แฆแแ แฌแแ แแแแก แจแแแแแ, แแแแแกแแขแแก แฃแแแแแ แกแแขแแขแแก แแแแแแแแ แแ แฏแแฃแคแแ, แ แแแแแก แชแแแแแแแแแแก แแแฆแแแ Linux-แแก แแแ แแแจแ แแแแแแแแแ แแงแ แแ แแ แแ แแฐ-แฐแแ แขแแแแแก แแแแ , แแแแแแแแแแแก แแแขแแแฃแ แ แแแคแแ แแแชแแ แแแ แแแแก แแแแแแแแแ แแแแกแแแแก แแแแแแแแแแ แแแฉแแแแก แจแแกแแฎแแ แแ แแแแแฌแแ แแก แจแแกแแฎแแ. แแแแแแจแแ แแแฃแแ แแ แแแขแฉแแแแแ.
แแฆแกแแแแจแแแแแ, แ แแ แงแแแแ แแ แแแแแแฃแ แ แแแขแฉแ แฃแแ แงแแคแแแ แแฅแแ แจแแแกแ แฃแแแแแแแแก แแแแชแแแขแแแแ, แแ แช แแ แแ แแแฉแ แแ แแแแขแแแชแแแฃแแ. แแก แคแแฅแขแ แชแฎแแแงแแคแก, แแฃ แ แแขแแ แแแแฅแชแ แแ แแ แแ แแ-แฐแแ แขแแแแ แแกแ แแแแชแ แแ, แ แแแแแ แแแฃแ แแแแแแแแ, แ แแก แแแแแแแแแแแแ แแแแแแแแ แแแ, แแฃ แแแขแฉแแแ แแแแขแแแชแแ แจแแแกแ แฃแแแแแแแแก แแแแ . แฃแแแแแแฎแแแแแ, แแกแแแ แแชแฎแแแแแแแแ, แ แแ แแแแ แแแแแแ แจแแแขแงแแแแแแ แจแแชแแแแแก แจแแกแแฎแแ แแ แแ แแแฃแจแแแแแแแ แแแขแฉแแแก Git-แจแ แฌแแกแแแแก, แแแแ แแ แแแฃแ แแแแแแแแ แ แแก แแแแแแแแแแแแ แแกแแแ แ แแแแฃแ แแ แแ แ แแแแแแแ แจแแ แก แจแแแซแแแแ แฌแแกแฃแแแงแแแแ.
แกแฃแ 2020 แฌแแแก แแแแแกแขแแจแ แแแแแแแฃแ แ แแแกแแแแ แแแแแแแ [แแ.แคแแกแขแแ แแแชแฃแแแ] ะธ [แแ.แคแแกแขแแ แแแชแฃแแแ] (แฌแแ แแแ แฏแแแแก แแแแแแกแแแ) แแแแแแแแแ แฎแฃแแ แแแขแฉแ: แแ แ แกแฌแแ แ (1, 2) แแ แกแแแ แคแแ แฃแแ แจแแชแแแแแก แจแแแชแแแแ (1, 2, 3), แ แแช แฅแแแแก แแแ แแแแแก แแแฌแงแแแแแแแแกแแแแก. แแแแแแฃแแ แแแฉแ แจแแแชแแแแ แแฎแแแแ 1-4 แฎแแแก แแแแก. แแชแแแ แ แแแฉแแแแก แแแแแแ แ แแแแ แแงแ แแก, แ แแ แแแฎแกแแแ แแแแก แแแแแแแแก แแแแแกแฌแแ แแแแ แจแแแซแแแแ แจแแฅแแแแก แแ แแแแ แแแแแกแฃแคแแแ แแแฃแชแแแแแแแก แแแแแแแ แแแแ. แแ แแ แแแแ แแก แจแแแแแ, แแแคแแ แแแชแแ แแแแแแแแแ แแแ แแแแก แแแแแแแแแ แแแก แฌแแแแแแแแแแ, แแแแแฎแแแแ แแแฃแชแแแแแแแก แฎแแแจแแฌแงแแแแก แจแแกแแซแแแแแแแ แแแฎแกแแแ แแแแก แแแแแแแแก แขแ แแแแแแฃแ แ แแแแแกแฌแแ แแแแก แกแแคแแ แฅแแแจ, แแแแ แแ แแ แแคแแ แ แแงแ แแแแฅแแแแ แแแแแ แแแขแฉแแแแก แแแแแแแแแก แฌแแแ แแชแแแแแแแแแ.
แแแ แแแแแ แแ แแแแแแฃแ แแ แแแขแฉแแ แแแแคแแฅแกแแ แ แแแฎแกแแแ แแแแก แแแแแแแ kfree()-แแ แแแ แแก แแแแแขแแแแ, แจแแชแแแแแก แจแแแแฎแแแแแจแ แแแแขแ แแแแก แแแแ แฃแแแแแแแ, แแแแ แแ แจแแฅแแแ แแแ แแแแแ แแแฎแกแแแ แแแแก แแแแแจแ แฌแแแแแแกแแแแก แแแกแ แแแแแแแกแฃแคแแแแแก แจแแแแแ (แแแแแงแแแแแแก แจแแแแแ แแแแแกแฃแคแแแ). แแก แแแขแฉแ แฃแแ แงแ แแแแฎแแแ แแ (Jiri Slaby), แ แแแแแแแช แแแแแแแแ แแ แแแแแแ แแ แแฆแแแจแแ, แ แแ แแ แแ แฌแแแก แฌแแ แแแฆแแชแแ แฃแแแ แกแชแแแ แแกแแแแกแ แชแแแแแแแแก แจแแแแแแแแแ แแ แแก แแแแแแแแ แแแแแ แแฅแแ แแแฆแแแฃแแ, แแแแ แแ แจแแแแแ แแแฃแฅแแแ แแแฃแชแแแแแแแก แแแ แแแแแแก แแแแแแแแก แจแแแแแ. > p2 = p1[n] = kmalloc_array(64, sizeof(u16), GFP_KERNEL); > - แแฃ (!p2) แแแแ แฃแแแแแ -ENOMEM; > + แแฃ (!p2) { > + kfree(p1); > + แแแแ แฃแแแแ -ENOMEM; > + }
แแแแ แ แแแฉแ แแกแแแ แจแแแชแแแแ แแแ แแแแแก แแแแแงแแแแแแก แจแแแแแ แแแแแกแฃแคแแแ แแ แแแแแแแกแแแแก. แแแแแแแแฃแแ แแแขแฉแ แแ แแแแฆแแก แแแแฎแแแ แแ (แแแ แแแ แแแแขแแ แแ), แ แแแแแแแช แฃแแ แงแ แแแขแฉแ list_add_tail-แแแ แแแแแแจแแ แแแฃแแ แกแฎแแ แแ แแแแแแแก แแแแ, แแแแ แแ แแแ แจแแแแฉแแแ, แ แแ "chdev" แแแฉแแแแแแแแ แจแแแซแแแแ แแแแแแแแกแฃแคแแแแก put_device แคแฃแแฅแชแแแจแ, แ แแแแแแช แแแแแแงแแแแแ แฅแแแแแ แแแ แจแ. dev_err (&chdev -> dev..). แแฃแแชแ, แแแขแฉแ แแ แแฅแแ แแแฆแแแฃแแ, แแฃแแชแ แแแฃแชแแแแแแแกแแแ แแแแแแจแแ แแแฃแแ แแแแแแแแแก แแแแ. if (ret < 0) { + put_device(&chdev->dev); dev_err(&chdev->dev, DRV_NAME ": kfifo_alloc แฉแแแจแแแ\n"); ret = -ENOMEM; goto err_fifo;
แแแกแแแ แแแขแฉแ แแกแแแ แแ แแฅแแ แแแฆแแแฃแแ แจแแแแแฎแแแแแก แแแแ (Miquel Raynal) แกแฎแแ แจแแชแแแแแก แแแแ, แ แแแแแแช แแ แแงแ แแแแแแจแแ แแแฃแแ แแแฃแชแแแแแแแกแแแ (แแ แแแแ แแแ แ pdev-แแกแแแแก แแแกแแงแแแแแแแ). if (!window->virt) { printk(KERN_ERR MOD_NAME ": ioremap(%08lx, %08lx) แฉแแแจแแแ\n", window->phys, window->size); + pci_dev_put(pdev); แแแแแแแแ; } ... if (!map) { printk(KERN_ERR MOD_NAME ": kmalloc แฉแแแจแแแ"); + pci_dev_put(pdev); แแแแแแแแ; } memset(map, 0, sizeof(*map)); ... if (mtd_device_register(map->mtd, NULL, 0)) { map_destroy(map->mtd); แ แฃแแ->แแขแ = NULL; + pci_dev_put(pdev); แแแแแแแแ; }
แกแแแแขแแ แแกแแ, แ แแ แแแแแแแแ แแแแแ แแแ แแฃแแแแแแแ, แ แแ 4-แแแ 5-แก แฐแฅแแแแ แแ แแแแแแแแ, แแแแ แแ แแแแแแแแ แแแแ แแแแแ แแแฃแจแแแก แจแแชแแแแ แแ แแ แ-แแ แ แแ แแแแแแฃแ แแแฉแจแ, แแแแ แแแ แแ, แกแฌแแ แ แแแแแกแฌแแ แแแ แจแแกแแแแแแแก, แแแแแกแฃแคแแแ แฌแแ แแแฅแแแแก แจแแแแแ แแแฎแกแแแ แแแแก แแแแแงแแแแแแก แแแกแแแแแแแแ แแแ แแแแแแก แแแ แแจแ. err = pci_request_mem_regions (pdev, nitrox_driver_name); if (er) { pci_disable_device(pdev); + dev_err(&pdev->dev, โแแแ แแแฎแแ แฎแแ แแแ แ แแแแแแแแแก แแแแฎแแแแ!\nโ); แแแแ แฃแแแแแก แจแแชแแแแ; }
แฌแงแแ แ: opennet.ru