[linux-block.git] / Documentation / DocBook / procfs_example.c

/*
 * procfs_example.c: an example proc interface
 *
 * Copyright (C) 2001, Erik Mouw (mouw@nl.linux.org)
 *
 * This file accompanies the procfs-guide in the Linux kernel
 * source. Its main use is to demonstrate the concepts and
 * functions described in the guide.
 *
 * This software has been developed while working on the LART
 * computing board (http://www.lartmaker.nl), which was sponsored
 * by the Delt University of Technology projects Mobile Multi-media
 * Communications and Ubiquitous Communications.
 *
 * This program is free software; you can redistribute
 * it and/or modify it under the terms of the GNU General
 * Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be
 * useful, but WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE.  See the GNU General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place,
 * Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/jiffies.h>
#include <asm/uaccess.h>


#define MODULE_VERS "1.0"
#define MODULE_NAME "procfs_example"

#define FOOBAR_LEN 8

struct fb_data_t {
	char name[FOOBAR_LEN + 1];
	char value[FOOBAR_LEN + 1];
};


static struct proc_dir_entry *example_dir, *foo_file,
	*bar_file, *jiffies_file, *symlink;


struct fb_data_t foo_data, bar_data;


static int proc_read_jiffies(char *page, char **start,
			     off_t off, int count,
			     int *eof, void *data)
{
	int len;

	len = sprintf(page, "jiffies = %ld\n",
                      jiffies);

	return len;
}


static int proc_read_foobar(char *page, char **start,
			    off_t off, int count, 
			    int *eof, void *data)
{
	int len;
	struct fb_data_t *fb_data = (struct fb_data_t *)data;

	/* DON'T DO THAT - buffer overruns are bad */
	len = sprintf(page, "%s = '%s'\n", 
		      fb_data->name, fb_data->value);

	return len;
}


static int proc_write_foobar(struct file *file,
			     const char *buffer,
			     unsigned long count, 
			     void *data)
{
	int len;
	struct fb_data_t *fb_data = (struct fb_data_t *)data;

	if(count > FOOBAR_LEN)
		len = FOOBAR_LEN;
	else
		len = count;

	if(copy_from_user(fb_data->value, buffer, len))
		return -EFAULT;

	fb_data->value[len] = '\0';

	return len;
}


static int __init init_procfs_example(void)
{
	int rv = 0;

	/* create directory */
	example_dir = proc_mkdir(MODULE_NAME, NULL);
	if(example_dir == NULL) {
		rv = -ENOMEM;
		goto out;
	}
	/* create jiffies using convenience function */
	jiffies_file = create_proc_read_entry("jiffies", 
					      0444, example_dir, 
					      proc_read_jiffies,
					      NULL);
	if(jiffies_file == NULL) {
		rv  = -ENOMEM;
		goto no_jiffies;
	}

	/* create foo and bar files using same callback
	 * functions 
	 */
	foo_file = create_proc_entry("foo", 0644, example_dir);
	if(foo_file == NULL) {
		rv = -ENOMEM;
		goto no_foo;
	}

	strcpy(foo_data.name, "foo");
	strcpy(foo_data.value, "foo");
	foo_file->data = &foo_data;
	foo_file->read_proc = proc_read_foobar;
	foo_file->write_proc = proc_write_foobar;
		
	bar_file = create_proc_entry("bar", 0644, example_dir);
	if(bar_file == NULL) {
		rv = -ENOMEM;
		goto no_bar;
	}

	strcpy(bar_data.name, "bar");
	strcpy(bar_data.value, "bar");
	bar_file->data = &bar_data;
	bar_file->read_proc = proc_read_foobar;
	bar_file->write_proc = proc_write_foobar;
		
	/* create symlink */
	symlink = proc_symlink("jiffies_too", example_dir, 
			       "jiffies");
	if(symlink == NULL) {
		rv = -ENOMEM;
		goto no_symlink;
	}

	/* everything OK */
	printk(KERN_INFO "%s %s initialised\n",
	       MODULE_NAME, MODULE_VERS);
	return 0;

no_symlink:
	remove_proc_entry("bar", example_dir);
no_bar:
	remove_proc_entry("foo", example_dir);
no_foo:
	remove_proc_entry("jiffies", example_dir);
no_jiffies:			      
	remove_proc_entry(MODULE_NAME, NULL);
out:
	return rv;
}


