add new system file

hc

2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c

 kernel/drivers/media/dvb-core/dvbdev.c
..
..
@@ -37,6 +37,7 @@
37
37
 #include <media/tuner.h>
38
38
 
39
39
 static DEFINE_MUTEX(dvbdev_mutex);
40
+static LIST_HEAD(dvbdevfops_list);
40
41
 static int dvbdev_debug;
41
42
 
42
43
 module_param(dvbdev_debug, int, 0644);
..
..
@@ -107,7 +108,7 @@
107
108
 		new_fops = fops_get(dvbdev->fops);
108
109
 		if (!new_fops)
109
110
 			goto fail;
110
-		file->private_data = dvbdev;
111
+		file->private_data = dvb_device_get(dvbdev);
111
112
 		replace_fops(file, new_fops);
112
113
 		if (file->f_op->open)
113
114
 			err = file->f_op->open(inode, file);
..
..
@@ -171,6 +172,9 @@
171
172
 	}
172
173
 
173
174
 	dvbdev->users++;
175
+
176
+	dvb_device_put(dvbdev);
177
+
174
178
 	return 0;
175
179
 }
176
180
 EXPORT_SYMBOL(dvb_generic_release);
..
..
@@ -342,6 +346,7 @@
342
346
 				       GFP_KERNEL);
343
347
 		if (!dvbdev->pads) {
344
348
 			kfree(dvbdev->entity);
349
+			dvbdev->entity = NULL;
345
350
 			return -ENOMEM;
346
351
 		}
347
352
 	}
..
..
@@ -458,14 +463,15 @@
458
463
 			enum dvb_device_type type, int demux_sink_pads)
