github-mirror/lkmpg
2
0
Fork 0
mirror of https://github.com/sysprog21/lkmpg.git synced 2024-11-25 17:56:36 +08:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

Enforce the customized style for example code

Browse Source 
Instead of using tab for indention, the style defaults to 4 spaces for
the sake of compact layout.
This commit is contained in:
Jim Huang 2021-07-22 06:58:13 +08:00
parent 936d82fad7
commit 50b8dfe6c2
33 changed files with 421 additions and 422 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
examples/.clang-format Normal file
View File

@ -0,0 +1,15 @@
BasedOnStyle: Chromium
Language: Cpp
MaxEmptyLinesToKeep: 3
IndentCaseLabels: false
AllowShortIfStatementsOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
DerivePointerAlignment: false
PointerAlignment: Right
SpaceAfterCStyleCast: true
TabWidth: 4
UseTab: Never
IndentWidth: 4
BreakBeforeBraces: Linux
AccessModifierOffset: -4

33
examples/bottomhalf.c
View File

@ -9,26 +9,22 @@
* 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/module.h>
#include <linux/kernel.h>
#include <linux/gpio.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/module.h>
static int button_irqs[] = { -1, -1 }; static int button_irqs[] = {-1, -1};
/* Define GPIOs for LEDs. /* Define GPIOs for LEDs.
Change the numbers for the GPIO on your board. */ Change the numbers for the GPIO on your board. */
static struct gpio leds[] = { static struct gpio leds[] = {{4, GPIOF_OUT_INIT_LOW, "LED 1"}};
{ 4, GPIOF_OUT_INIT_LOW, "LED 1" }
};
/* Define GPIOs for BUTTONS /* Define GPIOs for BUTTONS
Change the numbers for the GPIO on your board. */ Change the numbers for the GPIO on your board. */
static struct gpio buttons[] = { static struct gpio buttons[] = {{17, GPIOF_IN, "LED 1 ON BUTTON"},
{ 17, GPIOF_IN, "LED 1 ON BUTTON" }, {18, GPIOF_IN, "LED 1 OFF BUTTON"}};
{ 18, GPIOF_IN, "LED 1 OFF BUTTON" }
};
/* Tasklet containing some non-trivial amount of processing */ /* Tasklet containing some non-trivial amount of processing */
static void bottomhalf_tasklet_fn(unsigned long data) static void bottomhalf_tasklet_fn(unsigned long data)
@ -48,9 +44,9 @@ static irqreturn_t button_isr(int irq, void *data)
{ {
/* Do something quickly right now */ /* Do something quickly right now */
if (irq == button_irqs[0] && !gpio_get_value(leds[0].gpio)) if (irq == button_irqs[0] && !gpio_get_value(leds[0].gpio))
gpio_set_value(leds[0].gpio, 1); gpio_set_value(leds[0].gpio, 1);
else if(irq == button_irqs[1] && gpio_get_value(leds[0].gpio)) else if (irq == button_irqs[1] && gpio_get_value(leds[0].gpio))
gpio_set_value(leds[0].gpio, 0); gpio_set_value(leds[0].gpio, 0);
/* Do the rest at leisure via the scheduler */ /* Do the rest at leisure via the scheduler */
tasklet_schedule(&buttontask); tasklet_schedule(&buttontask);
@ -80,8 +76,7 @@ int init_module()
goto fail1; goto fail1;
} }
pr_info("Current button1 value: %d\n", pr_info("Current button1 value: %d\n", gpio_get_value(buttons[0].gpio));
gpio_get_value(buttons[0].gpio));
ret = gpio_to_irq(buttons[0].gpio); ret = gpio_to_irq(buttons[0].gpio);
@ -92,8 +87,7 @@ int init_module()
button_irqs[0] = ret; button_irqs[0] = ret;
pr_info("Successfully requested BUTTON1 IRQ # %d\n", pr_info("Successfully requested BUTTON1 IRQ # %d\n", button_irqs[0]);
button_irqs[0]);
ret = request_irq(button_irqs[0], button_isr, ret = request_irq(button_irqs[0], button_isr,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
@ -114,8 +108,7 @@ int init_module()
button_irqs[1] = ret; button_irqs[1] = ret;
pr_info("Successfully requested BUTTON2 IRQ # %d\n", pr_info("Successfully requested BUTTON2 IRQ # %d\n", button_irqs[1]);
button_irqs[1]);
ret = request_irq(button_irqs[1], button_isr, ret = request_irq(button_irqs[1], button_isr,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,

51
examples/chardev.c
View File

@ -3,18 +3,18 @@
* you've read from the dev file * you've read from the dev file
*/ */
#include <linux/kernel.h> #include <asm/io.h>
#include <linux/module.h> #include <asm/irq.h>
#include <linux/fs.h> #include <asm/uaccess.h>
#include <linux/init.h> #include <linux/cdev.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/device.h> #include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/irq.h> #include <linux/irq.h>
#include <asm/uaccess.h> #include <linux/kernel.h>
#include <asm/irq.h> #include <linux/module.h>
#include <asm/io.h>
#include <linux/poll.h> #include <linux/poll.h>
#include <linux/cdev.h>
/* /*
* Prototypes - this would normally go in a .h file * Prototypes - this would normally go in a .h file
@ -27,27 +27,25 @@ static ssize_t device_read(struct file *, char *, size_t, loff_t *);
static ssize_t device_write(struct file *, const char *, size_t, loff_t *); static ssize_t device_write(struct file *, const char *, size_t, loff_t *);
#define SUCCESS 0 #define SUCCESS 0
#define DEVICE_NAME "chardev" /* Dev name as it appears in /proc/devices */ #define DEVICE_NAME "chardev" /* Dev name as it appears in /proc/devices */
#define BUF_LEN 80 /* Max length of the message from the device */ #define BUF_LEN 80 /* Max length of the message from the device */
/* /*
* Global variables are declared as static, so are global within the file. * Global variables are declared as static, so are global within the file.
*/ */
static int Major; /* Major number assigned to our device driver */ static int Major; /* Major number assigned to our device driver */
static int Device_Open = 0; /* Is device open? static int Device_Open = 0; /* Is device open?
* Used to prevent multiple access to device */ * Used to prevent multiple access to device */
static char msg[BUF_LEN]; /* The msg the device will give when asked */ static char msg[BUF_LEN]; /* The msg the device will give when asked */
static char *msg_Ptr; static char *msg_Ptr;
static struct class *cls; static struct class *cls;
static struct file_operations chardev_fops = { static struct file_operations chardev_fops = {.read = device_read,
.read = device_read, .write = device_write,
.write = device_write, .open = device_open,
.open = device_open, .release = device_release};
.release = device_release
};
/* /*
* This function is called when the module is loaded * This function is called when the module is loaded
@ -113,7 +111,7 @@ static int device_open(struct inode *inode, struct file *file)
*/ */
static int device_release(struct inode *inode, struct file *file) static int device_release(struct inode *inode, struct file *file)
{ {
Device_Open--; /* We're now ready for our next caller */ Device_Open--; /* We're now ready for our next caller */
/* /*
* Decrement the usage count, or else once you opened the file, you'll * Decrement the usage count, or else once you opened the file, you'll
@ -128,10 +126,10 @@ static int device_release(struct inode *inode, struct file *file)
* Called when a process, which already opened the dev file, attempts to * Called when a process, which already opened the dev file, attempts to
* read from it. * read from it.
*/ */
static ssize_t device_read(struct file *filp, /* see include/linux/fs.h */ static ssize_t device_read(struct file *filp, /* see include/linux/fs.h */
char *buffer, /* buffer to fill with data */ char *buffer, /* buffer to fill with data */
size_t length, /* length of the buffer */ size_t length, /* length of the buffer */
loff_t * offset) loff_t *offset)
{ {
/* /*
* Number of bytes actually written to the buffer * Number of bytes actually written to the buffer
@ -149,7 +147,6 @@ static ssize_t device_read(struct file *filp, /* see include/linux/fs.h */
* Actually put the data into the buffer * Actually put the data into the buffer
*/ */
while (length && *msg_Ptr) { while (length && *msg_Ptr) {
/* /*
* The buffer is in the user data segment, not the kernel * The buffer is in the user data segment, not the kernel
* segment so "*" assignment won't work. We have to use * segment so "*" assignment won't work. We have to use
@ -174,7 +171,7 @@ static ssize_t device_read(struct file *filp, /* see include/linux/fs.h */
static ssize_t device_write(struct file *filp, static ssize_t device_write(struct file *filp,
const char *buff, const char *buff,
size_t len, size_t len,
loff_t * off) loff_t *off)
{ {
pr_alert("Sorry, this operation isn't supported.\n"); pr_alert("Sorry, this operation isn't supported.\n");
return -EINVAL; return -EINVAL;

92
examples/chardev2.c
View File

@ -2,18 +2,18 @@
* chardev2.c - Create an input/output character device * chardev2.c - Create an input/output character device
*/ */
#include <linux/kernel.h> /* We're doing kernel work */ #include <asm/io.h>
#include <linux/module.h> /* Specifically, a module */ #include <asm/irq.h>
#include <linux/fs.h> #include <asm/uaccess.h>
#include <linux/init.h> #include <linux/cdev.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/device.h> #include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/irq.h> #include <linux/irq.h>
#include <asm/uaccess.h> #include <linux/kernel.h> /* We're doing kernel work */
#include <asm/irq.h> #include <linux/module.h> /* Specifically, a module */
#include <asm/io.h>
#include <linux/poll.h> #include <linux/poll.h>
#include <linux/cdev.h>
#include "chardev.h" #include "chardev.h"
#define SUCCESS 0 #define SUCCESS 0
@ -38,7 +38,7 @@ static char Message[BUF_LEN];
*/ */
static char *Message_Ptr; static char *Message_Ptr;
static int Major; /* Major number assigned to our device driver */ static int Major; /* Major number assigned to our device driver */
static struct class *cls; static struct class *cls;
/* /*
@ -47,7 +47,7 @@ static struct class *cls;
static int device_open(struct inode *inode, struct file *file) static int device_open(struct inode *inode, struct file *file)
{ {
#ifdef DEBUG #ifdef DEBUG
pr_info("device_open(%p)\n", file); pr_info("device_open(%p)\n", file);
#endif #endif
/* /*
@ -85,10 +85,10 @@ static int device_release(struct inode *inode, struct file *file)
* device file attempts to read from it. * device file attempts to read from it.
*/ */
static ssize_t device_read(struct file *file, /* see include/linux/fs.h */ static ssize_t device_read(struct file *file, /* see include/linux/fs.h */
char __user * buffer, /* buffer to be char __user *buffer, /* buffer to be
* filled with data */ * filled with data */
size_t length, /* length of the buffer */ size_t length, /* length of the buffer */
loff_t * offset) loff_t *offset)
{ {
/* /*
* Number of bytes actually written to the buffer * Number of bytes actually written to the buffer
@ -110,18 +110,17 @@ static ssize_t device_read(struct file *file, /* see include/linux/fs.h */
* Actually put the data into the buffer * Actually put the data into the buffer
*/ */
while (length && *Message_Ptr) { while (length && *Message_Ptr) {
/*
/* * Because the buffer is in the user data segment,
* Because the buffer is in the user data segment, * not the kernel data segment, assignment wouldn't
* not the kernel data segment, assignment wouldn't * work. Instead, we have to use put_user which
* work. Instead, we have to use put_user which * copies data from the kernel data segment to the
* copies data from the kernel data segment to the * user data segment.
* user data segment. */
*/ put_user(*(Message_Ptr++), buffer++);
put_user(*(Message_Ptr++), buffer++); length--;
length--; bytes_read++;
bytes_read++; }
}
#ifdef DEBUG #ifdef DEBUG
pr_info("Read %d bytes, %d left\n", bytes_read, length); pr_info("Read %d bytes, %d left\n", bytes_read, length);
@ -138,9 +137,10 @@ static ssize_t device_read(struct file *file, /* see include/linux/fs.h */
* This function is called when somebody tries to * This function is called when somebody tries to
* write into our device file. * write into our device file.
*/ */
static ssize_t static ssize_t device_write(struct file *file,
device_write(struct file *file, const char __user *buffer,
const char __user * buffer, size_t length, loff_t * offset) size_t length,
loff_t *offset)
{ {
int i; int i;
@ -169,8 +169,8 @@ device_write(struct file *file,
* calling process), the ioctl call returns the output of this function. * calling process), the ioctl call returns the output of this function.
* *
*/ */
long device_ioctl(struct file *file, /* ditto */ long device_ioctl(struct file *file, /* ditto */
unsigned int ioctl_num, /* number and param for ioctl */ unsigned int ioctl_num, /* number and param for ioctl */
unsigned long ioctl_param) unsigned long ioctl_param)
{ {
int i; int i;
@ -187,30 +187,30 @@ long device_ioctl(struct file *file, /* ditto */
* to be the device's message. Get the parameter given to * to be the device's message. Get the parameter given to
* ioctl by the process. * ioctl by the process.
*/ */
temp = (char *)ioctl_param; temp = (char *) ioctl_param;
/* /*
* Find the length of the message * Find the length of the message
*/ */
get_user(ch, temp); get_user(ch, temp);
for (i = 0; ch && i < BUF_LEN; i++, temp++) for (i = 0; ch && i < BUF_LEN; i++, temp++)
get_user(ch, temp); get_user(ch, temp);
device_write(file, (char *)ioctl_param, i, 0); device_write(file, (char *) ioctl_param, i, 0);
break; break;
case IOCTL_GET_MSG: case IOCTL_GET_MSG:
/* /*
* Give the current message to the calling process - * Give the current message to the calling process -
* the parameter we got is a pointer, fill it. * the parameter we got is a pointer, fill it.
*/ */
i = device_read(file, (char *)ioctl_param, 99, 0); i = device_read(file, (char *) ioctl_param, 99, 0);
/* /*
* Put a zero at the end of the buffer, so it will be * Put a zero at the end of the buffer, so it will be
* properly terminated * properly terminated
*/ */
put_user('\0', (char *)ioctl_param + i); put_user('\0', (char *) ioctl_param + i);
break; break;
case IOCTL_GET_NTH_BYTE: case IOCTL_GET_NTH_BYTE:
@ -235,11 +235,11 @@ long device_ioctl(struct file *file, /* ditto */
* init_module. NULL is for unimplemented functions. * init_module. NULL is for unimplemented functions.
*/ */
struct file_operations Fops = { struct file_operations Fops = {
.read = device_read, .read = device_read,
.write = device_write, .write = device_write,
.unlocked_ioctl = device_ioctl, .unlocked_ioctl = device_ioctl,
.open = device_open, .open = device_open,
.release = device_release, /* a.k.a. close */ .release = device_release, /* a.k.a. close */
}; };
/* /*

21
examples/completions.c
View File

@ -1,15 +1,15 @@
#include <linux/completion.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/kthread.h> #include <linux/kthread.h>
#include <linux/completion.h> #include <linux/module.h>
static struct { static struct {
struct completion crank_comp; struct completion crank_comp;
struct completion flywheel_comp; struct completion flywheel_comp;
} machine; } machine;
static int machine_crank_thread(void* arg) static int machine_crank_thread(void *arg)
{ {
pr_info("Turn the crank\n"); pr_info("Turn the crank\n");
@ -17,7 +17,7 @@ static int machine_crank_thread(void* arg)
complete_and_exit(&machine.crank_comp, 0); complete_and_exit(&machine.crank_comp, 0);
} }
static int machine_flywheel_spinup_thread(void* arg) static int machine_flywheel_spinup_thread(void *arg)
{ {
wait_for_completion(&machine.crank_comp); wait_for_completion(&machine.crank_comp);
@ -29,23 +29,20 @@ static int machine_flywheel_spinup_thread(void* arg)
static int completions_init(void) static int completions_init(void)
{ {
struct task_struct* crank_thread; struct task_struct *crank_thread;
struct task_struct* flywheel_thread; struct task_struct *flywheel_thread;
pr_info("completions example\n"); pr_info("completions example\n");
init_completion(&machine.crank_comp); init_completion(&machine.crank_comp);
init_completion(&machine.flywheel_comp); init_completion(&machine.flywheel_comp);
crank_thread = crank_thread = kthread_create(machine_crank_thread, NULL, "KThread Crank");
kthread_create(machine_crank_thread,
NULL, "KThread Crank");
if (IS_ERR(crank_thread)) if (IS_ERR(crank_thread))
goto ERROR_THREAD_1; goto ERROR_THREAD_1;
flywheel_thread = flywheel_thread = kthread_create(machine_flywheel_spinup_thread, NULL,
kthread_create(machine_flywheel_spinup_thread, "KThread Flywheel");
NULL, "KThread Flywheel");
if (IS_ERR(flywheel_thread)) if (IS_ERR(flywheel_thread))
goto ERROR_THREAD_2; goto ERROR_THREAD_2;

23
examples/cryptosha256.c
View File

@ -1,23 +1,23 @@
#include <linux/module.h>
#include <crypto/internal/hash.h> #include <crypto/internal/hash.h>
#include <linux/module.h>
#define SHA256_LENGTH 32 #define SHA256_LENGTH 32
static void show_hash_result(char * plaintext, char * hash_sha256) static void show_hash_result(char *plaintext, char *hash_sha256)
{ {
int i; int i;
char str[SHA256_LENGTH*2 + 1]; char str[SHA256_LENGTH * 2 + 1];
pr_info("sha256 test for string: \"%s\"\n", plaintext); pr_info("sha256 test for string: \"%s\"\n", plaintext);
for (i = 0; i < SHA256_LENGTH ; i++) for (i = 0; i < SHA256_LENGTH; i++)
sprintf(&str[i*2],"%02x", (unsigned char)hash_sha256[i]); sprintf(&str[i * 2], "%02x", (unsigned char) hash_sha256[i]);
str[i*2] = 0; str[i * 2] = 0;
pr_info("%s\n", str); pr_info("%s\n", str);
} }
int cryptosha256_init(void) int cryptosha256_init(void)
{ {
char * plaintext = "This is a test"; char *plaintext = "This is a test";
char hash_sha256[SHA256_LENGTH]; char hash_sha256[SHA256_LENGTH];
struct crypto_shash *sha256; struct crypto_shash *sha256;
struct shash_desc *shash; struct shash_desc *shash;
@ -26,9 +26,8 @@ int cryptosha256_init(void)
if (IS_ERR(sha256)) if (IS_ERR(sha256))
return -1; return -1;
shash = shash = kmalloc(sizeof(struct shash_desc) + crypto_shash_descsize(sha256),
kmalloc(sizeof(struct shash_desc) + crypto_shash_descsize(sha256), GFP_KERNEL);
GFP_KERNEL);
if (!shash) if (!shash)
return -ENOMEM; return -ENOMEM;
@ -51,9 +50,7 @@ int cryptosha256_init(void)
return 0; return 0;
} }
void cryptosha256_exit(void) void cryptosha256_exit(void) {}
{
}
module_init(cryptosha256_init); module_init(cryptosha256_init);
module_exit(cryptosha256_exit); module_exit(cryptosha256_exit);

49
examples/cryptosk.c
View File

@ -1,9 +1,9 @@
#include <crypto/internal/skcipher.h> #include <crypto/internal/skcipher.h>
#include <linux/module.h>
#include <linux/crypto.h> #include <linux/crypto.h>
#include <linux/module.h>
#define SYMMETRIC_KEY_LENGTH 32 #define SYMMETRIC_KEY_LENGTH 32
#define CIPHER_BLOCK_SIZE 16 #define CIPHER_BLOCK_SIZE 16
struct tcrypt_result { struct tcrypt_result {
struct completion completion; struct completion completion;
@ -12,17 +12,17 @@ struct tcrypt_result {
struct skcipher_def { struct skcipher_def {
struct scatterlist sg; struct scatterlist sg;
struct crypto_skcipher * tfm; struct crypto_skcipher *tfm;
struct skcipher_request * req; struct skcipher_request *req;
struct tcrypt_result result; struct tcrypt_result result;
char * scratchpad; char *scratchpad;
char * ciphertext; char *ciphertext;
char * ivdata; char *ivdata;
}; };
static struct skcipher_def sk; static struct skcipher_def sk;
static void test_skcipher_finish(struct skcipher_def * sk) static void test_skcipher_finish(struct skcipher_def *sk)
{ {
if (sk->tfm) if (sk->tfm)
crypto_free_skcipher(sk->tfm); crypto_free_skcipher(sk->tfm);
@ -36,24 +36,23 @@ static void test_skcipher_finish(struct skcipher_def * sk)
kfree(sk->ciphertext); kfree(sk->ciphertext);
} }
static int test_skcipher_result(struct skcipher_def * sk, int rc) static int test_skcipher_result(struct skcipher_def *sk, int rc)
{ {
switch (rc) { switch (rc) {
case 0: case 0:
break; break;
case -EINPROGRESS || -EBUSY: case -EINPROGRESS || -EBUSY:
rc = wait_for_completion_interruptible( rc = wait_for_completion_interruptible(&sk->result.completion);
&sk->result.completion);
if (!rc && !sk->result.err) { if (!rc && !sk->result.err) {
reinit_completion(&sk->result.completion); reinit_completion(&sk->result.completion);
break; break;
} }
pr_info("skcipher encrypt returned with %d result %d\n", pr_info("skcipher encrypt returned with %d result %d\n", rc,
rc, sk->result.err); sk->result.err);
break; break;
default: default:
pr_info("skcipher encrypt returned with %d result %d\n", pr_info("skcipher encrypt returned with %d result %d\n", rc,
rc, sk->result.err); sk->result.err);
break; break;
} }
@ -90,8 +89,9 @@ static void test_skcipher_callback(struct crypto_async_request *req, int error)
*/ */
} }
static int test_skcipher_encrypt(char * plaintext, char * password, static int test_skcipher_encrypt(char *plaintext,
struct skcipher_def * sk) char *password,
struct skcipher_def *sk)
{ {
int ret = -EFAULT; int ret = -EFAULT;
unsigned char key[SYMMETRIC_KEY_LENGTH]; unsigned char key[SYMMETRIC_KEY_LENGTH];
@ -114,14 +114,13 @@ static int test_skcipher_encrypt(char * plaintext, char * password,
} }
skcipher_request_set_callback(sk->req, CRYPTO_TFM_REQ_MAY_BACKLOG, skcipher_request_set_callback(sk->req, CRYPTO_TFM_REQ_MAY_BACKLOG,
test_skcipher_callback, test_skcipher_callback, &sk->result);
&sk->result);
/* clear the key */ /* clear the key */
memset((void*)key,'\0',SYMMETRIC_KEY_LENGTH); memset((void *) key, '\0', SYMMETRIC_KEY_LENGTH);
/* Use the world's favourite password */ /* Use the world's favourite password */
sprintf((char*)key,"%s",password); sprintf((char *) key, "%s", password);
/* AES 256 with given symmetric key */ /* AES 256 with given symmetric key */
if (crypto_skcipher_setkey(sk->tfm, key, SYMMETRIC_KEY_LENGTH)) { if (crypto_skcipher_setkey(sk->tfm, key, SYMMETRIC_KEY_LENGTH)) {
@ -150,11 +149,11 @@ static int test_skcipher_encrypt(char * plaintext, char * password,
goto out; goto out;
} }
} }
sprintf((char*)sk->scratchpad,"%s",plaintext); sprintf((char *) sk->scratchpad, "%s", plaintext);
sg_init_one(&sk->sg, sk->scratchpad, CIPHER_BLOCK_SIZE); sg_init_one(&sk->sg, sk->scratchpad, CIPHER_BLOCK_SIZE);
skcipher_request_set_crypt(sk->req, &sk->sg, &sk->sg, skcipher_request_set_crypt(sk->req, &sk->sg, &sk->sg, CIPHER_BLOCK_SIZE,
CIPHER_BLOCK_SIZE, sk->ivdata); sk->ivdata);
init_completion(&sk->result.completion); init_completion(&sk->result.completion);
/* encrypt data */ /* encrypt data */
@ -172,7 +171,7 @@ out:
int cryptoapi_init(void) int cryptoapi_init(void)
{ {
/* The world's favourite password */ /* The world's favourite password */
char * password = "password123"; char *password = "password123";
sk.tfm = NULL; sk.tfm = NULL;
sk.req = NULL; sk.req = NULL;

26
examples/devicemodel.c
View File

@ -4,12 +4,13 @@
struct devicemodel_data { struct devicemodel_data {
char *greeting; char *greeting;
int number; int number;
}; };
static int devicemodel_probe(struct platform_device *dev) static int devicemodel_probe(struct platform_device *dev)
{ {
struct devicemodel_data *pd = (struct devicemodel_data *)(dev->dev.platform_data); struct devicemodel_data *pd =
(struct devicemodel_data *) (dev->dev.platform_data);
pr_info("devicemodel probe\n"); pr_info("devicemodel probe\n");
pr_info("devicemodel greeting: %s; %d\n", pd->greeting, pd->number); pr_info("devicemodel greeting: %s; %d\n", pd->greeting, pd->number);
@ -46,24 +47,23 @@ static int devicemodel_resume(struct device *dev)
return 0; return 0;
} }
static const struct dev_pm_ops devicemodel_pm_ops = static const struct dev_pm_ops devicemodel_pm_ops = {
{
.suspend = devicemodel_suspend, .suspend = devicemodel_suspend,
.resume = devicemodel_resume, .resume = devicemodel_resume,
.poweroff = devicemodel_suspend, .poweroff = devicemodel_suspend,
.freeze = devicemodel_suspend, .freeze = devicemodel_suspend,
.thaw = devicemodel_resume, .thaw = devicemodel_resume,
.restore = devicemodel_resume .restore = devicemodel_resume};
};
static struct platform_driver devicemodel_driver = { static struct platform_driver devicemodel_driver = {
.driver = { .driver =
.name = "devicemodel_example", {
.owner = THIS_MODULE, .name = "devicemodel_example",
.pm = &devicemodel_pm_ops, .owner = THIS_MODULE,
}, .pm = &devicemodel_pm_ops,
.probe = devicemodel_probe, },
.remove = devicemodel_remove, .probe = devicemodel_probe,
.remove = devicemodel_remove,
}; };
static int devicemodel_init(void) static int devicemodel_init(void)

32
examples/example_atomic.c
View File

@ -1,17 +1,13 @@
#include <linux/interrupt.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/interrupt.h>
#define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c" #define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c"
#define BYTE_TO_BINARY(byte) \ #define BYTE_TO_BINARY(byte) \
(byte & 0x80 ? '1' : '0'), \ (byte & 0x80 ? '1' : '0'), (byte & 0x40 ? '1' : '0'), \
(byte & 0x40 ? '1' : '0'), \ (byte & 0x20 ? '1' : '0'), (byte & 0x10 ? '1' : '0'), \
(byte & 0x20 ? '1' : '0'), \ (byte & 0x08 ? '1' : '0'), (byte & 0x04 ? '1' : '0'), \
(byte & 0x10 ? '1' : '0'), \ (byte & 0x02 ? '1' : '0'), (byte & 0x01 ? '1' : '0')
(byte & 0x08 ? '1' : '0'), \
(byte & 0x04 ? '1' : '0'), \
(byte & 0x02 ? '1' : '0'), \
(byte & 0x01 ? '1' : '0')
static void atomic_add_subtract(void) static void atomic_add_subtract(void)
{ {
@ -28,29 +24,29 @@ static void atomic_add_subtract(void)
/* add one */ /* add one */
atomic_inc(&debbie); atomic_inc(&debbie);
pr_info("chris: %d, debbie: %d\n", pr_info("chris: %d, debbie: %d\n", atomic_read(&chris),
atomic_read(&chris), atomic_read(&debbie)); atomic_read(&debbie));
} }
static void atomic_bitwise(void) static void atomic_bitwise(void)
{ {
unsigned long word = 0; unsigned long word = 0;
pr_info("Bits 0: "BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word)); pr_info("Bits 0: " BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word));
set_bit(3, &word); set_bit(3, &word);
set_bit(5, &word); set_bit(5, &word);
pr_info("Bits 1: "BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word)); pr_info("Bits 1: " BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word));
clear_bit(5, &word); clear_bit(5, &word);
pr_info("Bits 2: "BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word)); pr_info("Bits 2: " BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word));
change_bit(3, &word); change_bit(3, &word);
pr_info("Bits 3: "BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word)); pr_info("Bits 3: " BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word));
if (test_and_set_bit(3, &word)) if (test_and_set_bit(3, &word))
pr_info("wrong\n"); pr_info("wrong\n");
pr_info("Bits 4: "BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word)); pr_info("Bits 4: " BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word));
word = 255; word = 255;
pr_info("Bits 5: "BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word)); pr_info("Bits 5: " BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(word));
} }
static int example_atomic_init(void) static int example_atomic_init(void)

5
examples/example_mutex.c
View File

@ -1,6 +1,6 @@
#include <linux/init.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h>
#include <linux/mutex.h> #include <linux/mutex.h>
DEFINE_MUTEX(mymutex); DEFINE_MUTEX(mymutex);
@ -20,8 +20,7 @@ static int example_mutex_init(void)
mutex_unlock(&mymutex); mutex_unlock(&mymutex);
pr_info("mutex is unlocked\n"); pr_info("mutex is unlocked\n");
} } else
else
pr_info("Failed to lock\n"); pr_info("Failed to lock\n");
return 0; return 0;

2
examples/example_rwlock.c
View File

@ -1,6 +1,6 @@
#include <linux/interrupt.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/interrupt.h>
DEFINE_RWLOCK(myrwlock); DEFINE_RWLOCK(myrwlock);

4
examples/example_spinlock.c
View File

@ -1,8 +1,8 @@
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/interrupt.h>
DEFINE_SPINLOCK(sl_static); DEFINE_SPINLOCK(sl_static);
spinlock_t sl_dynamic; spinlock_t sl_dynamic;

4
examples/example_tasklet.c
View File

@ -1,7 +1,7 @@
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/module.h>
static void tasklet_fn(unsigned long data) static void tasklet_fn(unsigned long data)
{ {

4
examples/hello-1.c
View File

@ -1,8 +1,8 @@
/* /*
* hello-1.c - The simplest kernel module. * hello-1.c - The simplest kernel module.
*/ */
#include <linux/module.h> /* Needed by all modules */ #include <linux/kernel.h> /* Needed for KERN_INFO */
#include <linux/kernel.h> /* Needed for KERN_INFO */ #include <linux/module.h> /* Needed by all modules */
int init_module(void) int init_module(void)
{ {

6
examples/hello-2.c
View File

@ -2,9 +2,9 @@
* hello-2.c - Demonstrating the module_init() and module_exit() macros. * hello-2.c - Demonstrating the module_init() and module_exit() macros.
* This is preferred over using init_module() and cleanup_module(). * This is preferred over using init_module() and cleanup_module().
*/ */
#include <linux/module.h> /* Needed by all modules */ #include <linux/init.h> /* Needed for the macros */
#include <linux/kernel.h> /* Needed for KERN_INFO */ #include <linux/kernel.h> /* Needed for KERN_INFO */
#include <linux/init.h> /* Needed for the macros */ #include <linux/module.h> /* Needed by all modules */
static int __init hello_2_init(void) static int __init hello_2_init(void)
{ {

6
examples/hello-3.c
View File

@ -1,9 +1,9 @@
/* /*
* hello-3.c - Illustrating the __init, __initdata and __exit macros. * hello-3.c - Illustrating the __init, __initdata and __exit macros.
*/ */
#include <linux/module.h> /* Needed by all modules */ #include <linux/init.h> /* Needed for the macros */
#include <linux/kernel.h> /* Needed for KERN_INFO */ #include <linux/kernel.h> /* Needed for KERN_INFO */
#include <linux/init.h> /* Needed for the macros */ #include <linux/module.h> /* Needed by all modules */
static int hello3_data __initdata = 3; static int hello3_data __initdata = 3;

6
examples/hello-4.c
View File

@ -1,9 +1,9 @@
/* /*
* hello-4.c - Demonstrates module documentation. * hello-4.c - Demonstrates module documentation.
*/ */
#include <linux/module.h> /* Needed by all modules */ #include <linux/init.h> /* Needed for the macros */
#include <linux/kernel.h> /* Needed for KERN_INFO */ #include <linux/kernel.h> /* Needed for KERN_INFO */
#include <linux/init.h> /* Needed for the macros */ #include <linux/module.h> /* Needed by all modules */
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_AUTHOR("Bob Mottram"); MODULE_AUTHOR("Bob Mottram");

8
examples/hello-5.c
View File

@ -1,10 +1,10 @@
/* /*
* 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>
#include <linux/module.h> #include <linux/module.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/stat.h> #include <linux/stat.h>
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
@ -14,7 +14,7 @@ static short int myshort = 1;
static int myint = 420; static int myint = 420;
static long int mylong = 9999; static long int mylong = 9999;
static char *mystring = "blah"; static char *mystring = "blah";
static int myintArray[2] = { -1, -1 }; static int myintArray[2] = {-1, -1};
static int arr_argc = 0; static int arr_argc = 0;
/* /*
@ -54,7 +54,7 @@ static int __init hello_5_init(void)
pr_info("mylong is a long integer: %ld\n", mylong); pr_info("mylong is a long integer: %ld\n", mylong);
pr_info("mystring is a string: %s\n", mystring); pr_info("mystring is a string: %s\n", mystring);
for (i = 0; i < (sizeof myintArray / sizeof (int)); i++) for (i = 0; i < (sizeof myintArray / sizeof(int)); i++)
pr_info("myintArray[%d] = %d\n", i, myintArray[i]); pr_info("myintArray[%d] = %d\n", i, myintArray[i]);
pr_info("got %d arguments for myintArray.\n", arr_argc); pr_info("got %d arguments for myintArray.\n", arr_argc);

26
examples/hello-sysfs.c
View File

@ -2,12 +2,12 @@
* hello-sysfs.c sysfs example * hello-sysfs.c sysfs example
*/ */
#include <linux/module.h>
#include <linux/kobject.h>
#include <linux/sysfs.h>
#include <linux/init.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/init.h>
#include <linux/kobject.h>
#include <linux/module.h>
#include <linux/string.h> #include <linux/string.h>
#include <linux/sysfs.h>
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_AUTHOR("Bob Mottram"); MODULE_AUTHOR("Bob Mottram");
@ -26,7 +26,8 @@ static ssize_t myvariable_show(struct kobject *kobj,
static ssize_t myvariable_store(struct kobject *kobj, static ssize_t myvariable_store(struct kobject *kobj,
struct kobj_attribute *attr, struct kobj_attribute *attr,
char *buf, size_t count) char *buf,
size_t count)
{ {
sscanf(buf, "%du", &myvariable); sscanf(buf, "%du", &myvariable);
return count; return count;
@ -34,30 +35,29 @@ static ssize_t myvariable_store(struct kobject *kobj,
static struct kobj_attribute myvariable_attribute = static struct kobj_attribute myvariable_attribute =
__ATTR(myvariable, 0660, myvariable_show, __ATTR(myvariable, 0660, myvariable_show, (void *) myvariable_store);
(void*)myvariable_store);
static int __init mymodule_init (void) static int __init mymodule_init(void)
{ {
int error = 0; int error = 0;
pr_info("mymodule: initialised\n"); pr_info("mymodule: initialised\n");
mymodule = mymodule = kobject_create_and_add("mymodule", kernel_kobj);
kobject_create_and_add("mymodule", kernel_kobj);
if (!mymodule) if (!mymodule)
return -ENOMEM; return -ENOMEM;
error = sysfs_create_file(mymodule, &myvariable_attribute.attr); error = sysfs_create_file(mymodule, &myvariable_attribute.attr);
if (error) { if (error) {
pr_info("failed to create the myvariable file " \ pr_info(
"in /sys/kernel/mymodule\n"); "failed to create the myvariable file "
"in /sys/kernel/mymodule\n");
} }
return error; return error;
} }
static void __exit mymodule_exit (void) static void __exit mymodule_exit(void)
{ {
pr_info("mymodule: Exit success\n"); pr_info("mymodule: Exit success\n");
kobject_put(mymodule); kobject_put(mymodule);

31
examples/intrpt.c
View File

@ -9,25 +9,21 @@
* 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/module.h>
#include <linux/kernel.h>
#include <linux/gpio.h> #include <linux/gpio.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/module.h>
static int button_irqs[] = { -1, -1 }; static int button_irqs[] = {-1, -1};
/* Define GPIOs for LEDs. /* Define GPIOs for LEDs.
Change the numbers for the GPIO on your board. */ Change the numbers for the GPIO on your board. */
static struct gpio leds[] = { static struct gpio leds[] = {{4, GPIOF_OUT_INIT_LOW, "LED 1"}};
{ 4, GPIOF_OUT_INIT_LOW, "LED 1" }
};
/* Define GPIOs for BUTTONS /* Define GPIOs for BUTTONS
Change the numbers for the GPIO on your board. */ Change the numbers for the GPIO on your board. */
static struct gpio buttons[] = { static struct gpio buttons[] = {{17, GPIOF_IN, "LED 1 ON BUTTON"},
{ 17, GPIOF_IN, "LED 1 ON BUTTON" }, {18, GPIOF_IN, "LED 1 OFF BUTTON"}};
{ 18, GPIOF_IN, "LED 1 OFF BUTTON" }
};
/* /*
* interrupt function triggered when a button is pressed * interrupt function triggered when a button is pressed
@ -36,10 +32,10 @@ static irqreturn_t button_isr(int irq, void *data)
{ {
/* first button */ /* first button */
if (irq == button_irqs[0] && !gpio_get_value(leds[0].gpio)) if (irq == button_irqs[0] && !gpio_get_value(leds[0].gpio))
gpio_set_value(leds[0].gpio, 1); gpio_set_value(leds[0].gpio, 1);
/* second button */ /* second button */
else if(irq == button_irqs[1] && gpio_get_value(leds[0].gpio)) else if (irq == button_irqs[1] && gpio_get_value(leds[0].gpio))
gpio_set_value(leds[0].gpio, 0); gpio_set_value(leds[0].gpio, 0);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
@ -66,8 +62,7 @@ int init_module()
goto fail1; goto fail1;
} }
pr_info("Current button1 value: %d\n", pr_info("Current button1 value: %d\n", gpio_get_value(buttons[0].gpio));
gpio_get_value(buttons[0].gpio));
ret = gpio_to_irq(buttons[0].gpio); ret = gpio_to_irq(buttons[0].gpio);
@ -78,8 +73,7 @@ int init_module()
button_irqs[0] = ret; button_irqs[0] = ret;
pr_info("Successfully requested BUTTON1 IRQ # %d\n", pr_info("Successfully requested BUTTON1 IRQ # %d\n", button_irqs[0]);
button_irqs[0]);
ret = request_irq(button_irqs[0], button_isr, ret = request_irq(button_irqs[0], button_isr,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
@ -100,8 +94,7 @@ int init_module()
button_irqs[1] = ret; button_irqs[1] = ret;
pr_info("Successfully requested BUTTON2 IRQ # %d\n", pr_info("Successfully requested BUTTON2 IRQ # %d\n", button_irqs[1]);
button_irqs[1]);
ret = request_irq(button_irqs[1], button_isr, ret = request_irq(button_irqs[1], button_isr,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,

56
examples/ioctl.c
View File

@ -1,8 +1,8 @@
#include <linux/ioctl.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h> #include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/ioctl.h>
#include <linux/module.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/uaccess.h> #include <linux/uaccess.h>
@ -14,10 +14,10 @@ struct ioctl_arg {
/* Documentation/ioctl/ioctl-number.txt */ /* Documentation/ioctl/ioctl-number.txt */
#define IOC_MAGIC '\x66' #define IOC_MAGIC '\x66'
#define IOCTL_VALSET _IOW(IOC_MAGIC, 0, struct ioctl_arg) #define IOCTL_VALSET _IOW(IOC_MAGIC, 0, struct ioctl_arg)
#define IOCTL_VALGET _IOR(IOC_MAGIC, 1, struct ioctl_arg) #define IOCTL_VALGET _IOR(IOC_MAGIC, 1, struct ioctl_arg)
#define IOCTL_VALGET_NUM _IOR(IOC_MAGIC, 2, int) #define IOCTL_VALGET_NUM _IOR(IOC_MAGIC, 2, int)
#define IOCTL_VALSET_NUM _IOW(IOC_MAGIC, 3, int) #define IOCTL_VALSET_NUM _IOW(IOC_MAGIC, 3, int)
#define IOCTL_VAL_MAXNR 3 #define IOCTL_VAL_MAXNR 3
#define DRIVER_NAME "ioctltest" #define DRIVER_NAME "ioctltest"
@ -32,8 +32,11 @@ struct test_ioctl_data {
rwlock_t lock; rwlock_t lock;
}; };
static long test_ioctl_ioctl(struct file* filp, unsigned int cmd, unsigned long arg) { static long test_ioctl_ioctl(struct file *filp,
struct test_ioctl_data* ioctl_data = filp->private_data; unsigned int cmd,
unsigned long arg)
{
struct test_ioctl_data *ioctl_data = filp->private_data;
int retval = 0; int retval = 0;
unsigned char val; unsigned char val;
struct ioctl_arg data; struct ioctl_arg data;
@ -52,7 +55,7 @@ static long test_ioctl_ioctl(struct file* filp, unsigned int cmd, unsigned long
goto done; goto done;
} }
*/ */
if (copy_from_user(&data, (int __user*)arg, sizeof(data))) { if (copy_from_user(&data, (int __user *) arg, sizeof(data))) {
retval = -EFAULT; retval = -EFAULT;
goto done; goto done;
} }
@ -75,7 +78,7 @@ static long test_ioctl_ioctl(struct file* filp, unsigned int cmd, unsigned long
read_unlock(&ioctl_data->lock); read_unlock(&ioctl_data->lock);
data.val = val; data.val = val;
if (copy_to_user((int __user*)arg, &data, sizeof(data))) { if (copy_to_user((int __user *) arg, &data, sizeof(data))) {
retval = -EFAULT; retval = -EFAULT;
goto done; goto done;
} }
@ -83,7 +86,7 @@ static long test_ioctl_ioctl(struct file* filp, unsigned int cmd, unsigned long
break; break;
case IOCTL_VALGET_NUM: case IOCTL_VALGET_NUM:
retval = __put_user(ioctl_num, (int __user*)arg); retval = __put_user(ioctl_num, (int __user *) arg);
break; break;
case IOCTL_VALSET_NUM: case IOCTL_VALSET_NUM:
@ -102,8 +105,12 @@ done:
return retval; return retval;
} }
ssize_t test_ioctl_read(struct file* filp, char __user* buf, size_t count, loff_t* f_pos) { ssize_t test_ioctl_read(struct file *filp,
struct test_ioctl_data* ioctl_data = filp->private_data; char __user *buf,
size_t count,
loff_t *f_pos)
{
struct test_ioctl_data *ioctl_data = filp->private_data;
unsigned char val; unsigned char val;
int retval; int retval;
int i = 0; int i = 0;
@ -111,7 +118,7 @@ ssize_t test_ioctl_read(struct file* filp, char __user* buf, size_t count, loff_
val = ioctl_data->val; val = ioctl_data->val;
read_unlock(&ioctl_data->lock); read_unlock(&ioctl_data->lock);
for (; i < count ; i++) { for (; i < count; i++) {
if (copy_to_user(&buf[i], &val, 1)) { if (copy_to_user(&buf[i], &val, 1)) {
retval = -EFAULT; retval = -EFAULT;
goto out; goto out;
@ -123,7 +130,8 @@ out:
return retval; return retval;
} }
static int test_ioctl_close(struct inode* inode, struct file* filp) { static int test_ioctl_close(struct inode *inode, struct file *filp)
{
pr_alert("%s call.\n", __func__); pr_alert("%s call.\n", __func__);
if (filp->private_data) { if (filp->private_data) {
@ -134,8 +142,9 @@ static int test_ioctl_close(struct inode* inode, struct file* filp) {
return 0; return 0;
} }
static int test_ioctl_open(struct inode* inode, struct file* filp) { static int test_ioctl_open(struct inode *inode, struct file *filp)
struct test_ioctl_data* ioctl_data; {
struct test_ioctl_data *ioctl_data;
pr_alert("%s call.\n", __func__); pr_alert("%s call.\n", __func__);
ioctl_data = kmalloc(sizeof(struct test_ioctl_data), GFP_KERNEL); ioctl_data = kmalloc(sizeof(struct test_ioctl_data), GFP_KERNEL);
@ -157,7 +166,8 @@ struct file_operations fops = {
.unlocked_ioctl = test_ioctl_ioctl, .unlocked_ioctl = test_ioctl_ioctl,
}; };
static int ioctl_init(void) { static int ioctl_init(void)
{
dev_t dev = MKDEV(test_ioctl_major, 0); dev_t dev = MKDEV(test_ioctl_major, 0);
int alloc_ret = 0; int alloc_ret = 0;
int cdev_ret = 0; int cdev_ret = 0;
@ -175,7 +185,8 @@ static int ioctl_init(void) {
goto error; goto error;
} }
pr_alert("%s driver(major: %d) installed.\n", DRIVER_NAME, test_ioctl_major); pr_alert("%s driver(major: %d) installed.\n", DRIVER_NAME,
test_ioctl_major);
return 0; return 0;
error: error:
@ -190,7 +201,8 @@ error:
return -1; return -1;
} }
static void ioctl_exit(void) { static void ioctl_exit(void)
{
dev_t dev = MKDEV(test_ioctl_major, 0); dev_t dev = MKDEV(test_ioctl_major, 0);
cdev_del(&test_ioctl_cdev); cdev_del(&test_ioctl_cdev);
unregister_chrdev_region(dev, num_of_dev); unregister_chrdev_region(dev, num_of_dev);

34
examples/kbleds.c
View File

@ -2,13 +2,13 @@
* kbleds.c - Blink keyboard leds until the module is unloaded. * kbleds.c - Blink keyboard leds until the module is unloaded.
*/ */
#include <linux/module.h> #include <linux/console_struct.h> /* For vc_cons */
#include <linux/init.h> #include <linux/init.h>
#include <linux/vt_kern.h> /* for fg_console */ #include <linux/kd.h> /* For KDSETLED */
#include <linux/tty.h> /* For fg_console, MAX_NR_CONSOLES */ #include <linux/module.h>
#include <linux/kd.h> /* For KDSETLED */ #include <linux/tty.h> /* For fg_console, MAX_NR_CONSOLES */
#include <linux/vt.h> #include <linux/vt.h>
#include <linux/console_struct.h> /* For vc_cons */ #include <linux/vt_kern.h> /* for fg_console */
MODULE_DESCRIPTION("Example module illustrating the use of Keyboard LEDs."); MODULE_DESCRIPTION("Example module illustrating the use of Keyboard LEDs.");
MODULE_AUTHOR("Daniele Paolo Scarpazza"); MODULE_AUTHOR("Daniele Paolo Scarpazza");
@ -18,9 +18,9 @@ struct timer_list my_timer;
struct tty_driver *my_driver; struct tty_driver *my_driver;
char kbledstatus = 0; char kbledstatus = 0;
#define BLINK_DELAY HZ/5 #define BLINK_DELAY HZ / 5
#define ALL_LEDS_ON 0x07 #define ALL_LEDS_ON 0x07
#define RESTORE_LEDS 0xFF #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
@ -39,15 +39,15 @@ char kbledstatus = 0;
static void my_timer_func(unsigned long ptr) static void my_timer_func(unsigned long ptr)
{ {
unsigned long *pstatus = (unsigned long *)ptr; unsigned long *pstatus = (unsigned long *) ptr;
struct tty_struct* t = vc_cons[fg_console].d->port.tty; struct tty_struct *t = vc_cons[fg_console].d->port.tty;
if (*pstatus == ALL_LEDS_ON) if (*pstatus == ALL_LEDS_ON)
*pstatus = RESTORE_LEDS; *pstatus = RESTORE_LEDS;
else else
*pstatus = ALL_LEDS_ON; *pstatus = ALL_LEDS_ON;
(my_driver->ops->ioctl) (t, KDSETLED, *pstatus); (my_driver->ops->ioctl)(t, KDSETLED, *pstatus);
my_timer.expires = jiffies + BLINK_DELAY; my_timer.expires = jiffies + BLINK_DELAY;
add_timer(&my_timer); add_timer(&my_timer);
@ -62,9 +62,8 @@ static int __init kbleds_init(void)
for (i = 0; i < MAX_NR_CONSOLES; i++) { for (i = 0; i < MAX_NR_CONSOLES; i++) {
if (!vc_cons[i].d) if (!vc_cons[i].d)
break; break;
pr_info("poet_atkm: console[%i/%i] #%i, tty %lx\n", i, pr_info("poet_atkm: console[%i/%i] #%i, tty %lx\n", i, MAX_NR_CONSOLES,
MAX_NR_CONSOLES, vc_cons[i].d->vc_num, vc_cons[i].d->vc_num, (unsigned long) vc_cons[i].d->port.tty);
(unsigned long)vc_cons[i].d->port.tty);
} }
pr_info("kbleds: finished scanning consoles\n"); pr_info("kbleds: finished scanning consoles\n");
@ -74,7 +73,8 @@ static int __init kbleds_init(void)
/* /*
* 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); timer_setup(&my_timer, (void *) &my_timer_func,
(unsigned long) &kbledstatus);
my_timer.expires = jiffies + BLINK_DELAY; my_timer.expires = jiffies + BLINK_DELAY;
add_timer(&my_timer); add_timer(&my_timer);
@ -85,8 +85,8 @@ static void __exit kbleds_cleanup(void)
{ {
pr_info("kbleds: unloading...\n"); pr_info("kbleds: unloading...\n");
del_timer(&my_timer); del_timer(&my_timer);
(my_driver->ops->ioctl) (vc_cons[fg_console].d->port.tty, (my_driver->ops->ioctl)(vc_cons[fg_console].d->port.tty, KDSETLED,
KDSETLED, RESTORE_LEDS); RESTORE_LEDS);
} }
module_init(kbleds_init); module_init(kbleds_init);

20
examples/other/cat_noblock.c
View File

@ -2,20 +2,20 @@
* wait for input */ * wait for input */
/* Copyright (C) 1998 by Ori Pomerantz */ /* Copyright (C) 1998 by Ori Pomerantz */
#include <stdio.h> /* standard I/O */ #include <errno.h> /* for errno */
#include <fcntl.h> /* for open */ #include <fcntl.h> /* for open */
#include <unistd.h> /* for read */ #include <stdio.h> /* standard I/O */
#include <stdlib.h> /* for exit */ #include <stdlib.h> /* for exit */
#include <errno.h> /* for errno */ #include <unistd.h> /* for read */
#define MAX_BYTES 1024*4 #define MAX_BYTES 1024 * 4
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
int fd; /* The file descriptor for the file to read */ int fd; /* The file descriptor for the file to read */
size_t bytes; /* The number of bytes read */ size_t bytes; /* The number of bytes read */
char buffer[MAX_BYTES]; /* The buffer for the bytes */ char buffer[MAX_BYTES]; /* The buffer for the bytes */
/* Usage */ /* Usage */
@ -55,7 +55,7 @@ int main(int argc, char *argv[])
/* Print the characters */ /* Print the characters */
if (bytes > 0) { if (bytes > 0) {
for(i=0; i<bytes; i++) for (i = 0; i < bytes; i++)
putchar(buffer[i]); putchar(buffer[i]);
} }

29
examples/print_string.c
View File

@ -3,12 +3,12 @@
* through X11, telnet, etc. We do this by printing the string to the tty * through X11, telnet, etc. We do this by printing the string to the tty
* associated with the current task. * associated with the current task.
*/ */
#include <linux/init.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h> #include <linux/sched.h> /* For current */
#include <linux/sched.h> /* For current */ #include <linux/tty.h> /* For the tty declarations */
#include <linux/tty.h> /* For the tty declarations */ #include <linux/version.h> /* For LINUX_VERSION_CODE */
#include <linux/version.h> /* For LINUX_VERSION_CODE */
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_AUTHOR("Peter Jay Salzman"); MODULE_AUTHOR("Peter Jay Salzman");
@ -21,7 +21,7 @@ static void print_string(char *str)
/* /*
* tty struct went into signal struct in 2.6.6 * tty struct went into signal struct in 2.6.6
*/ */
#if ( LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,5) ) #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 5))
/* /*
* The tty for the current task * The tty for the current task
*/ */
@ -39,7 +39,6 @@ static void print_string(char *str)
* (ie, if it's a daemon). If so, there's nothing we can do. * (ie, if it's a daemon). If so, there's nothing we can do.
*/ */
if (my_tty != NULL) { if (my_tty != NULL) {
/* /*
* my_tty->driver is a struct which holds the tty's functions, * my_tty->driver is a struct which holds the tty's functions,
* one of which (write) is used to write strings to the tty. * one of which (write) is used to write strings to the tty.
@ -62,13 +61,13 @@ static void print_string(char *str)
* is described in section 2 of * is described in section 2 of
* linux/Documentation/SubmittingPatches * linux/Documentation/SubmittingPatches
*/ */
(ttyops->write) (my_tty, /* The tty itself */ (ttyops->write)(my_tty, /* The tty itself */
#if ( LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,9) ) #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 9))
0, /* Don't take the string 0, /* Don't take the string
from user space */ from user space */
#endif #endif
str, /* String */ str, /* String */
strlen(str)); /* Length */ strlen(str)); /* Length */
/* /*
* ttys were originally hardware devices, which (usually) * ttys were originally hardware devices, which (usually)
@ -85,10 +84,10 @@ static void print_string(char *str)
* and therefore a newline requirs both a LF and a CR. * and therefore a newline requirs both a LF and a CR.
*/ */
#if ( LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,9) ) #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 9))
(ttyops->write) (my_tty, 0, "\015\012", 2); (ttyops->write)(my_tty, 0, "\015\012", 2);
#else #else
(ttyops->write) (my_tty, "\015\012", 2); (ttyops->write)(my_tty, "\015\012", 2);
#endif #endif
} }
} }

27
examples/procfs1.c
View File

@ -2,8 +2,8 @@
procfs1.c procfs1.c
*/ */
#include <linux/module.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/module.h>
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/uaccess.h> #include <linux/uaccess.h>
@ -12,29 +12,30 @@
struct proc_dir_entry *Our_Proc_File; struct proc_dir_entry *Our_Proc_File;
ssize_t procfile_read(struct file *filePointer,char *buffer, ssize_t procfile_read(struct file *filePointer,
size_t buffer_length, loff_t * offset) char *buffer,
size_t buffer_length,
loff_t *offset)
{ {
int ret=0; int ret = 0;
if(strlen(buffer) ==0) { if (strlen(buffer) == 0) {
pr_info("procfile read %s\n",filePointer->f_path.dentry->d_name.name); pr_info("procfile read %s\n", filePointer->f_path.dentry->d_name.name);
ret=copy_to_user(buffer,"HelloWorld!\n",sizeof("HelloWorld!\n")); ret = copy_to_user(buffer, "HelloWorld!\n", sizeof("HelloWorld!\n"));
ret=sizeof("HelloWorld!\n"); ret = sizeof("HelloWorld!\n");
} }
return ret; return ret;
} }
static const struct proc_ops proc_file_fops = { static const struct proc_ops proc_file_fops = {
.proc_read = procfile_read, .proc_read = procfile_read,
}; };
int init_module() int init_module()
{ {
Our_Proc_File = proc_create(procfs_name,0644,NULL,&proc_file_fops); Our_Proc_File = proc_create(procfs_name, 0644, NULL, &proc_file_fops);
if(NULL==Our_Proc_File) { if (NULL == Our_Proc_File) {
proc_remove(Our_Proc_File); proc_remove(Our_Proc_File);
pr_alert("Error:Could not initialize /proc/%s\n",procfs_name); pr_alert("Error:Could not initialize /proc/%s\n", procfs_name);
return -ENOMEM; return -ENOMEM;
} }

44
examples/procfs2.c
View File

@ -3,13 +3,13 @@
* *
*/ */
#include <linux/module.h> /* Specifically, a module */ #include <linux/kernel.h> /* We're doing kernel work */
#include <linux/kernel.h> /* We're doing kernel work */ #include <linux/module.h> /* Specifically, a module */
#include <linux/proc_fs.h> /* Necessary because we use the proc fs */ #include <linux/proc_fs.h> /* Necessary because we use the proc fs */
#include <linux/uaccess.h> /* for copy_from_user */ #include <linux/uaccess.h> /* for copy_from_user */
#define PROCFS_MAX_SIZE 1024 #define PROCFS_MAX_SIZE 1024
#define PROCFS_NAME "buffer1k" #define PROCFS_NAME "buffer1k"
/** /**
* This structure hold information about the /proc file * This structure hold information about the /proc file
@ -33,14 +33,16 @@ 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, ssize_t procfile_read(struct file *filePointer,
size_t buffer_length, loff_t * offset) char *buffer,
size_t buffer_length,
loff_t *offset)
{ {
int ret=0; int ret = 0;
if(strlen(buffer) ==0) { if (strlen(buffer) == 0) {
pr_info("procfile read %s\n",filePointer->f_path.dentry->d_name.name); pr_info("procfile read %s\n", filePointer->f_path.dentry->d_name.name);
ret=copy_to_user(buffer,"HelloWorld!\n",sizeof("HelloWorld!\n")); ret = copy_to_user(buffer, "HelloWorld!\n", sizeof("HelloWorld!\n"));
ret=sizeof("HelloWorld!\n"); ret = sizeof("HelloWorld!\n");
} }
return ret; return ret;
} }
@ -50,8 +52,10 @@ ssize_t procfile_read(struct file *filePointer,char *buffer,
* 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, static ssize_t procfile_write(struct file *file,
size_t len, loff_t *off) const char *buff,
size_t len,
loff_t *off)
{ {
procfs_buffer_size = len; procfs_buffer_size = len;
if (procfs_buffer_size > PROCFS_MAX_SIZE) if (procfs_buffer_size > PROCFS_MAX_SIZE)
@ -65,8 +69,8 @@ static ssize_t procfile_write(struct file *file, const char *buff,
} }
static const struct proc_ops proc_file_fops = { static const struct proc_ops proc_file_fops = {
.proc_read = procfile_read, .proc_read = procfile_read,
.proc_write = procfile_write, .proc_write = procfile_write,
}; };
/** /**
@ -75,10 +79,10 @@ static const struct proc_ops proc_file_fops = {
*/ */
int init_module() int init_module()
{ {
Our_Proc_File = proc_create(PROCFS_NAME,0644,NULL,&proc_file_fops); Our_Proc_File = proc_create(PROCFS_NAME, 0644, NULL, &proc_file_fops);
if(NULL==Our_Proc_File) { if (NULL == Our_Proc_File) {
proc_remove(Our_Proc_File); proc_remove(Our_Proc_File);
pr_alert("Error:Could not initialize /proc/%s\n",PROCFS_NAME); pr_alert("Error:Could not initialize /proc/%s\n", PROCFS_NAME);
return -ENOMEM; return -ENOMEM;
} }

44
examples/procfs3.c
View File

@ -8,37 +8,40 @@
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/uaccess.h> #include <linux/uaccess.h>
#define PROCFS_MAX_SIZE 2048 #define PROCFS_MAX_SIZE 2048
#define PROCFS_ENTRY_FILENAME "buffer2k" #define PROCFS_ENTRY_FILENAME "buffer2k"
struct proc_dir_entry *Our_Proc_File; struct proc_dir_entry *Our_Proc_File;
static char procfs_buffer[PROCFS_MAX_SIZE]; static char procfs_buffer[PROCFS_MAX_SIZE];
static unsigned long procfs_buffer_size = 0; static unsigned long procfs_buffer_size = 0;
static ssize_t procfs_read(struct file *filp, char *buffer, static ssize_t procfs_read(struct file *filp,
size_t length, loff_t *offset) char *buffer,
size_t length,
loff_t *offset)
{ {
static int finished = 0; static int finished = 0;
if(finished) if (finished) {
{
pr_debug("procfs_read: END\n"); pr_debug("procfs_read: END\n");
finished = 0; finished = 0;
return 0; return 0;
} }
finished = 1; finished = 1;
if(copy_to_user(buffer, procfs_buffer, procfs_buffer_size)) if (copy_to_user(buffer, procfs_buffer, procfs_buffer_size))
return -EFAULT; return -EFAULT;
pr_debug("procfs_read: read %lu bytes\n", procfs_buffer_size); pr_debug("procfs_read: read %lu bytes\n", procfs_buffer_size);
return procfs_buffer_size; return procfs_buffer_size;
} }
static ssize_t procfs_write(struct file *file, const char *buffer, static ssize_t procfs_write(struct file *file,
size_t len, loff_t *off) const char *buffer,
size_t len,
loff_t *off)
{ {
if(len>PROCFS_MAX_SIZE) if (len > PROCFS_MAX_SIZE)
procfs_buffer_size = PROCFS_MAX_SIZE; procfs_buffer_size = PROCFS_MAX_SIZE;
else else
procfs_buffer_size = len; procfs_buffer_size = len;
if(copy_from_user(procfs_buffer, buffer, procfs_buffer_size)) if (copy_from_user(procfs_buffer, buffer, procfs_buffer_size))
return -EFAULT; return -EFAULT;
pr_debug("procfs_write: write %lu bytes\n", procfs_buffer_size); pr_debug("procfs_write: write %lu bytes\n", procfs_buffer_size);
return procfs_buffer_size; return procfs_buffer_size;
@ -55,23 +58,24 @@ int procfs_close(struct inode *inode, struct file *file)
} }
static struct proc_ops File_Ops_4_Our_Proc_File = { static struct proc_ops File_Ops_4_Our_Proc_File = {
.proc_read = procfs_read, .proc_read = procfs_read,
.proc_write = procfs_write, .proc_write = procfs_write,
.proc_open = procfs_open, .proc_open = procfs_open,
.proc_release = procfs_close, .proc_release = procfs_close,
}; };
int init_module() int init_module()
{ {
Our_Proc_File = proc_create(PROCFS_ENTRY_FILENAME, 0644, NULL,&File_Ops_4_Our_Proc_File); Our_Proc_File = proc_create(PROCFS_ENTRY_FILENAME, 0644, NULL,
if(Our_Proc_File == NULL) &File_Ops_4_Our_Proc_File);
{ if (Our_Proc_File == NULL) {
remove_proc_entry(PROCFS_ENTRY_FILENAME, NULL); remove_proc_entry(PROCFS_ENTRY_FILENAME, NULL);
pr_debug("Error: Could not initialize /proc/%s\n", PROCFS_ENTRY_FILENAME); pr_debug("Error: Could not initialize /proc/%s\n",
PROCFS_ENTRY_FILENAME);
return -ENOMEM; return -ENOMEM;
} }
proc_set_size(Our_Proc_File, 80); proc_set_size(Our_Proc_File, 80);
proc_set_user(Our_Proc_File, GLOBAL_ROOT_UID, GLOBAL_ROOT_GID); proc_set_user(Our_Proc_File, GLOBAL_ROOT_UID, GLOBAL_ROOT_GID);
pr_debug("/proc/%s created\n", PROCFS_ENTRY_FILENAME); pr_debug("/proc/%s created\n", PROCFS_ENTRY_FILENAME);
return 0; return 0;

40
examples/procfs4.c
View File

@ -4,12 +4,12 @@
* *
*/ */
#include <linux/kernel.h> /* We're doing kernel work */ #include <linux/kernel.h> /* We're doing kernel work */
#include <linux/module.h> /* Specifically, a module */ #include <linux/module.h> /* Specifically, a module */
#include <linux/proc_fs.h> /* Necessary because we use proc fs */ #include <linux/proc_fs.h> /* Necessary because we use proc fs */
#include <linux/seq_file.h> /* for seq_file */ #include <linux/seq_file.h> /* for seq_file */
#define PROC_NAME "iter" #define PROC_NAME "iter"
MODULE_AUTHOR("Philippe Reynes"); MODULE_AUTHOR("Philippe Reynes");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
@ -26,11 +26,10 @@ static void *my_seq_start(struct seq_file *s, loff_t *pos)
static unsigned long counter = 0; static unsigned long counter = 0;
/* beginning a new sequence ? */ /* beginning a new sequence ? */
if ( *pos == 0 ) { if (*pos == 0) {
/* yes => return a non null value to begin the sequence */ /* yes => return a non null value to begin the sequence */
return &counter; return &counter;
} } else {
else {
/* no => it's the end of the sequence, return end to stop reading */ /* no => it's the end of the sequence, return end to stop reading */
*pos = 0; *pos = 0;
return NULL; return NULL;
@ -44,7 +43,7 @@ static void *my_seq_start(struct seq_file *s, loff_t *pos)
*/ */
static void *my_seq_next(struct seq_file *s, void *v, loff_t *pos) static void *my_seq_next(struct seq_file *s, void *v, loff_t *pos)
{ {
unsigned long *tmp_v = (unsigned long *)v; unsigned long *tmp_v = (unsigned long *) v;
(*tmp_v)++; (*tmp_v)++;
(*pos)++; (*pos)++;
return NULL; return NULL;
@ -75,12 +74,10 @@ static int my_seq_show(struct seq_file *s, void *v)
* This structure gather "function" to manage the sequence * This structure gather "function" to manage the sequence
* *
*/ */
static struct seq_operations my_seq_ops = { static struct seq_operations my_seq_ops = {.start = my_seq_start,
.start = my_seq_start, .next = my_seq_next,
.next = my_seq_next, .stop = my_seq_stop,
.stop = my_seq_stop, .show = my_seq_show};
.show = my_seq_show
};
/** /**
* This function is called when the /proc file is open. * This function is called when the /proc file is open.
@ -95,12 +92,10 @@ static int my_open(struct inode *inode, struct file *file)
* This structure gather "function" that manage the /proc file * This structure gather "function" that manage the /proc file
* *
*/ */
static struct proc_ops my_file_ops = { static struct proc_ops my_file_ops = {.proc_open = my_open,
.proc_open = my_open, .proc_read = seq_read,
.proc_read = seq_read, .proc_lseek = seq_lseek,
.proc_lseek = seq_lseek, .proc_release = seq_release};
.proc_release = seq_release
};
/** /**
@ -112,8 +107,7 @@ int init_module(void)
struct proc_dir_entry *entry; struct proc_dir_entry *entry;
entry = proc_create(PROC_NAME, 0, NULL, &my_file_ops); entry = proc_create(PROC_NAME, 0, NULL, &my_file_ops);
if(entry == NULL) if (entry == NULL) {
{
remove_proc_entry(PROC_NAME, NULL); remove_proc_entry(PROC_NAME, NULL);
pr_debug("Error: Could not initialize /proc/%s\n", PROC_NAME); pr_debug("Error: Could not initialize /proc/%s\n", PROC_NAME);
return -ENOMEM; return -ENOMEM;

6
examples/sched.c
View File

@ -1,13 +1,13 @@
#include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/module.h>
#include <linux/workqueue.h> #include <linux/workqueue.h>
static struct workqueue_struct *queue=NULL; static struct workqueue_struct *queue = NULL;
static struct work_struct work; static struct work_struct work;
static void work_handler(struct work_struct *data) static void work_handler(struct work_struct *data)
{ {
pr_info ("work handler function.\n"); pr_info("work handler function.\n");
} }
int init_module() int init_module()

63
examples/sleep.c
View File

@ -3,12 +3,12 @@
* the same time, put all but one to sleep * the same time, put all but one to sleep
*/ */
#include <linux/kernel.h> /* We're doing kernel work */ #include <linux/kernel.h> /* We're doing kernel work */
#include <linux/module.h> /* Specifically, a module */ #include <linux/module.h> /* Specifically, a module */
#include <linux/proc_fs.h> /* Necessary because we use proc fs */ #include <linux/proc_fs.h> /* Necessary because we use proc fs */
#include <linux/sched.h> /* For putting processes to sleep and #include <linux/sched.h> /* For putting processes to sleep and
waking them up */ waking them up */
#include <linux/uaccess.h> /* for get_user and put_user */ #include <linux/uaccess.h> /* for get_user and put_user */
/* /*
* The module's file functions * The module's file functions
@ -30,10 +30,10 @@ static struct proc_dir_entry *Our_Proc_File;
* function * function
*/ */
static ssize_t module_output(struct file *file, /* see include/linux/fs.h */ static ssize_t module_output(struct file *file, /* see include/linux/fs.h */
char *buf, /* The buffer to put data to char *buf, /* The buffer to put data to
(in the user segment) */ (in the user segment) */
size_t len, /* The length of the buffer */ size_t len, /* The length of the buffer */
loff_t * offset) loff_t *offset)
{ {
static int finished = 0; static int finished = 0;
int i; int i;
@ -57,17 +57,17 @@ static ssize_t module_output(struct file *file, /* see include/linux/fs.h */
put_user(message[i], buf + i); put_user(message[i], buf + i);
finished = 1; finished = 1;
return i; /* Return the number of bytes "read" */ return i; /* Return the number of bytes "read" */
} }
/* /*
* This function receives input from the user when the user writes to the /proc * This function receives input from the user when the user writes to the /proc
* file. * file.
*/ */
static ssize_t module_input(struct file *file, /* The file itself */ static ssize_t module_input(struct file *file, /* The file itself */
const char *buf, /* The buffer with input */ const char *buf, /* The buffer with input */
size_t length, /* The buffer's length */ size_t length, /* The buffer's length */
loff_t * offset) /* offset to file - ignore */ loff_t *offset) /* offset to file - ignore */
{ {
int i; int i;
@ -144,20 +144,19 @@ static int module_open(struct inode *inode, struct file *file)
/* /*
* Emmanuel Papirakis: * Emmanuel Papirakis:
* *
* This is a little update to work with 2.2.*. Signals now are contained in * This is a little update to work with 2.2.*. Signals now are
* two words (64 bits) and are stored in a structure that contains an array of * contained in two words (64 bits) and are stored in a structure that
* two unsigned longs. We now have to make 2 checks in our if. * contains an array of two unsigned longs. We now have to make 2
* checks in our if.
* *
* Ori Pomerantz: * Ori Pomerantz:
* *
* Nobody promised me they'll never use more than 64 bits, or that this book * Nobody promised me they'll never use more than 64 bits, or that this
* won't be used for a version of Linux with a word size of 16 bits. This code * book won't be used for a version of Linux with a word size of 16
* would work in any case. * bits. This code would work in any case.
*/ */
for (i = 0; i < _NSIG_WORDS && !is_sig; i++) for (i = 0; i < _NSIG_WORDS && !is_sig; i++)
is_sig = is_sig = current->pending.signal.sig[i] & ~current->blocked.sig[i];
current->pending.signal.sig[i] & ~current->
blocked.sig[i];
if (is_sig) { if (is_sig) {
/* /*
@ -183,7 +182,7 @@ static int module_open(struct inode *inode, struct file *file)
* Open the file * Open the file
*/ */
Already_Open = 1; Already_Open = 1;
return 0; /* Allow the access */ return 0; /* Allow the access */
} }
/* /*
@ -207,7 +206,7 @@ int module_close(struct inode *inode, struct file *file)
module_put(THIS_MODULE); module_put(THIS_MODULE);
return 0; /* success */ return 0; /* success */
} }
/* /*
@ -221,10 +220,10 @@ int module_close(struct inode *inode, struct file *file)
* means we don't want to deal with something. * means we don't want to deal with something.
*/ */
static struct proc_ops File_Ops_4_Our_Proc_File = { static struct proc_ops File_Ops_4_Our_Proc_File = {
.proc_read = module_output, /* "read" from the file */ .proc_read = module_output, /* "read" from the file */
.proc_write = module_input, /* "write" to the file */ .proc_write = module_input, /* "write" to the file */
.proc_open = module_open, /* called when the /proc file is opened */ .proc_open = module_open, /* called when the /proc file is opened */
.proc_release = module_close, /* called when it's closed */ .proc_release = module_close, /* called when it's closed */
}; };
/* /*
@ -237,15 +236,15 @@ static struct proc_ops File_Ops_4_Our_Proc_File = {
int init_module() int init_module()
{ {
Our_Proc_File = proc_create(PROC_ENTRY_FILENAME, 0644, NULL, &File_Ops_4_Our_Proc_File); Our_Proc_File =
if(Our_Proc_File == NULL) proc_create(PROC_ENTRY_FILENAME, 0644, NULL, &File_Ops_4_Our_Proc_File);
{ if (Our_Proc_File == NULL) {
remove_proc_entry(PROC_ENTRY_FILENAME, NULL); remove_proc_entry(PROC_ENTRY_FILENAME, NULL);
pr_debug("Error: Could not initialize /proc/%s\n", PROC_ENTRY_FILENAME); pr_debug("Error: Could not initialize /proc/%s\n", PROC_ENTRY_FILENAME);
return -ENOMEM; return -ENOMEM;
} }
proc_set_size(Our_Proc_File, 80); proc_set_size(Our_Proc_File, 80);
proc_set_user(Our_Proc_File, GLOBAL_ROOT_UID, GLOBAL_ROOT_GID); proc_set_user(Our_Proc_File, GLOBAL_ROOT_UID, GLOBAL_ROOT_GID);
pr_info("/proc/test created\n"); pr_info("/proc/test created\n");

4
examples/start.c
View File

@ -2,8 +2,8 @@
* 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're doing kernel work */
#include <linux/module.h> /* Specifically, a module */ #include <linux/module.h> /* Specifically, a module */
int init_module(void) int init_module(void)
{ {

4
examples/stop.c
View File

@ -2,8 +2,8 @@
* 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're doing kernel work */
#include <linux/module.h> /* Specifically, a module */ #include <linux/module.h> /* Specifically, a module */
void cleanup_module() void cleanup_module()
{ {

28
examples/syscall.c
View File

@ -10,13 +10,13 @@
* https://bbs.archlinux.org/viewtopic.php?id=139406 * https://bbs.archlinux.org/viewtopic.php?id=139406
*/ */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/syscalls.h>
#include <linux/delay.h>
#include <asm/paravirt.h> #include <asm/paravirt.h>
#include <linux/moduleparam.h> /* which will have params */ #include <linux/delay.h>
#include <linux/unistd.h> /* The list of system calls */ #include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h> /* which will have params */
#include <linux/syscalls.h>
#include <linux/unistd.h> /* The list of system calls */
/* /*
* For the current (process) structure, we need * For the current (process) structure, we need
@ -48,7 +48,7 @@ module_param(uid, int, 0644);
* Another reason for this is that we can't get sys_open. * Another reason for this is that we can't get sys_open.
* It's a static variable, so it is not exported. * It's a static variable, so it is not exported.
*/ */
asmlinkage int (*original_call) (const char *, int, int); asmlinkage int (*original_call)(const char *, int, int);
/* /*
* The function we'll replace sys_open (the function * The function we'll replace sys_open (the function
@ -93,7 +93,7 @@ static unsigned long **aquire_sys_call_table(void)
unsigned long **sct; unsigned long **sct;
while (offset < ULLONG_MAX) { while (offset < ULLONG_MAX) {
sct = (unsigned long **)offset; sct = (unsigned long **) offset;
if (sct[__NR_close] == (unsigned long *) ksys_close) if (sct[__NR_close] == (unsigned long *) ksys_close)
return sct; return sct;
@ -106,7 +106,7 @@ static unsigned long **aquire_sys_call_table(void)
static int __init syscall_start(void) static int __init syscall_start(void)
{ {
if(!(sys_call_table = aquire_sys_call_table())) if (!(sys_call_table = aquire_sys_call_table()))
return -1; return -1;
original_cr0 = read_cr0(); original_cr0 = read_cr0();
@ -114,10 +114,10 @@ static int __init syscall_start(void)
write_cr0(original_cr0 & ~0x00010000); write_cr0(original_cr0 & ~0x00010000);
/* keep track of the original open function */ /* keep track of the original open function */
original_call = (void*)sys_call_table[__NR_open]; original_call = (void *) sys_call_table[__NR_open];
/* use our open function instead */ /* use our open function instead */
sys_call_table[__NR_open] = (unsigned long *)our_sys_open; sys_call_table[__NR_open] = (unsigned long *) our_sys_open;
write_cr0(original_cr0); write_cr0(original_cr0);
@ -128,14 +128,14 @@ static int __init syscall_start(void)
static void __exit syscall_end(void) static void __exit syscall_end(void)
{ {
if(!sys_call_table) { if (!sys_call_table) {
return; 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) { if (sys_call_table[__NR_open] != (unsigned long *) our_sys_open) {
pr_alert("Somebody else also played with the "); pr_alert("Somebody else also played with the ");
pr_alert("open system call\n"); pr_alert("open system call\n");
pr_alert("The system may be left in "); pr_alert("The system may be left in ");
@ -143,7 +143,7 @@ static void __exit syscall_end(void)
} }
write_cr0(original_cr0 & ~0x00010000); write_cr0(original_cr0 & ~0x00010000);
sys_call_table[__NR_open] = (unsigned long *)original_call; sys_call_table[__NR_open] = (unsigned long *) original_call;
write_cr0(original_cr0); write_cr0(original_cr0);
msleep(2000); msleep(2000);