summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: d43259c)
raw | patch | inline | side by side (parent: d43259c)
| author | Jim Huang <jserv@biilabs.io> | |
| Sat, 7 Aug 2021 17:24:59 +0000 (01:24 +0800) | ||
| committer | Jim Huang <jserv@biilabs.io> | |
| Sat, 7 Aug 2021 17:24:59 +0000 (01:24 +0800) |
This patch makes source listing shorter and more compact, that helps
when browsing.
when browsing.
32 files changed:
diff --git a/examples/bottomhalf.c b/examples/bottomhalf.c
index 4fa4e34f4d9991650a3f4dfa74b611874a5bd680..9117d1b70eb7bd16c55459ab0da9a62db2bde556 100644 (file)
--- a/examples/bottomhalf.c
+++ b/examples/bottomhalf.c
* from:
* https://github.com/wendlers/rpi-kmod-samples
*
- * Press one button to turn on a LED and another to turn it off
+ * Press one button to turn on a LED and another to turn it off
*/
#include <linux/delay.h>
static int button_irqs[] = {-1, -1};
/* Define GPIOs for LEDs.
- Change the numbers for the GPIO on your board. */
+ * TODO: Change the numbers for the GPIO on your board.
+ */
static struct gpio leds[] = {{4, GPIOF_OUT_INIT_LOW, "LED 1"}};
/* Define GPIOs for BUTTONS
- Change the numbers for the GPIO on your board. */
+ * TODO: Change the numbers for the GPIO on your board.
+ */
static struct gpio buttons[] = {
{17, GPIOF_IN, "LED 1 ON BUTTON"},
{18, GPIOF_IN, "LED 1 OFF BUTTON"},
DECLARE_TASKLET(buttontask, bottomhalf_tasklet_fn, 0L);
-/*
- * interrupt function triggered when a button is pressed
- */
+/* interrupt function triggered when a button is pressed */
static irqreturn_t button_isr(int irq, void *data)
{
/* Do something quickly right now */
diff --git a/examples/chardev.c b/examples/chardev.c
index 096a4bb03cb2aaf051c97e5fc4c725c3e12b66ac..138fe81b13316343ca4255fc1c4198ddbc518e3a 100644 (file)
--- a/examples/chardev.c
+++ b/examples/chardev.c
/*
- * chardev.c: Creates a read-only char device that says how many times
- * you have read from the dev file
+ * chardev.c: Creates a read-only char device that says how many times
+ * you have read from the dev file
*/
#include <linux/cdev.h>
diff --git a/examples/chardev.h b/examples/chardev.h
index 136ffed3a385e797d68717f9b47f9cf892ace6cb..98532998e8982de4c9c631fa692ea9dd0bf29995 100644 (file)
--- a/examples/chardev.h
+++ b/examples/chardev.h
/*
- * chardev.h - the header file with the ioctl definitions.
+ * 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)
+ * 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
#include <linux/ioctl.h>
-/*
- * The major device number. We can't rely on dynamic
- * registration any more, because ioctls need to know
- * it.
+/* The major device number. We can not rely on dynamic registration
+ * any more, because ioctls need to know it.
*/
#define MAJOR_NUM 100
-/*
- * Set the message of the device driver
- */
+/* Set the message of the device driver */
#define IOCTL_SET_MSG _IOW(MAJOR_NUM, 0, char *)
-/*
- * _IOW means that we're creating an ioctl command
- * number for passing information from a user process
- * to the kernel module.
+/* _IOW means that we are 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 first arguments, MAJOR_NUM, is the major device number we are using.
*
- * The second argument is the number of the command
- * (there could be several with different meanings).
+ * 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.
+ * The third argument is the type we want to get from the process to the
+ * kernel.
*/
-/*
- * Get the message of the device driver
- */
+/* 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,
+/* 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
- */
+/* 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 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
- */
+/* The name of the device file */
#define DEVICE_FILE_NAME "char_dev"
#endif
diff --git a/examples/chardev2.c b/examples/chardev2.c
index 013e55fc05e9bd72005e41a1d475102d90da1775..60d2345d9a94a174228f8299b67a68463ccc1a6f 100644 (file)
--- a/examples/chardev2.c
+++ b/examples/chardev2.c
/*
- * chardev2.c - Create an input/output character device
+ * chardev2.c - Create an input/output character device
*/
#include <linux/cdev.h>
#define DEVICE_NAME "char_dev"
#define BUF_LEN 80
-/*
- * Is the device open right now? Used to prevent
- * concurent access into the same device
+/* Is the device open right now? Used to prevent concurent access into
+ * the same device
*/
static int Device_Open = 0;
-/*
- * The message the device will give when asked
- */
+/* The message the device will give when asked */
static char Message[BUF_LEN];
-/*
- * How far did the process reading the message get?
- * Useful if the message is larger than the size of the
- * buffer we get to fill in device_read.
+/* How far did the process reading the message get? Useful if the message
+ * is larger than the size of the buffer we get to fill in device_read.
*/
static char *Message_Ptr;
-static int Major; /* Major number assigned to our device driver */
+/* Major number assigned to our device driver */
+static int Major;
static struct class *cls;
-/*
- * This is called whenever a process attempts to open the device file
- */
+/* This is called whenever a process attempts to open the device file */
static int device_open(struct inode *inode, struct file *file)
{
pr_info("device_open(%p)\n", file);
- /*
- * We don't want to talk to two processes at the same time
- */
+ /* We don't want to talk to two processes at the same time. */
if (Device_Open)
return -EBUSY;
Device_Open++;
- /*
- * Initialize the message
- */
+ /* Initialize the message */
Message_Ptr = Message;
try_module_get(THIS_MODULE);
return SUCCESS;
{
pr_info("device_release(%p,%p)\n", inode, file);
- /*
- * We're now ready for our next caller
- */
+ /* We're now ready for our next caller */
Device_Open--;
module_put(THIS_MODULE);
return SUCCESS;
}
-/*
- * This function is called whenever a process which has already opened the
+/* This function is called whenever a process which has already opened the
* device file attempts to read from it.
*/
static ssize_t device_read(struct file *file, /* see include/linux/fs.h */
- char __user *buffer, /* buffer to be
- * filled with data */
+ char __user *buffer, /* buffer to be filled */
size_t length, /* length of the buffer */
loff_t *offset)
{
- /*
- * Number of bytes actually written to the buffer
- */
+ /* Number of bytes actually written to the buffer */
int bytes_read = 0;
pr_info("device_read(%p,%p,%ld)\n", file, buffer, length);
- /*
- * If we're at the end of the message, return 0
- * (which signifies end of file)
- */
+ /* If at the end of message, return 0 (which signifies end of file). */
if (*Message_Ptr == 0)
return 0;
- /*
- * Actually put the data into the buffer
- */
+ /* Actually put the data into the buffer */
while (length && *Message_Ptr) {
- /*
- * Because the buffer is in the user data segment,
- * not the kernel data segment, assignment wouldn't
- * work. Instead, we have to use put_user which
- * copies data from the kernel data segment to the
- * user data segment.
+ /* Because the buffer is in the user data segment, not the kernel
+ * data segment, assignment would not work. Instead, we have to
+ * use put_user which copies data from the kernel data segment to
+ * the user data segment.
*/
put_user(*(Message_Ptr++), buffer++);
length--;
pr_info("Read %d bytes, %ld left\n", bytes_read, length);
- /*
- * Read functions are supposed to return the number
- * of bytes actually inserted into the buffer
+ /* Read functions are supposed to return the number of bytes actually
+ * inserted into the buffer.
*/
return bytes_read;
}
-/*
- * This function is called when somebody tries to
- * write into our device file.
- */
+/* called when somebody tries to write into our device file. */
static ssize_t device_write(struct file *file,
const char __user *buffer,
size_t length,
Message_Ptr = Message;
- /*
- * Again, return the number of input characters used
- */
+ /* Again, return the number of input characters used. */
return i;
}
-/*
- * This function is called whenever a process tries to do an ioctl on our
+/* This function is called whenever a process tries to do an ioctl on our
* device file. We get two extra parameters (additional to the inode and file
* structures, which all device functions get): the number of the ioctl called
* and the parameter given to the ioctl function.
*
* If the ioctl is write or read/write (meaning output is returned to the
* calling process), the ioctl call returns the output of this function.
- *
*/
long device_ioctl(struct file *file, /* ditto */
unsigned int ioctl_num, /* number and param for ioctl */
char *temp;
char ch;
- /*
- * Switch according to the ioctl called
- */
+ /* Switch according to the ioctl called */
switch (ioctl_num) {
case IOCTL_SET_MSG:
- /*
- * Receive a pointer to a message (in user space) and set that
- * to be the device's message. Get the parameter given to
- * ioctl by the process.
+ /* Receive a pointer to a message (in user space) and set that to
+ * be the device's message. Get the parameter given to ioctl by
+ * the process.
*/
temp = (char *) ioctl_param;
- /*
- * Find the length of the message
- */
+ /* Find the length of the message */
get_user(ch, temp);
for (i = 0; ch && i < BUF_LEN; i++, temp++)
get_user(ch, temp);
break;
case IOCTL_GET_MSG:
- /*
- * Give the current message to the calling process -
- * the parameter we got is a pointer, fill it.
+ /* Give the current message to the calling process - the parameter
+ * we got is a pointer, fill it.
*/
i = device_read(file, (char *) ioctl_param, 99, 0);
- /*
- * Put a zero at the end of the buffer, so it will be
- * properly terminated
+ /* Put a zero at the end of the buffer, so it will be properly
+ * terminated.
*/
put_user('\0', (char *) ioctl_param + i);
break;
case IOCTL_GET_NTH_BYTE:
- /*
- * This ioctl is both input (ioctl_param) and
- * output (the return value of this function)
+ /* This ioctl is both input (ioctl_param) and output (the return
+ * value of this function).
*/
return Message[ioctl_param];
break;
/* Module Declarations */
-/*
- * This structure will hold the functions to be called
- * when a process does something to the device we
- * created. Since a pointer to this structure is kept in
- * the devices table, it can't be local to
- * init_module. NULL is for unimplemented functions.
+/* This structure will hold the functions to be called when a process does
+ * something to the device we created. Since a pointer to this structure
+ * is kept in the devices table, it can't be local to init_module. NULL is
+ * for unimplemented functions.
*/
struct file_operations Fops = {
.read = device_read,
diff --git a/examples/completions.c b/examples/completions.c
index b3b472e3450c46d4580b7f2f873b4efb37c47654..64e0ec2c87abfe3db967a1cd79e43202efed7851 100644 (file)
--- a/examples/completions.c
+++ b/examples/completions.c
/*
- * completions.c
+ * completions.c
*/
#include <linux/completion.h>
#include <linux/init.h>
index 63c54841c7e0c2b7a441043583ca8be414377599..02e3a0792f13cd30d2bbe1137d57937396834e09 100644 (file)
--- a/examples/cryptosha256.c
+++ b/examples/cryptosha256.c
/*
- * cryptosha256.c
+ * cryptosha256.c
*/
#include <crypto/internal/hash.h>
#include <linux/module.h>
diff --git a/examples/cryptosk.c b/examples/cryptosk.c
index c5ec7b11b3d17d879cc8db089520ee1b1d6abd58..82af61687a74f501f1d4662d9311a94ab3250490 100644 (file)
--- a/examples/cryptosk.c
+++ b/examples/cryptosk.c
/*
- * cryptosk.c
+ * cryptosk.c
*/
#include <crypto/internal/skcipher.h>
#include <linux/crypto.h>
static void test_skcipher_callback(struct crypto_async_request *req, int error)
{
struct tcrypt_result *result = req->data;
- /* int ret; */
if (error == -EINPROGRESS)
return;
pr_info("Encryption finished successfully\n");
/* decrypt data */
- /*
+#if 0
memset((void*)sk.scratchpad, '-', CIPHER_BLOCK_SIZE);
ret = crypto_skcipher_decrypt(sk.req);
ret = test_skcipher_result(&sk, ret);
pr_info("Decryption request successful\n");
pr_info("Decrypted: %s\n", sk.scratchpad);
- */
+#endif
}
static int test_skcipher_encrypt(char *plaintext,
diff --git a/examples/devicemodel.c b/examples/devicemodel.c
index 07d30ec540a177138bf8d45efc6abd91d0ce7749..b8f855b4d4f9be52d5d644fecafe8303479555f4 100644 (file)
--- a/examples/devicemodel.c
+++ b/examples/devicemodel.c
/*
- * devicemodel.c
+ * devicemodel.c
*/
#include <linux/kernel.h>
#include <linux/module.h>
index 48fb004d01c20bb806449207b9e2bd71b422334b..d9eee866d04f1953dcddaf0e45700b5fe475401d 100644 (file)
/*
- * example_atomic.c
+ * example_atomic.c
*/
#include <linux/interrupt.h>
#include <linux/kernel.h>
index d63cceee71563ecbb92ae75b3a5a601beeeb3ac8..653a50e739549ae0208bf37b6aea680837a1c949 100644 (file)
--- a/examples/example_mutex.c
+++ b/examples/example_mutex.c
/*
- * example_mutex.c
+ * example_mutex.c
*/
#include <linux/init.h>
#include <linux/kernel.h>
index bca5218833c58888b58735f4a805e6620894cc56..9ef05673a13087b1dd4819a86f34c799153f14e4 100644 (file)
/*
- * example_rwlock.c
+ * example_rwlock.c
*/
#include <linux/interrupt.h>
#include <linux/kernel.h>
index 0d0d88ec7fd7e14ff959227a10c8433298d0dee4..337c9d4b794af1793bd6458e5bdc374bfeaa17c3 100644 (file)
/*
- * example_spinlock.c
+ * example_spinlock.c
*/
#include <linux/init.h>
#include <linux/interrupt.h>
spin_lock_irqsave(&sl_static, flags);
pr_info("Locked static spinlock\n");
- /* Do something or other safely.
- Because this uses 100% CPU time this
- code should take no more than a few
- milliseconds to run */
+ /* Do something or other safely. Because this uses 100% CPU time, this
+ * code should take no more than a few milliseconds to run.
+ */
spin_unlock_irqrestore(&sl_static, flags);
pr_info("Unlocked static spinlock\n");
spin_lock_irqsave(&sl_dynamic, flags);
pr_info("Locked dynamic spinlock\n");
- /* Do something or other safely.
- Because this uses 100% CPU time this
- code should take no more than a few
- milliseconds to run */
+ /* Do something or other safely. Because this uses 100% CPU time, this
+ * code should take no more than a few milliseconds to run.
+ */
spin_unlock_irqrestore(&sl_dynamic, flags);
pr_info("Unlocked dynamic spinlock\n");
index 372db15b5ae72a0d29ab2fd4fe50941ec54907dc..a0cbd3c94858cfd4cc7adfba1ba99679355a44e2 100644 (file)
/*
- * example_tasklet.c
+ * example_tasklet.c
*/
#include <linux/delay.h>
#include <linux/interrupt.h>
diff --git a/examples/hello-1.c b/examples/hello-1.c
index e4fb93ae4ed2f49d134b9ebf3179fa7eba956ad3..c12d9211473fa5ec5857e9bc5a77b0f926f84d4f 100644 (file)
--- a/examples/hello-1.c
+++ b/examples/hello-1.c
/*
- * hello-1.c - The simplest kernel module.
+ * hello-1.c - The simplest kernel module.
*/
#include <linux/kernel.h> /* Needed for KERN_INFO */
#include <linux/module.h> /* Needed by all modules */
diff --git a/examples/hello-2.c b/examples/hello-2.c
index 8987fab08187bf2ad9cafb45cab96b85c432e6e7..503dcce3a8727f28a3c7a6abce9c6f1a191fa8e5 100644 (file)
--- a/examples/hello-2.c
+++ b/examples/hello-2.c
/*
- * hello-2.c - Demonstrating the module_init() and module_exit() macros.
- * This is preferred over using init_module() and cleanup_module().
+ * hello-2.c - Demonstrating the module_init() and module_exit() macros.
+ * This is preferred over using init_module() and cleanup_module().
*/
#include <linux/init.h> /* Needed for the macros */
#include <linux/kernel.h> /* Needed for KERN_INFO */
diff --git a/examples/hello-3.c b/examples/hello-3.c
index 6bb052b6ac60e01ae71d420b3e778cbccad7136e..bcfa8044f134353d26cde20cf7907b97ec044df0 100644 (file)
--- a/examples/hello-3.c
+++ b/examples/hello-3.c
/*
- * hello-3.c - Illustrating the __init, __initdata and __exit macros.
+ * hello-3.c - Illustrating the __init, __initdata and __exit macros.
*/
#include <linux/init.h> /* Needed for the macros */
#include <linux/kernel.h> /* Needed for KERN_INFO */
diff --git a/examples/hello-4.c b/examples/hello-4.c
index 1ad8b8c3a8eae9c36af6c2ce6ec550b8fb75e591..2deb72117c6acac3da82580eaf0ca0cf84bdbe85 100644 (file)
--- a/examples/hello-4.c
+++ b/examples/hello-4.c
/*
- * hello-4.c - Demonstrates module documentation.
+ * hello-4.c - Demonstrates module documentation.
*/
#include <linux/init.h> /* Needed for the macros */
#include <linux/kernel.h> /* Needed for KERN_INFO */
diff --git a/examples/hello-5.c b/examples/hello-5.c
index 414c9942fa2a48f90551662dc48a5bcc58e06862..dd97d461b7f3ec3740eae55837db5ece16f24a84 100644 (file)
--- a/examples/hello-5.c
+++ b/examples/hello-5.c
/*
- * hello-5.c - Demonstrates command line argument passing to a module.
+ * hello-5.c - Demonstrates command line argument passing to a module.
*/
#include <linux/init.h>
#include <linux/kernel.h>
static int myintArray[2] = {420, 420};
static int arr_argc = 0;
-/*
- * module_param(foo, int, 0000)
- * The first param is the parameters name
- * The second param is it's data type
+/* module_param(foo, int, 0000)
+ * The first param is the parameters name.
+ * The second param is its data type.
* The final argument is the permissions bits,
* for exposing parameters in sysfs (if non-zero) at a later stage.
*/
-
module_param(myshort, short, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
MODULE_PARM_DESC(myshort, "A short integer");
module_param(myint, int, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
module_param(mystring, charp, 0000);
MODULE_PARM_DESC(mystring, "A character string");
-/*
- * module_param_array(name, type, num, perm);
- * The first param is the parameter's (in this case the array's) name
- * The second param is the data type of the elements of the array
- * The third argument is a pointer to the variable that will store the number
- * of elements of the array initialized by the user at module loading time
- * The fourth argument is the permission bits
+/* module_param_array(name, type, num, perm);
+ * The first param is the parameter's (in this case the array's) name.
+ * The second param is the data type of the elements of the array.
+ * The third argument is a pointer to the variable that will store the number.
+ * of elements of the array initialized by the user at module loading time.
+ * The fourth argument is the permission bits.
*/
module_param_array(myintArray, int, &arr_argc, 0000);
MODULE_PARM_DESC(myintArray, "An array of integers");
diff --git a/examples/hello-sysfs.c b/examples/hello-sysfs.c
index f764e67fd24a93de3f1e3986df56b6cbb98da896..4be12096161fec71e934b1110bbfe1516c6778b8 100644 (file)
--- a/examples/hello-sysfs.c
+++ b/examples/hello-sysfs.c
/*
- * hello-sysfs.c sysfs example
+ * hello-sysfs.c sysfs example
*/
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/sysfs.h>
-MODULE_LICENSE("GPL");
-
static struct kobject *mymodule;
/* the variable you want to be able to change */
module_init(mymodule_init);
module_exit(mymodule_exit);
+
+MODULE_LICENSE("GPL");
diff --git a/examples/intrpt.c b/examples/intrpt.c
index a506837be28a3e82fb94e76f3fd88c8faf1fcc97..37aca49c7f1b73c8c1674a5f826abb96c832f4aa 100644 (file)
--- a/examples/intrpt.c
+++ b/examples/intrpt.c
/*
- * intrpt.c - Handling GPIO with interrupts
+ * intrpt.c - Handling GPIO with interrupts
*
- * Based upon the RPi example by Stefan Wendler (devnull@kaltpost.de)
- * from:
- * https://github.com/wendlers/rpi-kmod-samples
+ * Based upon the RPi example by Stefan Wendler (devnull@kaltpost.de)
+ * from:
+ * https://github.com/wendlers/rpi-kmod-samples
*
- * Press one button to turn on a LED and another to turn it off
+ * Press one button to turn on a LED and another to turn it off.
*/
#include <linux/gpio.h>
static int button_irqs[] = {-1, -1};
/* Define GPIOs for LEDs.
- Change the numbers for the GPIO on your board. */
+ * TODO: Change the numbers for the GPIO on your board.
+ */
static struct gpio leds[] = {{4, GPIOF_OUT_INIT_LOW, "LED 1"}};
/* Define GPIOs for BUTTONS
- Change the numbers for the GPIO on your board. */
+ * TODO: Change the numbers for the GPIO on your board.
+ */
static struct gpio buttons[] = {{17, GPIOF_IN, "LED 1 ON BUTTON"},
{18, GPIOF_IN, "LED 1 OFF BUTTON"}};
-/*
- * interrupt function triggered when a button is pressed
- */
+/* interrupt function triggered when a button is pressed. */
static irqreturn_t button_isr(int irq, void *data)
{
/* first button */
diff --git a/examples/ioctl.c b/examples/ioctl.c
index f847500f01cd9770146876da85aadb7c68d8ff30..bc057f5dd02c35b5089a87374ad6a30cc57dc513 100644 (file)
--- a/examples/ioctl.c
+++ b/examples/ioctl.c
/*
- * ioctl.c
+ * ioctl.c
*/
#include <linux/cdev.h>
#include <linux/fs.h>
switch (cmd) {
case IOCTL_VALSET:
-
- /*
- if (!capable(CAP_SYS_ADMIN)) {
- retval = -EPERM;
- goto done;
- }
- if (!access_ok(VERIFY_READ, (void __user *)arg, _IOC_SIZE(cmd))) {
- retval = -EFAULT;
- goto done;
- }
- */
if (copy_from_user(&data, (int __user *) arg, sizeof(data))) {
retval = -EFAULT;
goto done;
break;
case IOCTL_VALGET:
- /*
- if (!access_ok(VERIFY_WRITE, (void __user *)arg, _IOC_SIZE(cmd))) {
- retval = -EFAULT;
- goto done;
- }
- */
read_lock(&ioctl_data->lock);
val = ioctl_data->val;
read_unlock(&ioctl_data->lock);
break;
case IOCTL_VALSET_NUM:
- /*
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- */
ioctl_num = arg;
break;
diff --git a/examples/kbleds.c b/examples/kbleds.c
index 873166de7b0b2c4870a25242e4f9a8f71e4f56ed..1573b10c944d97c7e03814513f6233edd618d373 100644 (file)
--- a/examples/kbleds.c
+++ b/examples/kbleds.c
/*
- * kbleds.c - Blink keyboard leds until the module is unloaded.
+ * kbleds.c - Blink keyboard leds until the module is unloaded.
*/
#include <linux/init.h>
#include <linux/console_struct.h> /* For vc_cons */
MODULE_DESCRIPTION("Example module illustrating the use of Keyboard LEDs.");
-MODULE_LICENSE("GPL");
struct timer_list my_timer;
struct tty_driver *my_driver;
#define ALL_LEDS_ON 0x07
#define RESTORE_LEDS 0xFF
-/*
- * Function my_timer_func blinks the keyboard LEDs periodically by invoking
+/* Function my_timer_func blinks the keyboard LEDs periodically by invoking
* command KDSETLED of ioctl() on the keyboard driver. To learn more on virtual
* terminal ioctl operations, please see file:
- * /usr/src/linux/drivers/char/vt_ioctl.c, function vt_ioctl().
+ * drivers/char/vt_ioctl.c, function vt_ioctl().
*
* The argument to KDSETLED is alternatively set to 7 (thus causing the led
* mode to be set to LED_SHOW_IOCTL, and all the leds are lit) and to 0xFF
* (any value above 7 switches back the led mode to LED_SHOW_FLAGS, thus
* the LEDs reflect the actual keyboard status). To learn more on this,
- * please see file:
- * /usr/src/linux/drivers/char/keyboard.c, function setledstate().
- *
+ * please see file: drivers/char/keyboard.c, function setledstate().
*/
static void my_timer_func(unsigned long ptr)
my_driver = vc_cons[fg_console].d->port.tty->driver;
pr_info("kbleds: tty driver magic %x\n", my_driver->magic);
- /*
- * Set up the LED blink timer the first time
- */
+ /* Set up the LED blink timer the first time. */
timer_setup(&my_timer, (void *) &my_timer_func,
(unsigned long) &kbledstatus);
my_timer.expires = jiffies + BLINK_DELAY;
module_init(kbleds_init);
module_exit(kbleds_cleanup);
+
+MODULE_LICENSE("GPL");
index 000a8ec3832ab9e205f2214e292d9b60ff8c39ac..369130c00dc3b1e19848dcbb63ac5f2cbca4fa69 100644 (file)
--- a/examples/print_string.c
+++ b/examples/print_string.c
/*
- * print_string.c - Send output to the tty we're running on, regardless if it's
- * through X11, telnet, etc. We do this by printing the string to the tty
- * associated with the current task.
+ * print_string.c - Send output to the tty we're running on, regardless if
+ * it is through X11, telnet, etc. We do this by printing the string to the
+ * tty associated with the current task.
*/
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/sched.h> /* For current */
#include <linux/tty.h> /* For the tty declarations */
-MODULE_LICENSE("GPL");
-
static void print_string(char *str)
{
struct tty_struct *my_tty;
const struct tty_operations *ttyops;
- /*
- * The tty for the current task, for 2.6.6+ kernels
- */
+ /* The tty for the current task, for 2.6.6+ kernels */
my_tty = get_current_tty();
ttyops = my_tty->driver->ops;
- /*
- * If my_tty is NULL, the current task has no tty you can print to
- * (ie, if it's a daemon). If so, there's nothing we can do.
+ /* If my_tty is NULL, the current task has no tty you can print to (i.e.,
+ * if it is a daemon). If so, there is nothing we can do.
*/
- if (my_tty != NULL) {
- /*
- * my_tty->driver is a struct which holds the tty's functions,
+ if (my_tty) {
+ /* my_tty->driver is a struct which holds the tty's functions,
* one of which (write) is used to write strings to the tty.
* It can be used to take a string either from the user's or
* kernel's memory segment.
*
- * The function's 1st parameter is the tty to write to,
- * because the same function would normally be used for all
- * tty's of a certain type.
+ * The function's 1st parameter is the tty to write to, because the
+ * same function would normally be used for all tty's of a certain
+ * type.
* The 2nd parameter is a pointer to a string.
* The 3rd parameter is the length of the string.
*
* As you will see below, sometimes it's necessary to use
* preprocessor stuff to create code that works for different
- * kernel versions. The (naive) approach we've taken here
- * does not scale well. The right way to deal with this
- * is described in section 2 of
+ * kernel versions. The (naive) approach we've taken here does not
+ * scale well. The right way to deal with this is described in
+ * section 2 of
* linux/Documentation/SubmittingPatches
*/
(ttyops->write)(my_tty, /* The tty itself */
str, /* String */
strlen(str)); /* Length */
- /*
- * ttys were originally hardware devices, which (usually)
- * strictly followed the ASCII standard. In ASCII, to move to
- * a new line you need two characters, a carriage return and a
- * line feed. On Unix, the ASCII line feed is used for both
- * purposes - so we can't just use \n, because it wouldn't have
- * a carriage return and the next line will start at the
- * column right after the line feed.
+ /* ttys were originally hardware devices, which (usually) strictly
+ * followed the ASCII standard. In ASCII, to move to a new line you
+ * need two characters, a carriage return and a line feed. On Unix,
+ * the ASCII line feed is used for both purposes - so we can not
+ * just use \n, because it would not have a carriage return and the
+ * next line will start at the column right after the line feed.
*
- * This is why text files are different between Unix and
- * MS Windows. In CP/M and derivatives, like MS-DOS and
- * MS Windows, the ASCII standard was strictly adhered to,
- * and therefore a newline requirs both a LF and a CR.
+ * This is why text files are different between Unix and MS Windows.
+ * In CP/M and derivatives, like MS-DOS and MS Windows, the ASCII
+ * standard was strictly adhered to, and therefore a newline requirs
+ * both a LF and a CR.
*/
(ttyops->write)(my_tty, "\015\012", 2);
}
module_init(print_string_init);
module_exit(print_string_exit);
+
+MODULE_LICENSE("GPL");
diff --git a/examples/procfs1.c b/examples/procfs1.c
index 2f627cf059231a58ea926769626adbd018ce7fca..71b23b44d79ac78917caeaf0f73bde2d1231eab8 100644 (file)
--- a/examples/procfs1.c
+++ b/examples/procfs1.c
/*
- * procfs1.c
+ * procfs1.c
*/
#include <linux/kernel.h>
diff --git a/examples/procfs2.c b/examples/procfs2.c
index dcb08a1e514c3ed564f9c3330f8530f8959dc579..29f3934117df06db1b7dba6fa8b5e114a8e2755f 100644 (file)
--- a/examples/procfs2.c
+++ b/examples/procfs2.c
/*
- * procfs2.c - create a "file" in /proc
+ * procfs2.c - create a "file" in /proc
*/
#include <linux/kernel.h> /* We're doing kernel work */
#define PROCFS_MAX_SIZE 1024
#define PROCFS_NAME "buffer1k"
-/**
- * This structure hold information about the /proc file
- *
- */
+/* This structure hold information about the /proc file */
static struct proc_dir_entry *Our_Proc_File;
-/**
- * The buffer used to store character for this module
- *
- */
+/* The buffer used to store character for this module */
static char procfs_buffer[PROCFS_MAX_SIZE];
-/**
- * The size of the buffer
- *
- */
+/* The size of the buffer */
static unsigned long procfs_buffer_size = 0;
-/**
- * This function is called then the /proc file is read
- *
- */
+/* This function is called then the /proc file is read */
ssize_t procfile_read(struct file *filePointer,
char *buffer,
size_t buffer_length,
return ret;
}
-
-/**
- * This function is called with the /proc file is written
- *
- */
+/* This function is called with the /proc file is written. */
static ssize_t procfile_write(struct file *file,
const char *buff,
size_t len,
diff --git a/examples/procfs3.c b/examples/procfs3.c
index 4a6e3bbec530bf1b9a7f345a8db616edc10eb70f..0a5c11f2f774cc73b5b69d7999537985db506af5 100644 (file)
--- a/examples/procfs3.c
+++ b/examples/procfs3.c
/*
- * procfs3.c
+ * procfs3.c
*/
#include <linux/kernel.h>
diff --git a/examples/procfs4.c b/examples/procfs4.c
index 676169769bc839361a4197d007172385b9e3ce23..432b0505998ded6284ceb820c65deffab8b0dc08 100644 (file)
--- a/examples/procfs4.c
+++ b/examples/procfs4.c
/*
- * procfs4.c - create a "file" in /proc
- * This program uses the seq_file library to manage the /proc file.
+ * procfs4.c - create a "file" in /proc
+ * This program uses the seq_file library to manage the /proc file.
*/
#include <linux/kernel.h> /* We are doing kernel work */
diff --git a/examples/sched.c b/examples/sched.c
index 5d208d67d01be39614dbcc1681064e482985f891..4bf2d707a876c3df6359e59e306234ea8de218ed 100644 (file)
--- a/examples/sched.c
+++ b/examples/sched.c
/*
- * sched.c
+ * sched.c
*/
#include <linux/init.h>
#include <linux/module.h>
diff --git a/examples/sleep.c b/examples/sleep.c
index 365c6018f4f6e3fe6af05144a02320e0f1b1419b..c27028ddf71228adefe9925d2834c4442865edf5 100644 (file)
--- a/examples/sleep.c
+++ b/examples/sleep.c
/*
- * sleep.c - create a /proc file, and if several processes try to open it at
- * the same time, put all but one to sleep
+ * sleep.c - create a /proc file, and if several processes try to open it
+ * at the same time, put all but one to sleep.
*/
#include <linux/kernel.h> /* We're doing kernel work */
#define HAVE_PROC_OPS
#endif
-/*
- * The module's file functions
- */
-
-/*
- * Here we keep the last message received, to prove that we can process our
- * input
+/* Here we keep the last message received, to prove that we can process our
+ * input.
*/
#define MESSAGE_LENGTH 80
static char Message[MESSAGE_LENGTH];
static struct proc_dir_entry *Our_Proc_File;
#define PROC_ENTRY_FILENAME "sleep"
-/*
- * Since we use the file operations struct, we can't use the special proc
+/* Since we use the file operations struct, we can't use the special proc
* output provisions - we have to use a standard read function, which is this
- * function
+ * function.
*/
static ssize_t module_output(struct file *file, /* see include/linux/fs.h */
char *buf, /* The buffer to put data to
int i;
char message[MESSAGE_LENGTH + 30];
- /*
- * Return 0 to signify end of file - that we have nothing
- * more to say at this point.
+ /* Return 0 to signify end of file - that we have nothing more to say
+ * at this point.
*/
if (finished) {
finished = 0;
return 0;
}
- /*
- * If you don't understand this by now, you're hopeless as a kernel
- * programmer.
- */
sprintf(message, "Last input:%s\n", Message);
for (i = 0; i < len && message[i]; i++)
put_user(message[i], buf + i);
return i; /* Return the number of bytes "read" */
}
-/*
- * This function receives input from the user when the user writes to the /proc
- * file.
+/* This function receives input from the user when the user writes to the
+ * /proc file.
*/
static ssize_t module_input(struct file *file, /* The file itself */
const char *buf, /* The buffer with input */
{
int i;
- /*
- * Put the input into Message, where module_output will later be
- * able to use it
+ /* Put the input into Message, where module_output will later be able
+ * to use it.
*/
for (i = 0; i < MESSAGE_LENGTH - 1 && i < length; i++)
get_user(Message[i], buf + i);
- /*
- * we want a standard, zero terminated string
- */
+ /* we want a standard, zero terminated string */
Message[i] = '\0';
- /*
- * We need to return the number of input characters used
- */
+ /* We need to return the number of input characters used */
return i;
}
-/*
- * 1 if the file is currently open by somebody
- */
+/* 1 if the file is currently open by somebody */
int Already_Open = 0;
-/*
- * Queue of processes who want our file
- */
+/* Queue of processes who want our file */
DECLARE_WAIT_QUEUE_HEAD(WaitQ);
-/*
- * Called when the /proc file is opened
- */
+
+/* Called when the /proc file is opened */
static int module_open(struct inode *inode, struct file *file)
{
- /*
- * If the file's flags include O_NONBLOCK, it means the process doesn't
- * want to wait for the file. In this case, if the file is already
- * open, we should fail with -EAGAIN, meaning "you'll have to try
- * again", instead of blocking a process which would rather stay awake.
+ /* If the file's flags include O_NONBLOCK, it means the process does not
+ * want to wait for the file. In this case, if the file is already open,
+ * we should fail with -EAGAIN, meaning "you will have to try again",
+ * instead of blocking a process which would rather stay awake.
*/
if ((file->f_flags & O_NONBLOCK) && Already_Open)
return -EAGAIN;
- /*
- * This is the correct place for try_module_get(THIS_MODULE) because
- * if a process is in the loop, which is within the kernel module,
+ /* This is the correct place for try_module_get(THIS_MODULE) because if
+ * a process is in the loop, which is within the kernel module,
* the kernel module must not be removed.
*/
try_module_get(THIS_MODULE);
- /*
- * If the file is already open, wait until it isn't
- */
-
+ /* If the file is already open, wait until it is not. */
while (Already_Open) {
int i, is_sig = 0;
- /*
- * This function puts the current process, including any system
- * calls, such as us, to sleep. Execution will be resumed right
+ /* This function puts the current process, including any system
+ * calls, such as us, to sleep. Execution will be resumed right
* after the function call, either because somebody called
* wake_up(&WaitQ) (only module_close does that, when the file
* is closed) or when a signal, such as Ctrl-C, is sent
*/
wait_event_interruptible(WaitQ, !Already_Open);
- /*
- * If we woke up because we got a signal we're not blocking,
+ /* If we woke up because we got a signal we're not blocking,
* return -EINTR (fail the system call). This allows processes
* to be killed or stopped.
*/
-
- /*
- * Emmanuel Papirakis:
- *
- * This is a little update to work with 2.2.*. Signals now are
- * contained in two words (64 bits) and are stored in a structure that
- * contains an array of two unsigned longs. We now have to make 2
- * checks in our if.
- *
- * Ori Pomerantz:
- *
- * Nobody promised me they'll never use more than 64 bits, or that this
- * book won't be used for a version of Linux with a word size of 16
- * bits. This code would work in any case.
- */
for (i = 0; i < _NSIG_WORDS && !is_sig; i++)
is_sig = current->pending.signal.sig[i] & ~current->blocked.sig[i];
if (is_sig) {
- /*
- * It's important to put module_put(THIS_MODULE) here,
- * because for processes where the open is interrupted
- * there will never be a corresponding close. If we
- * don't decrement the usage count here, we will be
- * left with a positive usage count which we'll have no
- * way to bring down to zero, giving us an immortal
- * module, which can only be killed by rebooting
+ /* It is important to put module_put(THIS_MODULE) here, because
+ * for processes where the open is interrupted there will never
+ * be a corresponding close. If we do not decrement the usage
+ * count here, we will be left with a positive usage count
+ * which we will have no way to bring down to zero, giving us
+ * an immortal module, which can only be killed by rebooting
* the machine.
*/
module_put(THIS_MODULE);
}
}
- /*
- * If we got here, Already_Open must be zero
- */
+ /* If we got here, Already_Open must be zero. */
- /*
- * Open the file
- */
+ /* Open the file */
Already_Open = 1;
return 0; /* Allow the access */
}
-/*
- * Called when the /proc file is closed
- */
+/* Called when the /proc file is closed */
int module_close(struct inode *inode, struct file *file)
{
- /*
- * Set Already_Open to zero, so one of the processes in the WaitQ will
+ /* Set Already_Open to zero, so one of the processes in the WaitQ will
* be able to set Already_Open back to one and to open the file. All
* the other processes will be called when Already_Open is back to one,
* so they'll go back to sleep.
*/
Already_Open = 0;
- /*
- * Wake up all the processes in WaitQ, so if anybody is waiting for the
+ /* Wake up all the processes in WaitQ, so if anybody is waiting for the
* file, they can have it.
*/
wake_up(&WaitQ);
return 0; /* success */
}
-/*
- * Structures to register as the /proc file, with pointers to all the relevant
+/* 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
+/* 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.
*/
diff --git a/examples/start.c b/examples/start.c
index 0f69d0a14bd5f3e6f31e9900f3dcc3e318dd3af6..6abe070681b6943b85b9436e8a171aa6debe729d 100644 (file)
--- a/examples/start.c
+++ b/examples/start.c
/*
- * start.c - Illustration of multi filed modules
+ * start.c - Illustration of multi filed modules
*/
-#include <linux/kernel.h> /* We're doing kernel work */
+#include <linux/kernel.h> /* We are doing kernel work */
#include <linux/module.h> /* Specifically, a module */
int init_module(void)
diff --git a/examples/stop.c b/examples/stop.c
index 59a9cf08f77935b027384c322d0802f6bf544de8..77fa67586b81875cc0023dbc7d2309396d7a7613 100644 (file)
--- a/examples/stop.c
+++ b/examples/stop.c
/*
- * stop.c - Illustration of multi filed modules
+ * stop.c - Illustration of multi filed modules
*/
-#include <linux/kernel.h> /* We're doing kernel work */
+#include <linux/kernel.h> /* We are doing kernel work */
#include <linux/module.h> /* Specifically, a module */
void cleanup_module()
diff --git a/examples/syscall.c b/examples/syscall.c
index 119a6a7566a61da2de5f064b7a7564991f7051d2..b9087f47577194a0095f3d771350f96806c2884b 100644 (file)
--- a/examples/syscall.c
+++ b/examples/syscall.c
/*
- * syscall.c
+ * syscall.c
*
- * System call "stealing" sample.
+ * System call "stealing" sample.
*
- * Disables page protection at a processor level by
- * changing the 16th bit in the cr0 register (could be Intel specific)
+ * Disables page protection at a processor level by changing the 16th bit
+ * in the cr0 register (could be Intel specific).
*
- * Based on example by Peter Jay Salzman and
- * https://bbs.archlinux.org/viewtopic.php?id=139406
+ * Based on example by Peter Jay Salzman and
+ * https://bbs.archlinux.org/viewtopic.php?id=139406
*/
#include <linux/delay.h>
#include <linux/syscalls.h>
#include <linux/unistd.h> /* The list of system calls */
-/*
- * For the current (process) structure, we need
- * this to know who the current user is.
+/* For the current (process) structure, we need this to know who the
+ * current user is.
*/
#include <linux/sched.h>
#include <linux/uaccess.h>
unsigned long **sys_call_table;
unsigned long original_cr0;
-/*
- * UID we want to spy on - will be filled from the
- * command line
- */
+/* UID we want to spy on - will be filled from the command line. */
static int uid;
module_param(uid, int, 0644);
-/*
- * A pointer to the original system call. The reason
- * we keep this, rather than call the original function
- * (sys_open), is because somebody else might have
- * replaced the system call before us. Note that this
- * is not 100% safe, because if another module
- * replaced sys_open before us, then when we're inserted
- * we'll call the function in that module - and it
- * might be removed before we are.
+/* A pointer to the original system call. The reason we keep this, rather
+ * than call the original function (sys_open), is because somebody else
+ * might have replaced the system call before us. Note that this is not
+ * 100% safe, because if another module replaced sys_open before us,
+ * then when we are inserted, we will call the function in that module -
+ * and it might be removed before we are.
*
- * Another reason for this is that we can't get sys_open.
- * It's a static variable, so it is not exported.
+ * Another reason for this is that we can not get sys_open.
+ * It is a static variable, so it is not exported.
*/
asmlinkage int (*original_call)(const char *, int, int);
-/*
- * The function we'll replace sys_open (the function
- * called when you call the open system call) with. To
- * find the exact prototype, with the number and type
- * of arguments, we find the original function first
- * (it's at fs/open.c).
+/* The function we will replace sys_open (the function called when you
+ * call the open system call) with. To find the exact prototype, with
+ * the number and type of arguments, we find the original function first
+ * (it is at fs/open.c).
*
- * In theory, this means that we're tied to the
- * current version of the kernel. In practice, the
- * system calls almost never change (it would wreck havoc
- * and require programs to be recompiled, since the system
- * calls are the interface between the kernel and the
- * processes).
+ * In theory, this means that we are tied to the current version of the
+ * kernel. In practice, the system calls almost never change (it would
+ * wreck havoc and require programs to be recompiled, since the system
+ * calls are the interface between the kernel and the processes).
*/
asmlinkage int our_sys_open(const char *filename, int flags, int mode)
{
int i = 0;
char ch;
- /*
- * Report the file, if relevant
- */
+ /* Report the file, if relevant */
pr_info("Opened file by %d: ", uid);
do {
get_user(ch, filename + i);
} while (ch != 0);
pr_info("\n");
- /*
- * Call the original sys_open - otherwise, we lose
- * the ability to open files
+ /* Call the original sys_open - otherwise, we lose the ability to
+ * open files.
*/
return original_call(filename, flags, mode);
}
static void __exit syscall_end(void)
{
- if (!sys_call_table) {
+ if (!sys_call_table)
return;
- }
- /*
- * Return the system call back to normal
- */
+ /* Return the system call back to normal */
if (sys_call_table[__NR_open] != (unsigned long *) our_sys_open) {
pr_alert("Somebody else also played with the ");
pr_alert("open system call\n");