[net-next-2.6.git] / fs / char_dev.c

/*
 *  linux/fs/char_dev.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

#include <linux/config.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/string.h>

#include <linux/major.h>
#include <linux/errno.h>
#include <linux/module.h>
#include <linux/smp_lock.h>
#include <linux/devfs_fs_kernel.h>

#include <linux/kobject.h>
#include <linux/kobj_map.h>
#include <linux/cdev.h>

#ifdef CONFIG_KMOD
#include <linux/kmod.h>
#endif

static struct kobj_map *cdev_map;

#define MAX_PROBE_HASH 255	/* random */

static DECLARE_MUTEX(chrdevs_lock);

static struct char_device_struct {
	struct char_device_struct *next;
	unsigned int major;
	unsigned int baseminor;
	int minorct;
	char name[64];
	struct file_operations *fops;
	struct cdev *cdev;		/* will die */
} *chrdevs[MAX_PROBE_HASH];

/* index in the above */
static inline int major_to_index(int major)
{
	return major % MAX_PROBE_HASH;
}

struct chrdev_info {
	int index;
	struct char_device_struct *cd;
};

void *get_next_chrdev(void *dev)
{
	struct chrdev_info *info;

	if (dev == NULL) {
		info = kmalloc(sizeof(*info), GFP_KERNEL);
		if (!info)
			goto out;
		info->index=0;
		info->cd = chrdevs[info->index];
		if (info->cd)
			goto out;
	} else {
		info = dev;
	}

	while (info->index < ARRAY_SIZE(chrdevs)) {
		if (info->cd)
			info->cd = info->cd->next;
		if (info->cd)
			goto out;
		/*
		 * No devices on this chain, move to the next
		 */
		info->index++;
		info->cd = (info->index < ARRAY_SIZE(chrdevs)) ?
			chrdevs[info->index] : NULL;
		if (info->cd)
			goto out;
	}

out:
	return info;
}

void *acquire_chrdev_list(void)
{
	down(&chrdevs_lock);
	return get_next_chrdev(NULL);
}

void release_chrdev_list(void *dev)
{
	up(&chrdevs_lock);
	kfree(dev);
}


int count_chrdev_list(void)
{
	struct char_device_struct *cd;
	int i, count;

	count = 0;

	for (i = 0; i < ARRAY_SIZE(chrdevs) ; i++) {
		for (cd = chrdevs[i]; cd; cd = cd->next)
			count++;
	}

	return count;
}

int get_chrdev_info(void *dev, int *major, char **name)
{
	struct chrdev_info *info = dev;

	if (info->cd == NULL)
		return 1;

	*major = info->cd->major;
	*name = info->cd->name;
	return 0;
}

/*
 * Register a single major with a specified minor range.
 *
 * If major == 0 this functions will dynamically allocate a major and return
 * its number.
 *
 * If major > 0 this function will attempt to reserve the passed range of
 * minors and will return zero on success.
 *
 * Returns a -ve errno on failure.
 */
static struct char_device_struct *
__register_chrdev_region(unsigned int major, unsigned int baseminor,
			   int minorct, const char *name)
{
	struct char_device_struct *cd, **cp;
	int ret = 0;
	int i;

	cd = kmalloc(sizeof(struct char_device_struct), GFP_KERNEL);
	if (cd == NULL)
		return ERR_PTR(-ENOMEM);

	memset(cd, 0, sizeof(struct char_device_struct));

	down(&chrdevs_lock);

	/* temporary */
	if (major == 0) {
		for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) {
			if (chrdevs[i] == NULL)
				break;
		}

		if (i == 0) {
			ret = -EBUSY;
			goto out;
		}
		major = i;
		ret = major;
	}

	cd->major = major;
	cd->baseminor = baseminor;
	cd->minorct = minorct;
	strncpy(cd->name,name, 64);

	i = major_to_index(major);

	for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
		if ((*cp)->major > major ||
		    ((*cp)->major == major && (*cp)->baseminor >= baseminor))
			break;
	if (*cp && (*cp)->major == major &&
	    (*cp)->baseminor < baseminor + minorct) {
		ret = -EBUSY;
		goto out;
	}
	cd->next = *cp;
	*cp = cd;
	up(&chrdevs_lock);
	return cd;
