← Back to branch summary

~ubuntu-branches/ubuntu/vivid/ndiswrapper/vivid

« back to all changes in this revision

Viewing changes to driver/loader.c

  • Committer: Package Import Robot
  • Author(s): Julian Andres Klode
  • Date: 2012-03-05 16:49:02 UTC
  • mfrom: (1.2.8)
  • Revision ID: package-import@ubuntu.com-20120305164902-rrir76um4yq4eimb
Tags: 1.57-1
http://bugs.debian.org/655223
https://launchpad.net/bugs/910597
http://bugs.debian.org/655249
* Imported Upstream version 1.57
  - Fixes build with kernel 3.2 (Closes: #655223, LP: #910597)
* Enable hardening build flags (Closes: #655249)
* patches/ndiswrapper-harden.patch: Use $(shell X) instead of `X`
* Update to Policy 3.9.3, copyright-format 1.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
driver/loader.c
43
43
        { .data1 = 0xf12d3cf8, .data2 = 0xb11d, .data3 = 0x457e},
44
44
};
45
45
 
46
 
struct semaphore loader_mutex;
 
46
struct mutex loader_mutex;
47
47
static struct completion loader_complete;
48
48
 
49
49
static struct nt_list wrap_devices;
52
52
static int wrap_device_type(int data1)
53
53
{
54
54
        int i;
55
 
        for (i = 0; i < sizeof(class_guids) / sizeof(class_guids[0]); i++)
 
55
        for (i = 0; i < ARRAY_SIZE(class_guids); i++)
56
56
                if (data1 == class_guids[i].data1)
57
57
                        return i;
58
58
        ERROR("unknown device: 0x%x\n", data1);
68
68
 
69
69
        ENTER1("device: %04X:%04X:%04X:%04X", wd->vendor, wd->device,
70
70
               wd->subvendor, wd->subdevice);
71
 
        if (down_interruptible(&loader_mutex)) {
72
 
                WARNING("couldn't obtain loader_mutex");
73
 
                EXIT1(return NULL);
74
 
        }
 
71
        mutex_lock(&loader_mutex);
75
72
        wrap_driver = NULL;
76
73
        nt_list_for_each(cur, &wrap_drivers) {
77
74
                wrap_driver = container_of(cur, struct wrap_driver, list);
81
78
                } else
82
79
                        wrap_driver = NULL;
83
80
        }
84
 
        up(&loader_mutex);
 
81
        mutex_unlock(&loader_mutex);
85
82
 
86
83
        if (!wrap_driver) {
87
84
                char *argv[] = {"loadndisdriver", WRAP_CMD_LOAD_DRIVER,
95
92
                char *env[] = {NULL};
96
93
 
97
94
                TRACE1("loading driver %s", wd->driver_name);
98
 
                if (down_interruptible(&loader_mutex)) {
99
 
                        WARNING("couldn't obtain loader_mutex");
100
 
                        EXIT1(return NULL);
101
 
                }
 
95
                mutex_lock(&loader_mutex);
102
96
                INIT_COMPLETION(loader_complete);
103
97
                ret = call_usermodehelper("/sbin/loadndisdriver", argv, env, 1);
104
98
                if (ret) {
105
 
                        up(&loader_mutex);
 
99
                        mutex_unlock(&loader_mutex);
106
100
                        ERROR("couldn't load driver %s; check system log "
107
101
                              "for messages from 'loadndisdriver'",
108
102
                              wd->driver_name);
120
114
                        } else
121
115
                                wrap_driver = NULL;
122
116
                }
123
 
                up(&loader_mutex);
 
117
                mutex_unlock(&loader_mutex);
124
118
                if (wrap_driver)
125
119
                        TRACE1("driver %s is loaded", wrap_driver->name);
126
120
                else
149
143
                strncpy(pe_image->name, load_driver->sys_files[i].name,
150
144
                        sizeof(pe_image->name));
151
145
                pe_image->name[sizeof(pe_image->name)-1] = 0;
152
 
                TRACE1("image size: %lu bytes",
153
 
                       (unsigned long)load_driver->sys_files[i].size);
 
146
                TRACE1("image size: %zu bytes", load_driver->sys_files[i].size);
154
147
 
155
148
#ifdef CONFIG_X86_64
156
149
#ifdef PAGE_KERNEL_EXECUTABLE
223
216
        struct wrap_driver *driver, *cur;
224
217
 
225
218
        ENTER1("%s", bin_file_name);
226
 
        if (down_interruptible(&loader_mutex)) {
227
 
                WARNING("couldn't obtain loader_mutex");
228
 
                EXIT1(return NULL);
229
 
        }
 
219
        mutex_lock(&loader_mutex);
230
220
        driver = NULL;
231
221
        nt_list_for_each_entry(cur, &wrap_drivers, list) {
232
222
                for (i = 0; i < cur->num_bin_files; i++)
237
227
                if (driver)
238
228
                        break;
239
229
        }
240
 
        up(&loader_mutex);
 
230
        mutex_unlock(&loader_mutex);
241
231
        if (!driver) {
242
232
                TRACE1("couldn't find bin file '%s'", bin_file_name);
243
233
                return NULL;
257
247
 
258
248
                TRACE1("loading bin file %s/%s", driver->name,
259
249
                       driver->bin_files[i].name);
260
 
                if (down_interruptible(&loader_mutex)) {
261
 
                        WARNING("couldn't obtain loader_mutex");
262
 
                        EXIT1(return NULL);
263
 
                }
 
250
                mutex_lock(&loader_mutex);
264
251
                INIT_COMPLETION(loader_complete);
265
252
                ret = call_usermodehelper("/sbin/loadndisdriver", argv, env, 1);
266
253
                if (ret) {
267
 
                        up(&loader_mutex);
 
254
                        mutex_unlock(&loader_mutex);
268
255
                        ERROR("couldn't load file %s/%s; check system log "
269
256
                              "for messages from 'loadndisdriver' (%d)",
270
257
                              driver->name, driver->bin_files[i].name, ret);
271
258
                        EXIT1(return NULL);
272
259
                }
273
260
                wait_for_completion(&loader_complete);
274
 
                up(&loader_mutex);
 
261
                mutex_unlock(&loader_mutex);
275
262
                if (!driver->bin_files[i].data) {
276
263
                        WARNING("couldn't load binary file %s",
277
264
                                driver->bin_files[i].name);
416
403
        ENTER1("unloading device %p (%04X:%04X:%04X:%04X), driver %s", wd,
417
404
               wd->vendor, wd->device, wd->subvendor, wd->subdevice,
418
405
               wd->driver_name);
419
 
        if (down_interruptible(&loader_mutex))
420
 
                WARNING("couldn't obtain loader_mutex");
 
406
        mutex_lock(&loader_mutex);
421
407
        while ((cur = RemoveHeadList(&wd->settings))) {
422
408
                struct wrap_device_setting *setting;
423
409
                setting = container_of(cur, struct wrap_device_setting, list);
424
410
                kfree(setting);
425
411
        }
426
412
        RemoveEntryList(&wd->list);
427
 
        up(&loader_mutex);
 
413
        mutex_unlock(&loader_mutex);
428
414
        kfree(wd);
429
415
        EXIT1(return);
430
416
}
565
551
        memset(wrap_driver, 0, sizeof(*wrap_driver));
566
552
        InitializeListHead(&wrap_driver->list);
567
553
        InitializeListHead(&wrap_driver->settings);
568
 
        InitializeListHead(&wrap_driver->wrap_devices);
569
554
        wrap_driver->drv_obj = drv_obj;
570
555
        RtlInitAnsiString(&ansi_reg, "/tmp");
571
556
        if (RtlAnsiStringToUnicodeString(&drv_obj->name, &ansi_reg, TRUE) !=
658
643
{
659
644
        struct nt_list *cur, *next;
660
645
 
661
 
        if (down_interruptible(&loader_mutex))
662
 
                WARNING("couldn't obtain loader_mutex");
 
646
        mutex_lock(&loader_mutex);
663
647
        nt_list_for_each_safe(cur, next, &wrap_devices) {
664
648
                struct wrap_device *wd;
665
649
                wd = container_of(cur, struct wrap_device, list);
666
 
                set_bit(HW_PRESENT, &wd->hw_status);
 
650
                set_bit(HW_DISABLED, &wd->hw_status);
667
651
        }
668
 
        up(&loader_mutex);
 
652
        mutex_unlock(&loader_mutex);
669
653
 
670
654
        if (wrap_pci_driver.name)
671
655
                pci_unregister_driver(&wrap_pci_driver);
701
685
                char *env[] = {NULL};
702
686
                TRACE2("%s, %s, %s, %s, %s", vendor, device,
703
687
                       subvendor, subdevice, bus);
704
 
                if (down_interruptible(&loader_mutex)) {
705
 
                        WARNING("couldn't obtain loader_mutex");
706
 
                        EXIT1(return NULL);
707
 
                }
 
688
                mutex_lock(&loader_mutex);
708
689
                INIT_COMPLETION(loader_complete);
709
690
                ret = call_usermodehelper("/sbin/loadndisdriver", argv, env, 1);
710
691
                if (ret) {
711
 
                        up(&loader_mutex);
 
692
                        mutex_unlock(&loader_mutex);
712
693
                        TRACE1("couldn't load device %04x:%04x; check system "
713
694
                               "log for messages from 'loadndisdriver'",
714
695
                               load_device->vendor, load_device->device);
726
707
                        else
727
708
                                wd = NULL;
728
709
                }
729
 
                up(&loader_mutex);
 
710
                mutex_unlock(&loader_mutex);
730
711
        } else
731
712
                wd = NULL;
732
713
        EXIT1(return wd);
737
718
        struct nt_list *cur;
738
719
        struct wrap_device *wd;
739
720
 
740
 
        if (down_interruptible(&loader_mutex)) {
741
 
                WARNING("couldn't obtain loader_mutex");
742
 
                return NULL;
743
 
        }
 
721
        mutex_lock(&loader_mutex);
744
722
        wd = NULL;
745
723
        nt_list_for_each(cur, &wrap_devices) {
746
724
                wd = container_of(cur, struct wrap_device, list);
753
731
                else
754
732
                        wd = NULL;
755
733
        }
756
 
        up(&loader_mutex);
 
734
        mutex_unlock(&loader_mutex);
757
735
        return wd;
758
736
}
759
737
 
843
821
}
844
822
 
845
823
static struct file_operations wrapper_fops = {
846
 
        .owner          = THIS_MODULE,
847
 
 
 
824
        .owner          = THIS_MODULE,
848
825
#ifdef HAVE_UNLOCKED_IOCTL
849
826
        .unlocked_ioctl = wrapper_ioctl,
850
827
#else
854
831
};
855
832
 
856
833
static struct miscdevice wrapper_misc = {
857
 
        .name   = DRIVER_NAME,
 
834
        .name   = DRIVER_NAME,
858
835
        .minor  = MISC_DYNAMIC_MINOR,
859
 
        .fops   = &wrapper_fops
 
836
        .fops   = &wrapper_fops
860
837
};
861
838
 
862
839
int loader_init(void)
865
842
 
866
843
        InitializeListHead(&wrap_drivers);
867
844
        InitializeListHead(&wrap_devices);
868
 
        sema_init(&loader_mutex, 1);
 
845
        mutex_init(&loader_mutex);
869
846
        init_completion(&loader_complete);
870
 
        if ((err = misc_register(&wrapper_misc)) < 0 ) {
 
847
        if ((err = misc_register(&wrapper_misc)) < 0) {
871
848
                ERROR("couldn't register module (%d)", err);
872
849
                unregister_devices();
873
850
                EXIT1(return err);
883
860
        ENTER1("");
884
861
        misc_deregister(&wrapper_misc);
885
862
        unregister_devices();
886
 
        if (down_interruptible(&loader_mutex))
887
 
                WARNING("couldn't obtain loader_mutex");
 
863
        mutex_lock(&loader_mutex);
888
864
        nt_list_for_each_safe(cur, next, &wrap_drivers) {
889
865
                struct wrap_driver *driver;
890
866
                driver = container_of(cur, struct wrap_driver, list);
891
867
                unload_wrap_driver(driver);
892
868
        }
893
 
        up(&loader_mutex);
 
869
        mutex_unlock(&loader_mutex);
894
870
        EXIT1(return);
895
871
}