static void __exit cleanup_procfs_example(void)
{
	remove_proc_entry("jiffies_too", example_dir);
	remove_proc_entry("bar", example_dir);
	remove_proc_entry("foo", example_dir);
	remove_proc_entry("jiffies", example_dir);
	remove_proc_entry(MODULE_NAME, NULL);

	printk(KERN_INFO "%s %s removed\n",
	       MODULE_NAME, MODULE_VERS);
}


module_init(init_procfs_example);
module_exit(cleanup_procfs_example);

MODULE_AUTHOR("Erik Mouw");
MODULE_DESCRIPTION("procfs examples");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* procfs_example.c: an example proc interface
	3	*
758222f8	4	* Copyright (C) 2001, Erik Mouw (mouw@nl.linux.org)
1da177e4 LT	5	*
	6	* This file accompanies the procfs-guide in the Linux kernel
	7	* source. Its main use is to demonstrate the concepts and
	8	* functions described in the guide.
	9	*
	10	* This software has been developed while working on the LART
758222f8 RD	11	* computing board (http://www.lartmaker.nl), which was sponsored
	12	* by the Delt University of Technology projects Mobile Multi-media
	13	* Communications and Ubiquitous Communications.
1da177e4 LT	14	*
	15	* This program is free software; you can redistribute
	16	* it and/or modify it under the terms of the GNU General
	17	* Public License as published by the Free Software
	18	* Foundation; either version 2 of the License, or (at your
	19	* option) any later version.
	20	*
	21	* This program is distributed in the hope that it will be
	22	* useful, but WITHOUT ANY WARRANTY; without even the implied
	23	* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
	24	* PURPOSE. See the GNU General Public License for more
	25	* details.
	26	*
	27	* You should have received a copy of the GNU General Public
	28	* License along with this program; if not, write to the
	29	* Free Software Foundation, Inc., 59 Temple Place,
	30	* Suite 330, Boston, MA 02111-1307 USA
	31	*
	32	*/
	33
	34	#include <linux/module.h>
	35	#include <linux/kernel.h>
	36	#include <linux/init.h>
	37	#include <linux/proc_fs.h>
	38	#include <linux/jiffies.h>
	39	#include <asm/uaccess.h>
	40
	41
	42	#define MODULE_VERS "1.0"
	43	#define MODULE_NAME "procfs_example"
	44
	45	#define FOOBAR_LEN 8
	46
	47	struct fb_data_t {
	48	char name[FOOBAR_LEN + 1];
	49	char value[FOOBAR_LEN + 1];
	50	};
	51
	52
	53	static struct proc_dir_entry example_dir, foo_file,
	54	bar_file, jiffies_file, *symlink;
	55
	56
	57	struct fb_data_t foo_data, bar_data;
	58
	59
	60	static int proc_read_jiffies(char page, char *start,
	61	off_t off, int count,
	62	int eof, void data)
	63	{
	64	int len;
	65
	66	len = sprintf(page, "jiffies = %ld\n",
	67	jiffies);
	68
	69	return len;
	70	}
	71
	72
	73	static int proc_read_foobar(char page, char *start,
	74	off_t off, int count,
	75	int eof, void data)
	76	{
	77	int len;
78	struct fb_data_t fb_data = (struct fb_data_t )data;
79
80	/* DON'T DO THAT - buffer overruns are bad */
81	len = sprintf(page, "%s = '%s'\n",
82	fb_data->name, fb_data->value);
83
84	return len;
85	}
86
87
88	static int proc_write_foobar(struct file *file,
89	const char *buffer,
90	unsigned long count,
91	void *data)
92	{
93	int len;
94	struct fb_data_t fb_data = (struct fb_data_t )data;
95
96	if(count > FOOBAR_LEN)
97	len = FOOBAR_LEN;
98	else
99	len = count;
100
101	if(copy_from_user(fb_data->value, buffer, len))
102	return -EFAULT;
103
104	fb_data->value[len] = '\0';
105
106	return len;
107	}
108
109
110	static int __init init_procfs_example(void)
111	{
112	int rv = 0;
113
114	/* create directory */
115	example_dir = proc_mkdir(MODULE_NAME, NULL);
116	if(example_dir == NULL) {
117	rv = -ENOMEM;
118	goto out;
119	}
1da177e4 LT	120	/* create jiffies using convenience function */
	121	jiffies_file = create_proc_read_entry("jiffies",
	122	0444, example_dir,
	123	proc_read_jiffies,
	124	NULL);
	125	if(jiffies_file == NULL) {
	126	rv = -ENOMEM;
	127	goto no_jiffies;
	128	}
	129
1da177e4 LT	130	/* create foo and bar files using same callback
	131	* functions
	132	*/
	133	foo_file = create_proc_entry("foo", 0644, example_dir);
	134	if(foo_file == NULL) {
	135	rv = -ENOMEM;
	136	goto no_foo;
	137	}
	138
	139	strcpy(foo_data.name, "foo");
	140	strcpy(foo_data.value, "foo");
	141	foo_file->data = &foo_data;
	142	foo_file->read_proc = proc_read_foobar;
	143	foo_file->write_proc = proc_write_foobar;
1da177e4 LT	144
	145	bar_file = create_proc_entry("bar", 0644, example_dir);
	146	if(bar_file == NULL) {
	147	rv = -ENOMEM;
	148	goto no_bar;
	149	}
	150
	151	strcpy(bar_data.name, "bar");
	152	strcpy(bar_data.value, "bar");
	153	bar_file->data = &bar_data;
	154	bar_file->read_proc = proc_read_foobar;
	155	bar_file->write_proc = proc_write_foobar;
1da177e4 LT	156
	157	/* create symlink */
	158	symlink = proc_symlink("jiffies_too", example_dir,
	159	"jiffies");
	160	if(symlink == NULL) {
	161	rv = -ENOMEM;
	162	goto no_symlink;
	163	}
	164
1da177e4 LT	165	/* everything OK */
	166	printk(KERN_INFO "%s %s initialised\n",
	167	MODULE_NAME, MODULE_VERS);
	168	return 0;
	169
	170	no_symlink:
1da177e4 LT	171	remove_proc_entry("bar", example_dir);
	172	no_bar:
	173	remove_proc_entry("foo", example_dir);
	174	no_foo:
	175	remove_proc_entry("jiffies", example_dir);
	176	no_jiffies:
	177	remove_proc_entry(MODULE_NAME, NULL);
	178	out:
	179	return rv;
	180	}
	181
	182
	183	static void __exit cleanup_procfs_example(void)
	184	{
	185	remove_proc_entry("jiffies_too", example_dir);
1da177e4 LT	186	remove_proc_entry("bar", example_dir);
	187	remove_proc_entry("foo", example_dir);
	188	remove_proc_entry("jiffies", example_dir);
	189	remove_proc_entry(MODULE_NAME, NULL);
	190
	191	printk(KERN_INFO "%s %s removed\n",
	192	MODULE_NAME, MODULE_VERS);
	193	}
	194
	195
	196	module_init(init_procfs_example);
	197	module_exit(cleanup_procfs_example);
	198
	199	MODULE_AUTHOR("Erik Mouw");
	200	MODULE_DESCRIPTION("procfs examples");
5d39d944	201	MODULE_LICENSE("GPL");