out:
	up(&chrdevs_lock);
	kfree(cd);
	return ERR_PTR(ret);
}

static struct char_device_struct *
__unregister_chrdev_region(unsigned major, unsigned baseminor, int minorct)
{
	struct char_device_struct *cd = NULL, **cp;
	int i = major_to_index(major);

	down(&chrdevs_lock);
	for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
		if ((*cp)->major == major &&
		    (*cp)->baseminor == baseminor &&
		    (*cp)->minorct == minorct)
			break;
	if (*cp) {
		cd = *cp;
		*cp = cd->next;
	}
	up(&chrdevs_lock);
	return cd;
}

int register_chrdev_region(dev_t from, unsigned count, const char *name)
{
	struct char_device_struct *cd;
	dev_t to = from + count;
	dev_t n, next;

	for (n = from; n < to; n = next) {
		next = MKDEV(MAJOR(n)+1, 0);
		if (next > to)
			next = to;
		cd = __register_chrdev_region(MAJOR(n), MINOR(n),
			       next - n, name);
		if (IS_ERR(cd))
			goto fail;
	}
	return 0;
fail:
	to = n;
	for (n = from; n < to; n = next) {
		next = MKDEV(MAJOR(n)+1, 0);
		kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
	}
	return PTR_ERR(cd);
}

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
			const char *name)
{
	struct char_device_struct *cd;
	cd = __register_chrdev_region(0, baseminor, count, name);
	if (IS_ERR(cd))
		return PTR_ERR(cd);
	*dev = MKDEV(cd->major, cd->baseminor);
	return 0;
}

int register_chrdev(unsigned int major, const char *name,
		    struct file_operations *fops)
{
	struct char_device_struct *cd;
	struct cdev *cdev;
	char *s;
	int err = -ENOMEM;

	cd = __register_chrdev_region(major, 0, 256, name);
	if (IS_ERR(cd))
		return PTR_ERR(cd);
	
	cdev = cdev_alloc();
	if (!cdev)
		goto out2;

	cdev->owner = fops->owner;
	cdev->ops = fops;
	kobject_set_name(&cdev->kobj, "%s", name);
	for (s = strchr(kobject_name(&cdev->kobj),'/'); s; s = strchr(s, '/'))
		*s = '!';
		
	err = cdev_add(cdev, MKDEV(cd->major, 0), 256);
	if (err)
		goto out;

	cd->cdev = cdev;

	return major ? 0 : cd->major;
out:
	kobject_put(&cdev->kobj);
out2:
	kfree(__unregister_chrdev_region(cd->major, 0, 256));
	return err;
}

void unregister_chrdev_region(dev_t from, unsigned count)
{
	dev_t to = from + count;
	dev_t n, next;

	for (n = from; n < to; n = next) {
		next = MKDEV(MAJOR(n)+1, 0);
		if (next > to)
			next = to;
		kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
	}
}

int unregister_chrdev(unsigned int major, const char *name)
{
	struct char_device_struct *cd;
	cd = __unregister_chrdev_region(major, 0, 256);
	if (cd && cd->cdev)
		cdev_del(cd->cdev);
	kfree(cd);
	return 0;
}

static DEFINE_SPINLOCK(cdev_lock);

static struct kobject *cdev_get(struct cdev *p)
{
	struct module *owner = p->owner;
	struct kobject *kobj;

	if (owner && !try_module_get(owner))
		return NULL;
	kobj = kobject_get(&p->kobj);
	if (!kobj)
		module_put(owner);
	return kobj;
}

void cdev_put(struct cdev *p)
{
	if (p) {
		struct module *owner = p->owner;
		kobject_put(&p->kobj);
		module_put(owner);
	}
}

/*
 * Called every time a character special file is opened
 */