459
464
 {
460
465
 	struct dvb_device *dvbdev;
461
-	struct file_operations *dvbdevfops;
466
+	struct file_operations *dvbdevfops = NULL;
467
+	struct dvbdevfops_node *node = NULL, *new_node = NULL;
462
468
 	struct device *clsdev;
463
469
 	int minor;
464
470
 	int id, ret;
465
471
 
466
472
 	mutex_lock(&dvbdev_register_lock);
467
473
 
468
-	if ((id = dvbdev_get_free_id (adap, type)) < 0){
474
+	if ((id = dvbdev_get_free_id (adap, type)) < 0) {
469
475
 		mutex_unlock(&dvbdev_register_lock);
470
476
 		*pdvbdev = NULL;
471
477
 		pr_err("%s: couldn't find free device id\n", __func__);
..
..
@@ -473,40 +479,69 @@
473
479
 	}
474
480
 
475
481
 	*pdvbdev = dvbdev = kzalloc(sizeof(*dvbdev), GFP_KERNEL);
476
-
477
482
 	if (!dvbdev){
478
483
 		mutex_unlock(&dvbdev_register_lock);
479
484
 		return -ENOMEM;
480
485
 	}
481
486
 
482
-	dvbdevfops = kmemdup(template->fops, sizeof(*dvbdevfops), GFP_KERNEL);
487
+	/*
488
+	 * When a device of the same type is probe()d more than once,
489
+	 * the first allocated fops are used. This prevents memory leaks
490
+	 * that can occur when the same device is probe()d repeatedly.
491
+	 */
492
+	list_for_each_entry(node, &dvbdevfops_list, list_head) {
493
+		if (node->fops->owner == adap->module &&
494
+				node->type == type &&
495
+				node->template == template) {
496
+			dvbdevfops = node->fops;
497
+			break;
498
+		}
499
+	}
483
500
 
484
-	if (!dvbdevfops){
485
-		kfree (dvbdev);
486
-		mutex_unlock(&dvbdev_register_lock);
487
-		return -ENOMEM;
501
+	if (dvbdevfops == NULL) {
502
+		dvbdevfops = kmemdup(template->fops, sizeof(*dvbdevfops), GFP_KERNEL);
503
+		if (!dvbdevfops) {
504
+			kfree(dvbdev);
505
+			mutex_unlock(&dvbdev_register_lock);
506
+			return -ENOMEM;
507
+		}
508
+
509
+		new_node = kzalloc(sizeof(struct dvbdevfops_node), GFP_KERNEL);
510
+		if (!new_node) {
511
+			kfree(dvbdevfops);
512
+			kfree(dvbdev);
513
+			mutex_unlock(&dvbdev_register_lock);
514
+			return -ENOMEM;
515
+		}
516
+
517
+		new_node->fops = dvbdevfops;
518
+		new_node->type = type;
519
+		new_node->template = template;
520
+		list_add_tail (&new_node->list_head, &dvbdevfops_list);
488
521
 	}
489
522
 
490
523
 	memcpy(dvbdev, template, sizeof(struct dvb_device));
524
+	kref_init(&dvbdev->ref);
491
525
 	dvbdev->type = type;
492
526
 	dvbdev->id = id;
493
527
 	dvbdev->adapter = adap;
494
528
 	dvbdev->priv = priv;
495
529
 	dvbdev->fops = dvbdevfops;
496
530
 	init_waitqueue_head (&dvbdev->wait_queue);
497
-
498
531
 	dvbdevfops->owner = adap->module;
499
-
500
532
 	list_add_tail (&dvbdev->list_head, &adap->device_list);
501
-
502
533
 	down_write(&minor_rwsem);
503
534
 #ifdef CONFIG_DVB_DYNAMIC_MINORS
504
535
 	for (minor = 0; minor < MAX_DVB_MINORS; minor++)
505
536
 		if (dvb_minors[minor] == NULL)
506
537
 			break;
507
-
508
538
 	if (minor == MAX_DVB_MINORS) {
509
-		kfree(dvbdevfops);
539
+		if (new_node) {
540
+			list_del (&new_node->list_head);
541
+			kfree(dvbdevfops);
542
+			kfree(new_node);
543
+		}
544
+		list_del (&dvbdev->list_head);
510
545
 		kfree(dvbdev);
511
546
 		up_write(&minor_rwsem);
512
547
 		mutex_unlock(&dvbdev_register_lock);
..
..
@@ -515,24 +550,24 @@
515
550
 #else
516
551
 	minor = nums2minor(adap->num, type, id);
517
552
 #endif
518
-
519
553
 	dvbdev->minor = minor;
520
-	dvb_minors[minor] = dvbdev;
554
+	dvb_minors[minor] = dvb_device_get(dvbdev);
521
555
 	up_write(&minor_rwsem);
522
-
523
556
 	ret = dvb_register_media_device(dvbdev, type, minor, demux_sink_pads);
524
557
 	if (ret) {
525
558
 		pr_err("%s: dvb_register_media_device failed to create the mediagraph\n",
526
559
 		      __func__);
527
-
560
+		if (new_node) {
561
+			list_del (&new_node->list_head);
562
+			kfree(dvbdevfops);
563
+			kfree(new_node);
564
+		}
528
565
 		dvb_media_device_free(dvbdev);
529
-		kfree(dvbdevfops);
566
+		list_del (&dvbdev->list_head);
530
567
 		kfree(dvbdev);
531
568
 		mutex_unlock(&dvbdev_register_lock);
532
569
 		return ret;
533
570
 	}
534
-
535
-	mutex_unlock(&dvbdev_register_lock);
536
571
 
537
572
 	clsdev = device_create(dvb_class, adap->device,
538
573
 			       MKDEV(DVB_MAJOR, minor),
..
..
@@ -540,11 +575,22 @@
540
575
 	if (IS_ERR(clsdev)) {
541
576
 		pr_err("%s: failed to create device dvb%d.%s%d (%ld)\n",
542
577
 		       __func__, adap->num, dnames[type], id, PTR_ERR(clsdev));
578
+		if (new_node) {
579
+			list_del (&new_node->list_head);
580
+			kfree(dvbdevfops);
581
+			kfree(new_node);
582
+		}
583
+		dvb_media_device_free(dvbdev);
584
+		list_del (&dvbdev->list_head);
585
+		kfree(dvbdev);
586
+		mutex_unlock(&dvbdev_register_lock);
543
587
 		return PTR_ERR(clsdev);
544
588
 	}
589
+
545
590
 	dprintk("DVB: register adapter%d/%s%d @ minor: %i (0x%02x)\n",
546
591
 		adap->num, dnames[type], id, minor, minor);
547
592
 
593
+	mutex_unlock(&dvbdev_register_lock);
548
594
 	return 0;
549
595
 }
550
596
 EXPORT_SYMBOL(dvb_register_device);
..
..
@@ -557,6 +603,7 @@
557
603
 
558
604
 	down_write(&minor_rwsem);
559
605
 	dvb_minors[dvbdev->minor] = NULL;
606
+	dvb_device_put(dvbdev);
560
607
 	up_write(&minor_rwsem);
561
608
 
562
609
 	dvb_media_device_free(dvbdev);
..
..
@@ -568,21 +615,33 @@
568
615
 EXPORT_SYMBOL(dvb_remove_device);
569
616
 
570
617
 
571
-void dvb_free_device(struct dvb_device *dvbdev)
618
+static void dvb_free_device(struct kref *ref)
572
619
 {
573
-	if (!dvbdev)
574
-		return;
620
+	struct dvb_device *dvbdev = container_of(ref, struct dvb_device, ref);
575
621
 
576
-	kfree (dvbdev->fops);
577
622
 	kfree (dvbdev);
578
623
 }
579
-EXPORT_SYMBOL(dvb_free_device);
624
+
625
+
626
+struct dvb_device *dvb_device_get(struct dvb_device *dvbdev)
627
+{
628
+	kref_get(&dvbdev->ref);
629
+	return dvbdev;
630
+}
631
+EXPORT_SYMBOL(dvb_device_get);
632
+
633
+
634
+void dvb_device_put(struct dvb_device *dvbdev)
635
+{
636
+	if (dvbdev)
637
+		kref_put(&dvbdev->ref, dvb_free_device);
638
+}
580
639
 
581
640
 
582
641
 void dvb_unregister_device(struct dvb_device *dvbdev)
583
642
 {
584
643
 	dvb_remove_device(dvbdev);
585
-	dvb_free_device(dvbdev);
644
+	dvb_device_put(dvbdev);
586
645
 }
587
646
 EXPORT_SYMBOL(dvb_unregister_device);
588
647
 
..
..
@@ -1065,9 +1124,17 @@
1065
1124
 
1066
1125
 static void __exit exit_dvbdev(void)
1067
1126
 {
1127
+	struct dvbdevfops_node *node, *next;
1128
+
1068
1129
 	class_destroy(dvb_class);
1069
1130
 	cdev_del(&dvb_device_cdev);
1070
1131
 	unregister_chrdev_region(MKDEV(DVB_MAJOR, 0), MAX_DVB_MINORS);
1132
+
1133
+	list_for_each_entry_safe(node, next, &dvbdevfops_list, list_head) {
1134
+		list_del (&node->list_head);
1135
+		kfree(node->fops);
1136
+		kfree(node);
1137
+	}
1071
1138
 }
1072
1139
 
1073
1140
 subsys_initcall(init_dvbdev);