tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

[netdrvr] Fix register_netdev() races in older ISA net drivers

authored by

and committed by
Jeff Garzik b1fc5505 88d7bd8c

+156 -228
+6 -10
drivers/net/3c503.c
··· 171 171 err = do_el2_probe(dev); 172 172 if (err) 173 173 goto out; 174 - err = register_netdev(dev); 175 - if (err) 176 - goto out1; 177 174 return dev; 178 - out1: 179 - cleanup_card(dev); 180 175 out: 181 176 free_netdev(dev); 182 177 return ERR_PTR(err); ··· 350 355 #ifdef CONFIG_NET_POLL_CONTROLLER 351 356 dev->poll_controller = ei_poll; 352 357 #endif 358 + 359 + retval = register_netdev(dev); 360 + if (retval) 361 + goto out1; 353 362 354 363 if (dev->mem_start) 355 364 printk("%s: %s - %dkB RAM, 8kB shared mem window at %#6lx-%#6lx.\n", ··· 714 715 dev->base_addr = io[this_dev]; 715 716 dev->mem_end = xcvr[this_dev]; /* low 4bits = xcvr sel. */ 716 717 if (do_el2_probe(dev) == 0) { 717 - if (register_netdev(dev) == 0) { 718 - dev_el2[found++] = dev; 719 - continue; 720 - } 721 - cleanup_card(dev); 718 + dev_el2[found++] = dev; 719 + continue; 722 720 } 723 721 free_netdev(dev); 724 722 printk(KERN_WARNING "3c503.c: No 3c503 card found (i/o = 0x%x).\n", io[this_dev]);
+6 -6
drivers/net/3c515.c
··· 365 365 #endif /* __ISAPNP__ */ 366 366 367 367 static struct net_device *corkscrew_scan(int unit); 368 - static void corkscrew_setup(struct net_device *dev, int ioaddr, 368 + static int corkscrew_setup(struct net_device *dev, int ioaddr, 369 369 struct pnp_dev *idev, int card_number); 370 370 static int corkscrew_open(struct net_device *dev); 371 371 static void corkscrew_timer(unsigned long arg); ··· 539 539 printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n", 540 540 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000)); 541 541 /* irq = inw(ioaddr + 0x2002) & 15; */ /* Use the irq from isapnp */ 542 - corkscrew_setup(dev, ioaddr, idev, cards_found++); 543 542 SET_NETDEV_DEV(dev, &idev->dev); 544 543 pnp_cards++; 545 - err = register_netdev(dev); 544 + err = corkscrew_setup(dev, ioaddr, idev, cards_found++); 546 545 if (!err) 547 546 return dev; 548 547 cleanup_card(dev); ··· 557 558 558 559 printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n", 559 560 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000)); 560 - corkscrew_setup(dev, ioaddr, NULL, cards_found++); 561 - err = register_netdev(dev); 561 + err = corkscrew_setup(dev, ioaddr, NULL, cards_found++); 562 562 if (!err) 563 563 return dev; 564 564 cleanup_card(dev); ··· 566 568 return NULL; 567 569 } 568 570 569 - static void corkscrew_setup(struct net_device *dev, int ioaddr, 571 + static int corkscrew_setup(struct net_device *dev, int ioaddr, 570 572 struct pnp_dev *idev, int card_number) 571 573 { 572 574 struct corkscrew_private *vp = netdev_priv(dev); ··· 689 691 dev->get_stats = &corkscrew_get_stats; 690 692 dev->set_multicast_list = &set_rx_mode; 691 693 dev->ethtool_ops = &netdev_ethtool_ops; 694 + 695 + return register_netdev(dev); 692 696 } 693 697 694 698
+7 -11
drivers/net/3c523.c
··· 572 572 dev->flags&=~IFF_MULTICAST; /* Multicast doesn't work */ 573 573 #endif 574 574 575 + retval = register_netdev(dev); 576 + if (retval) 577 + goto err_out; 578 + 575 579 return 0; 576 580 err_out: 577 581 mca_set_adapter_procfn(slot, NULL, NULL); ··· 604 600 err = do_elmc_probe(dev); 605 601 if (err) 606 602 goto out; 607 - err = register_netdev(dev); 608 - if (err) 609 - goto out1; 610 603 return dev; 611 - out1: 612 - cleanup_card(dev); 613 604 out: 614 605 free_netdev(dev); 615 606 return ERR_PTR(err); ··· 1287 1288 dev->irq=irq[this_dev]; 1288 1289 dev->base_addr=io[this_dev]; 1289 1290 if (do_elmc_probe(dev) == 0) { 1290 - if (register_netdev(dev) == 0) { 1291 - dev_elmc[this_dev] = dev; 1292 - found++; 1293 - continue; 1294 - } 1295 - cleanup_card(dev); 1291 + dev_elmc[this_dev] = dev; 1292 + found++; 1293 + continue; 1296 1294 } 1297 1295 free_netdev(dev); 1298 1296 if (io[this_dev]==0)
+9 -10
drivers/net/ac3200.c
··· 146 146 err = do_ac3200_probe(dev); 147 147 if (err) 148 148 goto out; 149 - err = register_netdev(dev); 150 - if (err) 151 - goto out1; 152 149 return dev; 153 - out1: 154 - cleanup_card(dev); 155 150 out: 156 151 free_netdev(dev); 157 152 return ERR_PTR(err); ··· 268 273 dev->poll_controller = ei_poll; 269 274 #endif 270 275 NS8390_init(dev, 0); 276 + 277 + retval = register_netdev(dev); 278 + if (retval) 279 + goto out2; 271 280 return 0; 281 + out2: 282 + if (ei_status.reg0) 283 + iounmap((void *)dev->mem_start); 272 284 out1: 273 285 free_irq(dev->irq, dev); 274 286 out: ··· 394 392 dev->base_addr = io[this_dev]; 395 393 dev->mem_start = mem[this_dev]; /* Currently ignored by driver */ 396 394 if (do_ac3200_probe(dev) == 0) { 397 - if (register_netdev(dev) == 0) { 398 - dev_ac32[found++] = dev; 399 - continue; 400 - } 401 - cleanup_card(dev); 395 + dev_ac32[found++] = dev; 396 + continue; 402 397 } 403 398 free_netdev(dev); 404 399 printk(KERN_WARNING "ac3200.c: No ac3200 card found (i/o = 0x%x).\n", io[this_dev]);
+6 -13
drivers/net/cs89x0.c
··· 319 319 } 320 320 if (err) 321 321 goto out; 322 - err = register_netdev(dev); 323 - if (err) 324 - goto out1; 325 322 return dev; 326 - out1: 327 - outw(PP_ChipID, dev->base_addr + ADD_PORT); 328 - release_region(dev->base_addr, NETCARD_IO_EXTENT); 329 323 out: 330 324 free_netdev(dev); 331 325 printk(KERN_WARNING "cs89x0: no cs8900 or cs8920 detected. Be sure to disable PnP with SETUP\n"); ··· 729 735 printk("\n"); 730 736 if (net_debug) 731 737 printk("cs89x0_probe1() successful\n"); 738 + 739 + retval = register_netdev(dev); 740 + if (retval) 741 + goto out3; 732 742 return 0; 743 + out3: 744 + outw(PP_ChipID, dev->base_addr + ADD_PORT); 733 745 out2: 734 746 release_region(ioaddr & ~3, NETCARD_IO_EXTENT); 735 747 out1: ··· 1831 1831 if (ret) 1832 1832 goto out; 1833 1833 1834 - if (register_netdev(dev) != 0) { 1835 - printk(KERN_ERR "cs89x0.c: No card found at 0x%x\n", io); 1836 - ret = -ENXIO; 1837 - outw(PP_ChipID, dev->base_addr + ADD_PORT); 1838 - release_region(dev->base_addr, NETCARD_IO_EXTENT); 1839 - goto out; 1840 - } 1841 1834 dev_cs89x0 = dev; 1842 1835 return 0; 1843 1836 out:
+5 -10
drivers/net/e2100.c
··· 162 162 err = do_e2100_probe(dev); 163 163 if (err) 164 164 goto out; 165 - err = register_netdev(dev); 166 - if (err) 167 - goto out1; 168 165 return dev; 169 - out1: 170 - cleanup_card(dev); 171 166 out: 172 167 free_netdev(dev); 173 168 return ERR_PTR(err); ··· 281 286 #endif 282 287 NS8390_init(dev, 0); 283 288 289 + retval = register_netdev(dev); 290 + if (retval) 291 + goto out; 284 292 return 0; 285 293 out: 286 294 release_region(ioaddr, E21_IO_EXTENT); ··· 451 453 dev->mem_start = mem[this_dev]; 452 454 dev->mem_end = xcvr[this_dev]; /* low 4bits = xcvr sel. */ 453 455 if (do_e2100_probe(dev) == 0) { 454 - if (register_netdev(dev) == 0) { 455 - dev_e21[found++] = dev; 456 - continue; 457 - } 458 - cleanup_card(dev); 456 + dev_e21[found++] = dev; 457 + continue; 459 458 } 460 459 free_netdev(dev); 461 460 printk(KERN_WARNING "e2100.c: No E2100 card found (i/o = 0x%x).\n", io[this_dev]);
+10 -11
drivers/net/eepro.c
··· 600 600 err = do_eepro_probe(dev); 601 601 if (err) 602 602 goto out; 603 - err = register_netdev(dev); 604 - if (err) 605 - goto out1; 606 603 return dev; 607 - out1: 608 - release_region(dev->base_addr, EEPRO_IO_EXTENT); 609 604 out: 610 605 free_netdev(dev); 611 606 return ERR_PTR(err); ··· 753 758 int i; 754 759 struct eepro_local *lp; 755 760 int ioaddr = dev->base_addr; 761 + int err; 756 762 757 763 /* Grab the region so we can find another board if autoIRQ fails. */ 758 764 if (!request_region(ioaddr, EEPRO_IO_EXTENT, DRV_NAME)) { ··· 869 873 870 874 /* reset 82595 */ 871 875 eepro_reset(ioaddr); 876 + 877 + err = register_netdev(dev); 878 + if (err) 879 + goto err; 872 880 return 0; 873 881 exit: 882 + err = -ENODEV; 883 + err: 874 884 release_region(dev->base_addr, EEPRO_IO_EXTENT); 875 - return -ENODEV; 885 + return err; 876 886 } 877 887 878 888 /* Open/initialize the board. This is called (in the current kernel) ··· 1836 1834 dev->irq = irq[i]; 1837 1835 1838 1836 if (do_eepro_probe(dev) == 0) { 1839 - if (register_netdev(dev) == 0) { 1840 - dev_eepro[n_eepro++] = dev; 1841 - continue; 1842 - } 1843 - release_region(dev->base_addr, EEPRO_IO_EXTENT); 1837 + dev_eepro[n_eepro++] = dev; 1838 + continue; 1844 1839 } 1845 1840 free_netdev(dev); 1846 1841 break;
+5 -7
drivers/net/eexpress.c
··· 436 436 netdev_boot_setup_check(dev); 437 437 438 438 err = do_express_probe(dev); 439 - if (!err) { 440 - err = register_netdev(dev); 441 - if (!err) 442 - return dev; 443 - } 439 + if (!err) 440 + return dev; 444 441 free_netdev(dev); 445 442 return ERR_PTR(err); 446 443 } ··· 1202 1205 dev->set_multicast_list = &eexp_set_multicast; 1203 1206 dev->tx_timeout = eexp_timeout; 1204 1207 dev->watchdog_timeo = 2*HZ; 1205 - return 0; 1208 + 1209 + return register_netdev(dev); 1206 1210 } 1207 1211 1208 1212 /* ··· 1714 1716 break; 1715 1717 printk(KERN_NOTICE "eexpress.c: Module autoprobe not recommended, give io=xx.\n"); 1716 1718 } 1717 - if (do_express_probe(dev) == 0 && register_netdev(dev) == 0) { 1719 + if (do_express_probe(dev) == 0) { 1718 1720 dev_eexp[this_dev] = dev; 1719 1721 found++; 1720 1722 continue;
+6 -10
drivers/net/es3210.c
··· 177 177 err = do_es_probe(dev); 178 178 if (err) 179 179 goto out; 180 - err = register_netdev(dev); 181 - if (err) 182 - goto out1; 183 180 return dev; 184 - out1: 185 - cleanup_card(dev); 186 181 out: 187 182 free_netdev(dev); 188 183 return ERR_PTR(err); ··· 305 310 dev->poll_controller = ei_poll; 306 311 #endif 307 312 NS8390_init(dev, 0); 313 + 314 + retval = register_netdev(dev); 315 + if (retval) 316 + goto out1; 308 317 return 0; 309 318 out1: 310 319 free_irq(dev->irq, dev); ··· 444 445 dev->base_addr = io[this_dev]; 445 446 dev->mem_start = mem[this_dev]; 446 447 if (do_es_probe(dev) == 0) { 447 - if (register_netdev(dev) == 0) { 448 - dev_es3210[found++] = dev; 449 - continue; 450 - } 451 - cleanup_card(dev); 448 + dev_es3210[found++] = dev; 449 + continue; 452 450 } 453 451 free_netdev(dev); 454 452 printk(KERN_WARNING "es3210.c: No es3210 card found (i/o = 0x%x).\n", io[this_dev]);
+8 -12
drivers/net/eth16i.c
··· 473 473 err = do_eth16i_probe(dev); 474 474 if (err) 475 475 goto out; 476 - err = register_netdev(dev); 477 - if (err) 478 - goto out1; 479 476 return dev; 480 - out1: 481 - free_irq(dev->irq, dev); 482 - release_region(dev->base_addr, ETH16I_IO_EXTENT); 483 477 out: 484 478 free_netdev(dev); 485 479 return ERR_PTR(err); ··· 563 569 dev->tx_timeout = eth16i_timeout; 564 570 dev->watchdog_timeo = TX_TIMEOUT; 565 571 spin_lock_init(&lp->lock); 572 + 573 + retval = register_netdev(dev); 574 + if (retval) 575 + goto out1; 566 576 return 0; 577 + out1: 578 + free_irq(dev->irq, dev); 567 579 out: 568 580 release_region(ioaddr, ETH16I_IO_EXTENT); 569 581 return retval; ··· 1462 1462 } 1463 1463 1464 1464 if (do_eth16i_probe(dev) == 0) { 1465 - if (register_netdev(dev) == 0) { 1466 - dev_eth16i[found++] = dev; 1467 - continue; 1468 - } 1469 - free_irq(dev->irq, dev); 1470 - release_region(dev->base_addr, ETH16I_IO_EXTENT); 1465 + dev_eth16i[found++] = dev; 1466 + continue; 1471 1467 } 1472 1468 printk(KERN_WARNING "eth16i.c No Eth16i card found (i/o = 0x%x).\n", 1473 1469 io[this_dev]);
+5 -10
drivers/net/hp-plus.c
··· 159 159 err = do_hpp_probe(dev); 160 160 if (err) 161 161 goto out; 162 - err = register_netdev(dev); 163 - if (err) 164 - goto out1; 165 162 return dev; 166 - out1: 167 - cleanup_card(dev); 168 163 out: 169 164 free_netdev(dev); 170 165 return ERR_PTR(err); ··· 266 271 /* Leave the 8390 and HP chip reset. */ 267 272 outw(inw(ioaddr + HPP_OPTION) & ~EnableIRQ, ioaddr + HPP_OPTION); 268 273 274 + retval = register_netdev(dev); 275 + if (retval) 276 + goto out; 269 277 return 0; 270 278 out: 271 279 release_region(ioaddr, HP_IO_EXTENT); ··· 461 463 dev->irq = irq[this_dev]; 462 464 dev->base_addr = io[this_dev]; 463 465 if (do_hpp_probe(dev) == 0) { 464 - if (register_netdev(dev) == 0) { 465 - dev_hpp[found++] = dev; 466 - continue; 467 - } 468 - cleanup_card(dev); 466 + dev_hpp[found++] = dev; 467 + continue; 469 468 } 470 469 free_netdev(dev); 471 470 printk(KERN_WARNING "hp-plus.c: No HP-Plus card found (i/o = 0x%x).\n", io[this_dev]);
+7 -10
drivers/net/hp.c
··· 123 123 err = do_hp_probe(dev); 124 124 if (err) 125 125 goto out; 126 - err = register_netdev(dev); 127 - if (err) 128 - goto out1; 129 126 return dev; 130 - out1: 131 - cleanup_card(dev); 132 127 out: 133 128 free_netdev(dev); 134 129 return ERR_PTR(err); ··· 222 227 ei_status.block_output = &hp_block_output; 223 228 hp_init_card(dev); 224 229 230 + retval = register_netdev(dev); 231 + if (retval) 232 + goto out1; 225 233 return 0; 234 + out1: 235 + free_irq(dev->irq, dev); 226 236 out: 227 237 release_region(ioaddr, HP_IO_EXTENT); 228 238 return retval; ··· 432 432 dev->irq = irq[this_dev]; 433 433 dev->base_addr = io[this_dev]; 434 434 if (do_hp_probe(dev) == 0) { 435 - if (register_netdev(dev) == 0) { 436 - dev_hp[found++] = dev; 437 - continue; 438 - } 439 - cleanup_card(dev); 435 + dev_hp[found++] = dev; 436 + continue; 440 437 } 441 438 free_netdev(dev); 442 439 printk(KERN_WARNING "hp.c: No HP card found (i/o = 0x%x).\n", io[this_dev]);
+15 -26
drivers/net/hp100.c
··· 417 417 if (err) 418 418 goto out; 419 419 420 - err = register_netdev(dev); 421 - if (err) 422 - goto out1; 423 420 return dev; 424 - out1: 425 - release_region(dev->base_addr, HP100_REGION_SIZE); 426 421 out: 427 422 free_netdev(dev); 428 423 return ERR_PTR(err); ··· 771 776 printk("Warning! Link down.\n"); 772 777 } 773 778 779 + err = register_netdev(dev); 780 + if (err) 781 + goto out3; 782 + 774 783 return 0; 784 + out3: 785 + if (local_mode == 1) 786 + pci_free_consistent(lp->pci_dev, MAX_RINGSIZE + 0x0f, 787 + lp->page_vaddr_algn, 788 + virt_to_whatever(dev, lp->page_vaddr_algn)); 789 + if (mem_ptr_virt) 790 + iounmap(mem_ptr_virt); 775 791 out2: 776 792 release_region(ioaddr, HP100_REGION_SIZE); 777 793 out1: 778 - return -ENODEV; 794 + return err; 779 795 } 780 796 781 797 /* This procedure puts the card into a stable init state */ ··· 2881 2875 if (err) 2882 2876 goto out1; 2883 2877 2884 - err = register_netdev(dev); 2885 - if (err) 2886 - goto out2; 2887 - 2888 2878 #ifdef HP100_DEBUG 2889 2879 printk("hp100: %s: EISA adapter found at 0x%x\n", dev->name, 2890 2880 dev->base_addr); 2891 2881 #endif 2892 2882 gendev->driver_data = dev; 2893 2883 return 0; 2894 - out2: 2895 - release_region(dev->base_addr, HP100_REGION_SIZE); 2896 2884 out1: 2897 2885 free_netdev(dev); 2898 2886 return err; ··· 2951 2951 err = hp100_probe1(dev, ioaddr, HP100_BUS_PCI, pdev); 2952 2952 if (err) 2953 2953 goto out1; 2954 - err = register_netdev(dev); 2955 - if (err) 2956 - goto out2; 2957 2954 2958 2955 #ifdef HP100_DEBUG 2959 2956 printk("hp100: %s: PCI adapter found at 0x%x\n", dev->name, ioaddr); 2960 2957 #endif 2961 2958 pci_set_drvdata(pdev, dev); 2962 2959 return 0; 2963 - out2: 2964 - release_region(dev->base_addr, HP100_REGION_SIZE); 2965 2960 out1: 2966 2961 free_netdev(dev); 2967 2962 out0: ··· 3027 3032 SET_MODULE_OWNER(dev); 3028 3033 3029 3034 err = hp100_isa_probe(dev, hp100_port[i]); 3030 - if (!err) { 3031 - err = register_netdev(dev); 3032 - if (!err) 3033 - hp100_devlist[cards++] = dev; 3034 - else 3035 - release_region(dev->base_addr, HP100_REGION_SIZE); 3036 - } 3037 - 3038 - if (err) 3035 + if (!err) 3036 + hp100_devlist[cards++] = dev; 3037 + else 3039 3038 free_netdev(dev); 3040 3039 } 3041 3040
+10 -10
drivers/net/isa-skeleton.c
··· 176 176 err = do_netcard_probe(dev); 177 177 if (err) 178 178 goto out; 179 - err = register_netdev(dev); 180 - if (err) 181 - goto out1; 182 179 return dev; 183 - out1: 184 - cleanup_card(dev); 185 180 out: 186 181 free_netdev(dev); 187 182 return ERR_PTR(err); ··· 311 316 312 317 dev->tx_timeout = &net_tx_timeout; 313 318 dev->watchdog_timeo = MY_TX_TIMEOUT; 319 + 320 + err = register_netdev(dev); 321 + if (err) 322 + goto out2; 314 323 return 0; 324 + out2: 325 + #ifdef jumpered_dma 326 + free_dma(dev->dma); 327 + #endif 315 328 out1: 316 329 #ifdef jumpered_interrupts 317 330 free_irq(dev->irq, dev); ··· 694 691 dev->dma = dma; 695 692 dev->mem_start = mem; 696 693 if (do_netcard_probe(dev) == 0) { 697 - if (register_netdev(dev) == 0) 698 - this_device = dev; 699 - return 0; 700 - } 701 - cleanup_card(dev); 694 + this_device = dev; 695 + return 0; 702 696 } 703 697 free_netdev(dev); 704 698 return -ENXIO;
+5 -10
drivers/net/lance.c
··· 356 356 dev->base_addr = io[this_dev]; 357 357 dev->dma = dma[this_dev]; 358 358 if (do_lance_probe(dev) == 0) { 359 - if (register_netdev(dev) == 0) { 360 - dev_lance[found++] = dev; 361 - continue; 362 - } 363 - cleanup_card(dev); 359 + dev_lance[found++] = dev; 360 + continue; 364 361 } 365 362 free_netdev(dev); 366 363 break; ··· 445 448 err = do_lance_probe(dev); 446 449 if (err) 447 450 goto out; 448 - err = register_netdev(dev); 449 - if (err) 450 - goto out1; 451 451 return dev; 452 - out1: 453 - cleanup_card(dev); 454 452 out: 455 453 free_netdev(dev); 456 454 return ERR_PTR(err); ··· 716 724 dev->tx_timeout = lance_tx_timeout; 717 725 dev->watchdog_timeo = TX_TIMEOUT; 718 726 727 + err = register_netdev(dev); 728 + if (err) 729 + goto out_dma; 719 730 return 0; 720 731 out_dma: 721 732 if (dev->dma != 4)
+9 -10
drivers/net/lne390.c
··· 167 167 err = do_lne390_probe(dev); 168 168 if (err) 169 169 goto out; 170 - err = register_netdev(dev); 171 - if (err) 172 - goto out1; 173 170 return dev; 174 - out1: 175 - cleanup_card(dev); 176 171 out: 177 172 free_netdev(dev); 178 173 return ERR_PTR(err); ··· 291 296 dev->poll_controller = ei_poll; 292 297 #endif 293 298 NS8390_init(dev, 0); 299 + 300 + ret = register_netdev(dev); 301 + if (ret) 302 + goto unmap; 294 303 return 0; 304 + unmap: 305 + if (ei_status.reg0) 306 + iounmap((void *)dev->mem_start); 295 307 cleanup: 296 308 free_irq(dev->irq, dev); 297 309 return ret; ··· 428 426 dev->base_addr = io[this_dev]; 429 427 dev->mem_start = mem[this_dev]; 430 428 if (do_lne390_probe(dev) == 0) { 431 - if (register_netdev(dev) == 0) { 432 - dev_lne[found++] = dev; 433 - continue; 434 - } 435 - cleanup_card(dev); 429 + dev_lne[found++] = dev; 430 + continue; 436 431 } 437 432 free_netdev(dev); 438 433 printk(KERN_WARNING "lne390.c: No LNE390 card found (i/o = 0x%x).\n", io[this_dev]);
+8 -11
drivers/net/ne-h8300.c
··· 180 180 err = do_ne_probe(dev); 181 181 if (err) 182 182 goto out; 183 - err = register_netdev(dev); 184 - if (err) 185 - goto out1; 186 183 return dev; 187 - out1: 188 - cleanup_card(dev); 189 184 out: 190 185 free_netdev(dev); 191 186 return ERR_PTR(err); ··· 320 325 dev->poll_controller = ei_poll; 321 326 #endif 322 327 NS8390_init(dev, 0); 323 - return 0; 324 328 329 + ret = register_netdev(dev); 330 + if (ret) 331 + goto out_irq; 332 + return 0; 333 + out_irq: 334 + free_irq(dev->irq, dev); 325 335 err_out: 326 336 release_region(ioaddr, NE_IO_EXTENT); 327 337 return ret; ··· 633 633 err = init_reg_offset(dev, dev->base_addr); 634 634 if (!err) { 635 635 if (do_ne_probe(dev) == 0) { 636 - if (register_netdev(dev) == 0) { 637 - dev_ne[found++] = dev; 638 - continue; 639 - } 640 - cleanup_card(dev); 636 + dev_ne[found++] = dev; 637 + continue; 641 638 } 642 639 } 643 640 free_netdev(dev);
+8 -10
drivers/net/ne.c
··· 229 229 err = do_ne_probe(dev); 230 230 if (err) 231 231 goto out; 232 - err = register_netdev(dev); 233 - if (err) 234 - goto out1; 235 232 return dev; 236 - out1: 237 - cleanup_card(dev); 238 233 out: 239 234 free_netdev(dev); 240 235 return ERR_PTR(err); ··· 529 534 dev->poll_controller = ei_poll; 530 535 #endif 531 536 NS8390_init(dev, 0); 537 + 538 + ret = register_netdev(dev); 539 + if (ret) 540 + goto out_irq; 532 541 return 0; 533 542 543 + out_irq: 544 + free_irq(dev->irq, dev); 534 545 err_out: 535 546 release_region(ioaddr, NE_IO_EXTENT); 536 547 return ret; ··· 827 826 dev->mem_end = bad[this_dev]; 828 827 dev->base_addr = io[this_dev]; 829 828 if (do_ne_probe(dev) == 0) { 830 - if (register_netdev(dev) == 0) { 831 - dev_ne[found++] = dev; 832 - continue; 833 - } 834 - cleanup_card(dev); 829 + dev_ne[found++] = dev; 830 + continue; 835 831 } 836 832 free_netdev(dev); 837 833 if (found)
+9 -10
drivers/net/ne2.c
··· 301 301 err = do_ne2_probe(dev); 302 302 if (err) 303 303 goto out; 304 - err = register_netdev(dev); 305 - if (err) 306 - goto out1; 307 304 return dev; 308 - out1: 309 - cleanup_card(dev); 310 305 out: 311 306 free_netdev(dev); 312 307 return ERR_PTR(err); ··· 512 517 dev->poll_controller = ei_poll; 513 518 #endif 514 519 NS8390_init(dev, 0); 520 + 521 + retval = register_netdev(dev); 522 + if (retval) 523 + goto out1; 515 524 return 0; 525 + out1: 526 + mca_set_adapter_procfn( ei_status.priv, NULL, NULL); 527 + free_irq(dev->irq, dev); 516 528 out: 517 529 release_region(base_addr, NE_IO_EXTENT); 518 530 return retval; ··· 800 798 dev->mem_end = bad[this_dev]; 801 799 dev->base_addr = io[this_dev]; 802 800 if (do_ne2_probe(dev) == 0) { 803 - if (register_netdev(dev) == 0) { 804 - dev_ne[found++] = dev; 805 - continue; 806 - } 807 - cleanup_card(dev); 801 + dev_ne[found++] = dev; 802 + continue; 808 803 } 809 804 free_netdev(dev); 810 805 break;
+5 -10
drivers/net/smc-ultra.c
··· 194 194 err = do_ultra_probe(dev); 195 195 if (err) 196 196 goto out; 197 - err = register_netdev(dev); 198 - if (err) 199 - goto out1; 200 197 return dev; 201 - out1: 202 - cleanup_card(dev); 203 198 out: 204 199 free_netdev(dev); 205 200 return ERR_PTR(err); ··· 320 325 #endif 321 326 NS8390_init(dev, 0); 322 327 328 + retval = register_netdev(dev); 329 + if (retval) 330 + goto out; 323 331 return 0; 324 332 out: 325 333 release_region(ioaddr, ULTRA_IO_EXTENT); ··· 581 583 dev->irq = irq[this_dev]; 582 584 dev->base_addr = io[this_dev]; 583 585 if (do_ultra_probe(dev) == 0) { 584 - if (register_netdev(dev) == 0) { 585 - dev_ultra[found++] = dev; 586 - continue; 587 - } 588 - cleanup_card(dev); 586 + dev_ultra[found++] = dev; 587 + continue; 589 588 } 590 589 free_netdev(dev); 591 590 printk(KERN_WARNING "smc-ultra.c: No SMC Ultra card found (i/o = 0x%x).\n", io[this_dev]);
+7 -11
drivers/net/wd.c
··· 149 149 err = do_wd_probe(dev); 150 150 if (err) 151 151 goto out; 152 - err = register_netdev(dev); 153 - if (err) 154 - goto out1; 155 152 return dev; 156 - out1: 157 - cleanup_card(dev); 158 153 out: 159 154 free_netdev(dev); 160 155 return ERR_PTR(err); ··· 159 164 static int __init wd_probe1(struct net_device *dev, int ioaddr) 160 165 { 161 166 int i; 167 + int err; 162 168 int checksum = 0; 163 169 int ancient = 0; /* An old card without config registers. */ 164 170 int word16 = 0; /* 0 = 8 bit, 1 = 16 bit */ ··· 352 356 outb(inb(ioaddr+4)|0x80, ioaddr+4); 353 357 #endif 354 358 355 - return 0; 359 + err = register_netdev(dev); 360 + if (err) 361 + free_irq(dev->irq, dev); 362 + return err; 356 363 } 357 364 358 365 static int ··· 526 527 dev->mem_start = mem[this_dev]; 527 528 dev->mem_end = mem_end[this_dev]; 528 529 if (do_wd_probe(dev) == 0) { 529 - if (register_netdev(dev) == 0) { 530 - dev_wd[found++] = dev; 531 - continue; 532 - } 533 - cleanup_card(dev); 530 + dev_wd[found++] = dev; 531 + continue; 534 532 } 535 533 free_netdev(dev); 536 534 printk(KERN_WARNING "wd.c: No wd80x3 card found (i/o = 0x%x).\n", io[this_dev]);