int chrdev_open(struct inode * inode, struct file * filp)
{
	struct cdev *p;
	struct cdev *new = NULL;
	int ret = 0;

	spin_lock(&cdev_lock);
	p = inode->i_cdev;
	if (!p) {
		struct kobject *kobj;
		int idx;
		spin_unlock(&cdev_lock);
		kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx);
		if (!kobj)
			return -ENXIO;
		new = container_of(kobj, struct cdev, kobj);
		spin_lock(&cdev_lock);
		p = inode->i_cdev;
		if (!p) {
			inode->i_cdev = p = new;
			inode->i_cindex = idx;
			list_add(&inode->i_devices, &p->list);
			new = NULL;
		} else if (!cdev_get(p))
			ret = -ENXIO;
	} else if (!cdev_get(p))
		ret = -ENXIO;
	spin_unlock(&cdev_lock);
	cdev_put(new);
	if (ret)
		return ret;
	filp->f_op = fops_get(p->ops);
	if (!filp->f_op) {
		cdev_put(p);
		return -ENXIO;
	}
	if (filp->f_op->open) {
		lock_kernel();
		ret = filp->f_op->open(inode,filp);
		unlock_kernel();
	}
	if (ret)
		cdev_put(p);
	return ret;
}

void cd_forget(struct inode *inode)
{
	spin_lock(&cdev_lock);
	list_del_init(&inode->i_devices);
	inode->i_cdev = NULL;
	spin_unlock(&cdev_lock);
}

static void cdev_purge(struct cdev *cdev)
{
	spin_lock(&cdev_lock);
	while (!list_empty(&cdev->list)) {
		struct inode *inode;
		inode = container_of(cdev->list.next, struct inode, i_devices);
		list_del_init(&inode->i_devices);
		inode->i_cdev = NULL;
	}
	spin_unlock(&cdev_lock);
}

/*
 * Dummy default file-operations: the only thing this does
 * is contain the open that then fills in the correct operations
 * depending on the special file...
 */
struct file_operations def_chr_fops = {
	.open = chrdev_open,
};

static struct kobject *exact_match(dev_t dev, int *part, void *data)
{
	struct cdev *p = data;
	return &p->kobj;
}

static int exact_lock(dev_t dev, void *data)
{
	struct cdev *p = data;
	return cdev_get(p) ? 0 : -1;
}

int cdev_add(struct cdev *p, dev_t dev, unsigned count)
{
	p->dev = dev;
	p->count = count;
	return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);
}

static void cdev_unmap(dev_t dev, unsigned count)
{
	kobj_unmap(cdev_map, dev, count);
}

void cdev_del(struct cdev *p)
{
	cdev_unmap(p->dev, p->count);
	kobject_put(&p->kobj);
}


static void cdev_default_release(struct kobject *kobj)
{
	struct cdev *p = container_of(kobj, struct cdev, kobj);
	cdev_purge(p);
}

static void cdev_dynamic_release(struct kobject *kobj)
{
	struct cdev *p = container_of(kobj, struct cdev, kobj);
	cdev_purge(p);
	kfree(p);
}

static struct kobj_type ktype_cdev_default = {
	.release	= cdev_default_release,
};

static struct kobj_type ktype_cdev_dynamic = {
	.release	= cdev_dynamic_release,
};

struct cdev *cdev_alloc(void)
{
	struct cdev *p = kmalloc(sizeof(struct cdev), GFP_KERNEL);
	if (p) {
		memset(p, 0, sizeof(struct cdev));
		p->kobj.ktype = &ktype_cdev_dynamic;
		INIT_LIST_HEAD(&p->list);
		kobject_init(&p->kobj);
	}
	return p;
}

void cdev_init(struct cdev *cdev, struct file_operations *fops)
{
	memset(cdev, 0, sizeof *cdev);
	INIT_LIST_HEAD(&cdev->list);
	cdev->kobj.ktype = &ktype_cdev_default;
	kobject_init(&cdev->kobj);
	cdev->ops = fops;
}

static struct kobject *base_probe(dev_t dev, int *part, void *data)
{
	if (request_module("char-major-%d-%d", MAJOR(dev), MINOR(dev)) > 0)
		/* Make old-style 2.4 aliases work */
		request_module("char-major-%d", MAJOR(dev));
	return NULL;
}

void __init chrdev_init(void)
{
	cdev_map = kobj_map_init(base_probe, &chrdevs_lock);
}


