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

 /* We need to return the number of input characters used */
 return i;
}

/* This function decides whether to allow an operation
* (return zero) or not allow it (return a non-zero
* which indicates why it is not allowed).
*
* The operation can be one of the following values:
* 0 - Execute (run the "file" - meaningless in our case)
* 2 - Write (input to the kernel module)
* 4 - Read (output from the kernel module)
*
* This is the real function that checks file
* permissions. The permissions returned by ls -l are
* for reference only, and can be overridden here. */
static int module_permission(struct inode *inode, int op) {
 /* We allow everybody to read from our module, but only root (uid 0) may write to it */
 if (op == 4 || (op == 2 && current->euid == 0)) return 0;
 /* If it's anything else, access is denied */
 return -EACCES;
}

/* The file is opened - we don't really care about
* that, but it does mean we need to increment the
* module's reference count. */
int module_open(struct inode *inode, struct file *file) {
 MOD_INC_USE_COUNT;
 return 0;
}

/* The file is closed - again, interesting only because of the reference count. */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
int module_close(struct inode *inode, struct file *file)
#else
void module_close(struct inode *inode, struct file *file)
#endif
{
 MOD_DEC_USE_COUNT;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
 return 0; /* success */
#endif
}

/* Structures to register as the /proc file, with
* pointers to all the relevant functions. ********** */

/* File operations for our proc file. This is where we
* place pointers to all the functions called when
* somebody tries to do something to our file. NULL
* means we don't want to deal with something. */
static struct file_operations File_Ops_4_Our_Proc_File = {
 NULL, /* lseek */
 module_output, /* "read" from the file */
 module_input, /* "write" to the file */
 NULL, /* readdir */
 NULL, /* select */
 NULL, /* ioctl */
 NULL, /* mmap */
 module_open, /* Somebody opened the file */
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
 NULL, /* flush, added here in version 2.2 */
#endif
 module_close, /* Somebody closed the file */
 /* etc. etc. etc. (they are all given in
 * /usr/include/linux/fs.h). Since we don't put
 * anything here, the system will keep the default
 * data, which in Unix is zeros (NULLs when taken as pointers). */
};

/* Inode operations for our proc file. We need it so
* we'll have some place to specify the file operations
* structure we want to use, and the function we use for
* permissions. It's also possible to specify functions
* to be called for anything else which could be done to
* an inode (although we don't bother, we just put NULL). */
static struct inode_operations Inode_Ops_4_Our_Proc_File = {
 &File_Ops_4_Our_Proc_File,
 NULL, /* create */
 NULL, /* lookup */
 NULL, /* link */
 NULL, /* unlink */
 NULL, /* symlink */
 NULL, /* mkdir */
 NULL, /* rmdir */
 NULL, /* mknod */
 NULL, /* rename */
 NULL, /* readlink */
 NULL, /* follow_link */
 NULL, /* readpage */
 NULL, /* writepage */
 NULL, /* bmap */
 NULL, /* truncate */
 module_permission /* check for permissions */
};

/* Directory entry */
static struct proc_dir_entry Our_Proc_File = {
 0, /* Inode number - ignore, it will be filled by proc_register[_dynamic] */
 7, /* Length of the file name */
 "rw_test", /* The file name */
 S_IFREG | S_IRUGO | S_IWUSR,
 /* File mode - this is a regular file which
 * can be read by its owner, its group, and everybody
 * else. Also, its owner can write to it.
 *
 * Actually, this field is just for reference, it's