http://comments.gmane.org/gmane.linux.kernel.kernelnewbies/41709

m.c

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/proc_fs.h>
#include "m.h"

#define OPTIMAL_COPY_SIZE	(32 * 1024)

int		init_module(void);
void		cleanup_module(void);
static int	m_open(struct inode *, struct file *);
static int	m_release(struct inode *, struct file *);
static long	m_ioctl(struct file *, unsigned int, unsigned long);
static int display_copy_count(char *buffer, char **start, off_t offset, int len, int *eof, void *data);

const struct file_operations m_fops = {
	.owner   = THIS_MODULE,
	.unlocked_ioctl   = m_ioctl,
	.open    = m_open,
	.release = m_release,
};

struct proc_dir_entry *cavium;
struct proc_dir_entry *copy_count;
unsigned long long COPY_COUNT;
unsigned long long CALL_COUNT;

static int display_copy_count(char *buffer, char **start, off_t offset, int len, int *eof, void *data)
{
	int count;

	count = sprintf(buffer, "No of calls .......: %lld\n", CALL_COUNT);
	count += sprintf(buffer + count, "Bytes copied ......: %lld\n", COPY_COUNT);
	*eof = 1;
	COPY_COUNT = 0;
	CALL_COUNT = 0;

	return count;
}

static int m_open(struct inode *inode, struct file *file)
{
	return 0;
}

static int m_release(struct inode *inode, struct file *file)
{
	return 0;
}

/* allocate and copy optimal size */
static long m_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	void __user *argp = (void __user *)arg;
	struct copy_cmd *ioctl_cmd;
	int rc = -1;

	int data_copied = 0, data_to_copy;
	char *data;

	switch (cmd) {
	case M_COPY_CMS:
		ioctl_cmd = (struct copy_cmd *) argp;

		while (data_copied < ioctl_cmd->copy_bytes) {
			if ((ioctl_cmd->copy_bytes - data_copied) >= OPTIMAL_COPY_SIZE)
				data_to_copy = OPTIMAL_COPY_SIZE;
			else
				data_to_copy = ioctl_cmd->copy_bytes - data_copied;

			data = kmalloc(data_to_copy, GFP_ATOMIC);
			if (data == NULL) {
				pr_info("%s:%d: out of memory\n", __func__, __LINE__);
				return rc;
			}

			if (copy_from_user(data, ioctl_cmd->copy_buffer, data_to_copy)  > 0) {
				pr_info("%s:%d: bad memory from user\n", __func__, __LINE__);
				kfree(data);
				return rc;
			}

			kfree(data);
			data_copied += data_to_copy;
			COPY_COUNT += data_to_copy;
			CALL_COUNT++;
		}

		rc = ioctl_cmd->copy_bytes;
	break;

	default:
		pr_info("m:invalid ioctl\n");
	}
	return rc;
}

int init_module()
{
	COPY_COUNT = 0;
	CALL_COUNT = 0;
	if (register_chrdev(M_DEVICE_MAJOR, "m", &m_fops)) {
		pr_info("m: init_module: unable to get major # %d\n", M_DEVICE_MAJOR);
		return -ENODEV;
	}

	cavium = proc_mkdir("cavium", NULL);
	if (cavium == NULL) {
		pr_info("m:unable to creat /proc/cavium");
		goto unregister;
	}

	copy_count = create_proc_entry("copy_count", S_IFREG|S_IRUGO, cavium);
	if (copy_count == NULL) {
		pr_info("m:unable to creat /proc/cavium/copy_count");
		goto remove_cavium;
	}

	copy_count->read_proc = display_copy_count;
	copy_count->write_proc = NULL;

	pr_info("module:m loaded\n");

normal:
	return 0;

remove_cavium:
	remove_proc_entry("cavium", NULL);

unregister:
	unregister_chrdev(M_DEVICE_MAJOR, "m");

	goto normal;
}

void cleanup_module()
{
	remove_proc_entry("copy_count", cavium);
	remove_proc_entry("cavium", NULL);
	unregister_chrdev(M_DEVICE_MAJOR, "m");
	pr_info("module:m unloaded\n");
}