/* Let modules do char dev stuff */
EXPORT_SYMBOL(register_chrdev_region);
EXPORT_SYMBOL(unregister_chrdev_region);
EXPORT_SYMBOL(alloc_chrdev_region);
EXPORT_SYMBOL(cdev_init);
EXPORT_SYMBOL(cdev_alloc);
EXPORT_SYMBOL(cdev_del);
EXPORT_SYMBOL(cdev_add);
EXPORT_SYMBOL(register_chrdev);
EXPORT_SYMBOL(unregister_chrdev);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/char_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/fs.h>
	10	#include <linux/slab.h>
	11	#include <linux/string.h>
	12
	13	#include <linux/major.h>
	14	#include <linux/errno.h>
	15	#include <linux/module.h>
	16	#include <linux/smp_lock.h>
	17	#include <linux/devfs_fs_kernel.h>
	18
	19	#include <linux/kobject.h>
	20	#include <linux/kobj_map.h>
	21	#include <linux/cdev.h>
	22
	23	#ifdef CONFIG_KMOD
	24	#include <linux/kmod.h>
	25	#endif
	26
	27	static struct kobj_map *cdev_map;
	28
1d4d5b32	29	#define MAX_PROBE_HASH 255 /* random */
1da177e4 LT	30
	31	static DECLARE_MUTEX(chrdevs_lock);
	32
	33	static struct char_device_struct {
	34	struct char_device_struct *next;
	35	unsigned int major;
	36	unsigned int baseminor;
	37	int minorct;
7170be5f	38	char name[64];
1da177e4 LT	39	struct file_operations *fops;
	40	struct cdev cdev; / will die */
	41	} *chrdevs[MAX_PROBE_HASH];
	42
	43	/* index in the above */
	44	static inline int major_to_index(int major)
	45	{
	46	return major % MAX_PROBE_HASH;
	47	}
	48
7170be5f NH	49	struct chrdev_info {
7170be5f NH	50	int index;
1da177e4	51	struct char_device_struct *cd;
7170be5f NH	52	};
	53
	54	void get_next_chrdev(void dev)
	55	{
	56	struct chrdev_info *info;
	57
	58	if (dev == NULL) {
	59	info = kmalloc(sizeof(*info), GFP_KERNEL);
	60	if (!info)
	61	goto out;
	62	info->index=0;
	63	info->cd = chrdevs[info->index];
	64	if (info->cd)
	65	goto out;
	66	} else {
	67	info = dev;
	68	}
	69
	70	while (info->index < ARRAY_SIZE(chrdevs)) {
	71	if (info->cd)
	72	info->cd = info->cd->next;
	73	if (info->cd)
	74	goto out;
	75	/*
	76	* No devices on this chain, move to the next
	77	*/
	78	info->index++;
	79	info->cd = (info->index < ARRAY_SIZE(chrdevs)) ?
	80	chrdevs[info->index] : NULL;
	81	if (info->cd)
	82	goto out;
	83	}
1da177e4	84
7170be5f NH	85	out:
	86	return info;
	87	}
