File: /usr/src/linux/fs/char_dev.c

1     /*
2      *  linux/fs/block_dev.c
3      *
4      *  Copyright (C) 1991, 1992  Linus Torvalds
5      */
6     
7     #include <linux/config.h>
8     #include <linux/init.h>
9     #include <linux/slab.h>
10     
11     #define HASH_BITS	6
12     #define HASH_SIZE	(1UL << HASH_BITS)
13     #define HASH_MASK	(HASH_SIZE-1)
14     static struct list_head cdev_hashtable[HASH_SIZE];
15     static spinlock_t cdev_lock = SPIN_LOCK_UNLOCKED;
16     static kmem_cache_t * cdev_cachep;
17     
18     #define alloc_cdev() \
19     	 ((struct char_device *) kmem_cache_alloc(cdev_cachep, SLAB_KERNEL))
20     #define destroy_cdev(cdev) kmem_cache_free(cdev_cachep, (cdev))
21     
22     static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
23     {
24     	struct char_device * cdev = (struct char_device *) foo;
25     
26     	if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
27     	    SLAB_CTOR_CONSTRUCTOR)
28     	{
29     		memset(cdev, 0, sizeof(*cdev));
30     		sema_init(&cdev->sem, 1);
31     	}
32     }
33     
34     void __init cdev_cache_init(void)
35     {
36     	int i;
37     	struct list_head *head = cdev_hashtable;
38     
39     	i = HASH_SIZE;
40     	do {
41     		INIT_LIST_HEAD(head);
42     		head++;
43     		i--;
44     	} while (i);
45     
46     	cdev_cachep = kmem_cache_create("cdev_cache",
47     					 sizeof(struct char_device),
48     					 0, SLAB_HWCACHE_ALIGN, init_once,
49     					 NULL);
50     	if (!cdev_cachep)
51     		panic("Cannot create cdev_cache SLAB cache");
52     }
53     
54     /*
55      * Most likely _very_ bad one - but then it's hardly critical for small
56      * /dev and can be fixed when somebody will need really large one.
57      */
58     static inline unsigned long hash(dev_t dev)
59     {
60     	unsigned long tmp = dev;
61     	tmp = tmp + (tmp >> HASH_BITS) + (tmp >> HASH_BITS*2);
62     	return tmp & HASH_MASK;
63     }
64     
65     static struct char_device *cdfind(dev_t dev, struct list_head *head)
66     {
67     	struct list_head *p;
68     	struct char_device *cdev;
69     	for (p=head->next; p!=head; p=p->next) {
70     		cdev = list_entry(p, struct char_device, hash);
71     		if (cdev->dev != dev)
72     			continue;
73     		atomic_inc(&cdev->count);
74     		return cdev;
75     	}
76     	return NULL;
77     }
78     
79     struct char_device *cdget(dev_t dev)
80     {
81     	struct list_head * head = cdev_hashtable + hash(dev);
82     	struct char_device *cdev, *new_cdev;
83     	spin_lock(&cdev_lock);
84     	cdev = cdfind(dev, head);
85     	spin_unlock(&cdev_lock);
86     	if (cdev)
87     		return cdev;
88     	new_cdev = alloc_cdev();
89     	if (!new_cdev)
90     		return NULL;
91     	atomic_set(&new_cdev->count,1);
92     	new_cdev->dev = dev;
93     	spin_lock(&cdev_lock);
94     	cdev = cdfind(dev, head);
95     	if (!cdev) {
96     		list_add(&new_cdev->hash, head);
97     		spin_unlock(&cdev_lock);
98     		return new_cdev;
99     	}
100     	spin_unlock(&cdev_lock);
101     	destroy_cdev(new_cdev);
102     	return cdev;
103     }
104     
105     void cdput(struct char_device *cdev)
106     {
107     	if (atomic_dec_and_test(&cdev->count)) {
108     		spin_lock(&cdev_lock);
109     		list_del(&cdev->hash);
110     		spin_unlock(&cdev_lock);
111     		destroy_cdev(cdev);
112     	}
113     }
114     
115