Энциклопедия разработчика модулей ядра Linux

 return ret_val;
 }
 printk("%s The major device number is %d.\n", "Registeration is a success", MAJOR_NUM);
 printk("If you want to talk to the device driver,\n");
 printk ("you'll have to create a device file. \n");
 printk ("We suggest you use:\n");
 printk ("mknod %s c %d 0\n", DEVICE_FILE_NAME, MAJOR_NUM);
 printk ("The device file name is important, because\n");
 printk ("the ioctl program assumes that's the\n");
 printk ("file you'll use.\n");
 return 0;
}

/* Cleanup - unregister the appropriate file from /proc */
void cleanup_module {
 int ret;
 /* Unregister the device */
 ret = module_unregister_chrdev(MAJOR_NUM, DEVICE_NAME);
 /* If there's an error, report it */
 if (ret < 0) printk("Error in module_unregister_chrdev: %d\n", ret);
}

chardev.h

/* chardev.h - the header file with the ioctl definitions.
*
* The declarations here have to be in a header file,
* because they need to be known both to the kernel
* module (in chardev.c) and the process calling ioctl (ioctl.c)
*/
#ifndef CHARDEV_H
#define CHARDEV_H #

include <linux/ioctl.h>
/* The major device number. We can't rely on dynamic
* registration any more, because ioctls need to know it. */
#define MAJOR_NUM 100

/* Set the message of the device driver */
#define IOCTL_SET_MSG _IOR(MAJOR_NUM, 0, char *)
/* _IOR means that we're creating an ioctl command
* number for passing information from a user process
* to the kernel module.
*
* The first arguments, MAJOR_NUM, is the major device
* number we're using.
*
* The second argument is the number of the command
* (there could be several with different meanings).
*
* The third argument is the type we want to get from
* the process to the kernel. */

/* Get the message of the device driver */
#define IOCTL_GET_MSG _IOR(MAJOR_NUM, 1, char *)
/* This IOCTL is used for output, to get the message
* of the device driver. However, we still need the
* buffer to place the message in to be input,
* as it is allocated by the process. */

/* Get the n'th byte of the message */
#define IOCTL_GET_NTH_BYTE _IOWR(MAJOR_NUM, 2, int)
/* The IOCTL is used for both input and output. It
* receives from the user a number, n, and returns Message[n]. */

/* The name of the device file */
#define DEVICE_FILE_NAME "char_dev"
#endif

ioctl.c

/* ioctl.c - the process to use ioctl's to control the
* kernel module
*
* Until now we could have used cat for input and
* output. But now we need to do ioctl's, which require
* writing our own process. */
/* Copyright (C) 1998 by Ori Pomerantz */

/* device specifics, such as ioctl numbers and the major device file. */
#include "chardev.h"
#include <fcntl.h> /* open */
#include <unistd.h> /* exit */
#include <sys/ioctl.h> /* ioctl */

/* Functions for the ioctl calls */
ioctl_set_msg(int file_desc, char *message) {
 int ret_val;
 ret_val = ioctl(file_desc, IOCTL_SET_MSG, message);
 if (ret_val < 0) {
 printf("ioctl_set_msg failed:%d\n", ret_val);
 exit(-1);
 }
}

ioctl_get_msg(int file_desc) {
 int ret_val;
 char message[100];
 /* Warning - this is dangerous because we don't tell
 * the kernel how far it's allowed to write, so it
 * might overflow the buffer. In a real production
 * program, we would have used two ioctls - one to tell
 * the kernel the buffer length and another to give
 * it the buffer to fill */
 ret_val = ioctl(file_desc, IOCTL_GET_MSG, message);
 if (ret_val < 0) {
 printf("ioctl_get_msg failed:%d\n", ret_val);
 exit(-1);
 }
 printf("get_msg message:%s\n", message);
}

ioctl_get_nth_byte(int file_desc) {
 int i;
 char c;
 printf("get_nth_byte message:");
 i = 0;
 while (c != 0) {
 c = ioctl(file_desc, IOCTL_GET_NTH_BYTE, i++);