1da177e4	88
7170be5f NH	89	void *acquire_chrdev_list(void)
7170be5f NH	90	{
1da177e4	91	down(&chrdevs_lock);
7170be5f NH	92	return get_next_chrdev(NULL);
	93	}
	94
	95	void release_chrdev_list(void *dev)
	96	{
	97	up(&chrdevs_lock);
	98	kfree(dev);
	99	}
	100
	101
	102	int count_chrdev_list(void)
	103	{
	104	struct char_device_struct *cd;
	105	int i, count;
	106
	107	count = 0;
	108
1da177e4	109	for (i = 0; i < ARRAY_SIZE(chrdevs) ; i++) {
7170be5f NH	110	for (cd = chrdevs[i]; cd; cd = cd->next)
7170be5f NH	111	count++;
1da177e4	112	}
1da177e4	113
7170be5f NH	114	return count;
	115	}
	116
	117	int get_chrdev_info(void dev, int major, char **name)
	118	{
	119	struct chrdev_info *info = dev;
	120
	121	if (info->cd == NULL)
	122	return 1;
	123
	124	*major = info->cd->major;
	125	*name = info->cd->name;
	126	return 0;
1da177e4 LT	127	}
	128
	129	/*
	130	* Register a single major with a specified minor range.
	131	*
	132	* If major == 0 this functions will dynamically allocate a major and return
	133	* its number.
	134	*
	135	* If major > 0 this function will attempt to reserve the passed range of
	136	* minors and will return zero on success.
	137	*
	138	* Returns a -ve errno on failure.
	139	*/
	140	static struct char_device_struct *
	141	__register_chrdev_region(unsigned int major, unsigned int baseminor,
	142	int minorct, const char *name)
	143	{
	144	struct char_device_struct cd, *cp;
	145	int ret = 0;
	146	int i;
	147
	148	cd = kmalloc(sizeof(struct char_device_struct), GFP_KERNEL);
	149	if (cd == NULL)
	150	return ERR_PTR(-ENOMEM);
	151
	152	memset(cd, 0, sizeof(struct char_device_struct));
	153
	154	down(&chrdevs_lock);
	155
	156	/* temporary */
	157	if (major == 0) {
	158	for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) {
	159	if (chrdevs[i] == NULL)
	160	break;
	161	}
	162
	163	if (i == 0) {
	164	ret = -EBUSY;
	165	goto out;
	166	}
	167	major = i;
	168	ret = major;
	169	}
	170
	171	cd->major = major;
	172	cd->baseminor = baseminor;
	173	cd->minorct = minorct;
7170be5f	174	strncpy(cd->name,name, 64);
1da177e4 LT	175
	176	i = major_to_index(major);
	177
	178	for (cp = &chrdevs[i]; cp; cp = &(cp)->next)
	179	if ((*cp)->major > major \|\|
	180	((cp)->major == major && (cp)->baseminor >= baseminor))
	181	break;
	182	if (cp && (cp)->major == major &&
	183	(*cp)->baseminor < baseminor + minorct) {
	184	ret = -EBUSY;
	185	goto out;
	186	}
	187	cd->next = *cp;
	188	*cp = cd;
	189	up(&chrdevs_lock);
	190	return cd;
	191	out:
	192	up(&chrdevs_lock);
	193	kfree(cd);
	194	return ERR_PTR(ret);
	195	}
	196
	197	static struct char_device_struct *
	198	__unregister_chrdev_region(unsigned major, unsigned baseminor, int minorct)
	199	{
	200	struct char_device_struct cd = NULL, *cp;
	201	int i = major_to_index(major);
	202
8d451687	203	down(&chrdevs_lock);
1da177e4 LT	204	for (cp = &chrdevs[i]; cp; cp = &(cp)->next)
	205	if ((*cp)->major == major &&
	206	(*cp)->baseminor == baseminor &&
	207	(*cp)->minorct == minorct)
	208	break;
	209	if (*cp) {
	210	cd = *cp;
	211	*cp = cd->next;
	212	}
	213	up(&chrdevs_lock);
	214	return cd;
	215	}
	216
	217	int register_chrdev_region(dev_t from, unsigned count, const char *name)
	218	{
	219	struct char_device_struct *cd;
	220	dev_t to = from + count;
	221	dev_t n, next;
	222
	223	for (n = from; n < to; n = next) {
	224	next = MKDEV(MAJOR(n)+1, 0);
	225	if (next > to)
	226	next = to;
	227	cd = __register_chrdev_region(MAJOR(n), MINOR(n),
	228	next - n, name);
	229	if (IS_ERR(cd))
	230	goto fail;
	231	}
	232	return 0;
	233	fail:
	234	to = n;
	235	for (n = from; n < to; n = next) {
	236	next = MKDEV(MAJOR(n)+1, 0);
	237	kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
	238	}
	239	return PTR_ERR(cd);
	240	}
	241
	242	int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
	243	const char *name)
	244	{
	245	struct char_device_struct *cd;
	246	cd = __register_chrdev_region(0, baseminor, count, name);
	247	if (IS_ERR(cd))
	248	return PTR_ERR(cd);
	249	*dev = MKDEV(cd->major, cd->baseminor);
	250	return 0;
	251	}
	252
	253	int register_chrdev(unsigned int major, const char *name,
	254	struct file_operations *fops)
	255	{
	256	struct char_device_struct *cd;
	257	struct cdev *cdev;
	258	char *s;
	259	int err = -ENOMEM;
	260
	261	cd = __register_chrdev_region(major, 0, 256, name);
	262	if (IS_ERR(cd))
	263	return PTR_ERR(cd);
	264
	265	cdev = cdev_alloc();
	266	if (!cdev)
	267	goto out2;
268
269	cdev->owner = fops->owner;
270	cdev->ops = fops;
271	kobject_set_name(&cdev->kobj, "%s", name);
272	for (s = strchr(kobject_name(&cdev->kobj),'/'); s; s = strchr(s, '/'))
273	*s = '!';
274
275	err = cdev_add(cdev, MKDEV(cd->major, 0), 256);
276	if (err)
277	goto out;
278
279	cd->cdev = cdev;
280
281	return major ? 0 : cd->major;
282	out:
283	kobject_put(&cdev->kobj);
284	out2:
285	kfree(__unregister_chrdev_region(cd->major, 0, 256));
286	return err;
287	}
288
289	void unregister_chrdev_region(dev_t from, unsigned count)
290	{
291	dev_t to = from + count;
292	dev_t n, next;
293
294	for (n = from; n < to; n = next) {
295	next = MKDEV(MAJOR(n)+1, 0);
296	if (next > to)
297	next = to;
298	kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
299	}
300	}
301
302	int unregister_chrdev(unsigned int major, const char *name)
303	{
304	struct char_device_struct *cd;
305	cd = __unregister_chrdev_region(major, 0, 256);
306	if (cd && cd->cdev)
307	cdev_del(cd->cdev);
308	kfree(cd);
309	return 0;
310	}
311
312	static DEFINE_SPINLOCK(cdev_lock);
313
314	static struct kobject cdev_get(struct cdev p)
315	{
316	struct module *owner = p->owner;
317	struct kobject *kobj;
318
319	if (owner && !try_module_get(owner))
320	return NULL;
321	kobj = kobject_get(&p->kobj);
322	if (!kobj)
323	module_put(owner);
324	return kobj;
325	}
326
327	void cdev_put(struct cdev *p)
328	{
329	if (p) {
7da6844c	330	struct module *owner = p->owner;
1da177e4	331	kobject_put(&p->kobj);
7da6844c	332	module_put(owner);
1da177e4 LT	333	}
	334	}
	335
	336	/*
	337	* Called every time a character special file is opened
	338	*/
	339	int chrdev_open(struct inode * inode, struct file * filp)
	340	{
	341	struct cdev *p;
	342	struct cdev *new = NULL;
	343	int ret = 0;
	344
	345	spin_lock(&cdev_lock);
	346	p = inode->i_cdev;
	347	if (!p) {
	348	struct kobject *kobj;
	349	int idx;
	350	spin_unlock(&cdev_lock);
	351	kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx);
	352	if (!kobj)
	353	return -ENXIO;
	354	new = container_of(kobj, struct cdev, kobj);
	355	spin_lock(&cdev_lock);
	356	p = inode->i_cdev;
	357	if (!p) {
	358	inode->i_cdev = p = new;
	359	inode->i_cindex = idx;
	360	list_add(&inode->i_devices, &p->list);
	361	new = NULL;
	362	} else if (!cdev_get(p))
	363	ret = -ENXIO;
	364	} else if (!cdev_get(p))
	365	ret = -ENXIO;
	366	spin_unlock(&cdev_lock);
	367	cdev_put(new);
	368	if (ret)
	369	return ret;
	370	filp->f_op = fops_get(p->ops);
	371	if (!filp->f_op) {
	372	cdev_put(p);
	373	return -ENXIO;
	374	}
	375	if (filp->f_op->open) {
	376	lock_kernel();
	377	ret = filp->f_op->open(inode,filp);
	378	unlock_kernel();
	379	}
	380	if (ret)
	381	cdev_put(p);
	382	return ret;
	383	}
	384
	385	void cd_forget(struct inode *inode)
	386	{
	387	spin_lock(&cdev_lock);
	388	list_del_init(&inode->i_devices);
	389	inode->i_cdev = NULL;
	390	spin_unlock(&cdev_lock);
	391	}
	392
75c96f85	393	static void cdev_purge(struct cdev *cdev)
1da177e4 LT	394	{
	395	spin_lock(&cdev_lock);
	396	while (!list_empty(&cdev->list)) {
	397	struct inode *inode;
	398	inode = container_of(cdev->list.next, struct inode, i_devices);
	399	list_del_init(&inode->i_devices);
	400	inode->i_cdev = NULL;
	401	}
	402	spin_unlock(&cdev_lock);
	403	}
	404
	405	/*
	406	* Dummy default file-operations: the only thing this does
	407	* is contain the open that then fills in the correct operations
	408	* depending on the special file...
	409	*/
	410	struct file_operations def_chr_fops = {
	411	.open = chrdev_open,
	412	};
	413
	414	static struct kobject exact_match(dev_t dev, int part, void *data)
	415	{
	416	struct cdev *p = data;
	417	return &p->kobj;
	418	}
	419
	420	static int exact_lock(dev_t dev, void *data)
	421	{
	422	struct cdev *p = data;
	423	return cdev_get(p) ? 0 : -1;
	424	}
	425
	426	int cdev_add(struct cdev *p, dev_t dev, unsigned count)
	427	{
	428	p->dev = dev;
	429	p->count = count;
	430	return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);
	431	}
	432
	433	static void cdev_unmap(dev_t dev, unsigned count)
	434	{
	435	kobj_unmap(cdev_map, dev, count);
	436	}
	437
	438	void cdev_del(struct cdev *p)
	439	{
	440	cdev_unmap(p->dev, p->count);
	441	kobject_put(&p->kobj);
	442	}
	443
	444
	445	static void cdev_default_release(struct kobject *kobj)
	446	{
	447	struct cdev *p = container_of(kobj, struct cdev, kobj);
	448	cdev_purge(p);
	449	}
	450
	451	static void cdev_dynamic_release(struct kobject *kobj)
	452	{
	453	struct cdev *p = container_of(kobj, struct cdev, kobj);
	454	cdev_purge(p);
	455	kfree(p);
	456	}
	457
458	static struct kobj_type ktype_cdev_default = {
459	.release = cdev_default_release,
460	};
461
462	static struct kobj_type ktype_cdev_dynamic = {
463	.release = cdev_dynamic_release,
464	};
465
466	struct cdev *cdev_alloc(void)
467	{
468	struct cdev *p = kmalloc(sizeof(struct cdev), GFP_KERNEL);
469	if (p) {
470	memset(p, 0, sizeof(struct cdev));
471	p->kobj.ktype = &ktype_cdev_dynamic;
472	INIT_LIST_HEAD(&p->list);
473	kobject_init(&p->kobj);
474	}
475	return p;
476	}
477
478	void cdev_init(struct cdev cdev, struct file_operations fops)
479	{
480	memset(cdev, 0, sizeof *cdev);
481	INIT_LIST_HEAD(&cdev->list);
482	cdev->kobj.ktype = &ktype_cdev_default;
483	kobject_init(&cdev->kobj);
484	cdev->ops = fops;
485	}
486
487	static struct kobject base_probe(dev_t dev, int part, void *data)
488	{
489	if (request_module("char-major-%d-%d", MAJOR(dev), MINOR(dev)) > 0)
490	/* Make old-style 2.4 aliases work */
491	request_module("char-major-%d", MAJOR(dev));
492	return NULL;
493	}
494
495	void __init chrdev_init(void)
496	{
497	cdev_map = kobj_map_init(base_probe, &chrdevs_lock);
498	}
499
500
501	/* Let modules do char dev stuff */
502	EXPORT_SYMBOL(register_chrdev_region);
503	EXPORT_SYMBOL(unregister_chrdev_region);
504	EXPORT_SYMBOL(alloc_chrdev_region);
505	EXPORT_SYMBOL(cdev_init);
506	EXPORT_SYMBOL(cdev_alloc);
507	EXPORT_SYMBOL(cdev_del);
508	EXPORT_SYMBOL(cdev_add);
509	EXPORT_SYMBOL(register_chrdev);
510	EXPORT_SYMBOL(unregister_chrdev);