[OpenEuler]OS实验

#include<linux/module.h>
MODULE_LICENSE("GPL");
int __init hello_init(void)
{
    printk("hello init\n");
    printk("hello,world!\n");
    return 0;
}
void __exit hello_exit(void)
{
    printk("hello exit\n");
}
module_init(hello_init);
module_exit(hello_exit);

#include <linux/module.h>
#include <linux/slab.h>
MODULE LICENSE("GPL");
unsigned char *kmallocmem1;
unsigned char *kmallocmem2;
static int __init mem_module_init(void)
{
    printk("Start kmalloc!\n");
    kmallocmem1 = (unsigned char*)kmalloc(1024, GFP_KERNEL);
    if (kmallocmem1 != NULL) {
        printk(KERN_ALERT "kmallocmeml addr = %lx\n", (unsigned long)kmallocmem1);
    }else{
        printk("Failed to allocate kmallocmem1!\n");
    }
    kmallocmem2 = (unsigned char *)kmalloc(8192, GFP_KERNEL);
    if (kmallocmem2 != NULL) {
        printk(KERN_ALERT "kmallocmem2 addr = %lx\n", (unsigned long)kmallocmem1);
    }
    else{
    printk("Failed to allocate kmallocmem2!\n");
    }
    return 0;
}

static void __exit mem_module_exit(void)
{
    kfree(kmallocmem1);
    kfree(kmallocmem2);
    printk("Exit kmalloc!\n");
}
module_init(mem_module_init);
module_exit(mem_module_exit);

#include <linux/module.h>
#include <linux/vmalloc.h>

MODULE_LICENSE("GPL");

unsigned char *vmallocmem1;
unsigned char *vmallocmem2;
unsigned char *vmallocmem3;

static int __init mem_module_init(void)
{
    printk("Start vmalloc!\n");

    vmallocmem1 = (unsigned char *)vmalloc(8192);
    if (vmallocmem1 != NULL) {
        printk(KERN_ALERT "vmallocmem1 addr = %px\n", vmallocmem1);
    } else {
        printk("Failed to allocate vmallocmem1!\n");
    }

    vmallocmem2 = (unsigned char *)vmalloc(1048576);
    if (vmallocmem2 != NULL) {
        printk(KERN_ALERT "vmallocmem2 addr = %px\n", vmallocmem2);
    } else {
        printk("Failed to allocate vmallocmem2!\n");
    }

    vmallocmem3 = (unsigned char *)vmalloc(67108864);
    if (vmallocmem3 != NULL) {
        printk(KERN_ALERT "vmallocmem3 addr = %px\n", vmallocmem3);
    } else {
        printk("Failed to allocate vmallocmem3!\n");
    }

    return 0;
}

static void __exit mem_module_exit(void)
{
    vfree(vmallocmem1);
    vfree(vmallocmem2);
    vfree(vmallocmem3);
    printk("Exit vmalloc!\n");
}

module_init(mem_module_init);
module_exit(mem_module_exit);

#include <linux/kthread.h>
#include <linux/module.h>
#include <linux/delay.h>
MODULE_LICENSE("GPL");
#define BUF_SIZE 20
static struct task_struct *myThread= NULL;
static int print(void *data)
{
    while(!kthread_should_stop()) {
        printk("New kthread is running.");
        msleep(2000);
    }
    return 0;
}


static int __init kthread_init(void)
{
    printk("Create kernel thread!\n");
    myThread = kthread_run(print, NULL, "myThread");
    return 0;
}


static void __exit kthread_exit(void)
{
    printk("Kill new kthread.\n");
    if(myThread)
        kthread_stop(myThread);
}

module_init(kthread_init);
module_exit(kthread_exit);

#include <linux/module.h>
#include <linux/sched/signal.h>
#include <linux/sched.h>
MODULE_LICENSE("GPL");

struct task_struct *p;

static int __init process_info_init(void)
{
    printk("Start process_info!\n");
    for_each_process(p) {
        if (task_state(p) == TASK_RUNNING)
            printk("1)name:%s 2)pid:%d 3)state: %ld\n", p->comm, p->pid, p->state);
    }
    return 0;
}

static void __exit process_info_exit(void)
{
    printk("Exit process_info!\n");
}

module_init(process_info_init);
module_exit(process_info_exit);

#include <linux/module.h>
#include <linux/interrupt.h>
MODULE_LICENSE("GPL");
static struct tasklet_struct my_tasklet;

static void tasklet_handler(unsigned long data)
{
    printk("Hello World! tasklet is working...\n");
}

static int __init mytasklet_init(void)
{
    printk("Start tasklet module...\n");
    tasklet_init(&my_tasklet, tasklet_handler, 0);
    tasklet_schedule(&my_tasklet);
    return 0;
}

static void __exit mytasklet_exit(void)
{
    tasklet_kill(&my_tasklet);
    printk("Exit tasklet module...\n");
}

module_init(mytasklet_init);
module_exit(mytasklet_exit);

#include <linux/module.h>
#include <linux/workqueue.h>
#include <linux/delay.h>
MODULE_LICENSE("GPL");
static struct workqueue_struct *queue = NULL;
static struct delayed_work mywork;
static int i = 0;

//work handle
void work_handle(struct work_struct *work)
{
    printk(KERN_ALERT "Hello World!\n");
}

static int __init timewq_init(void)
{ 
    printk(KERN_ALERT "Start workqueue_test module.");
    queue= create_singlethread_workqueue("workqueue_test");
    if(queue == NULL)
    {
        printk(KERN_ALERT "Failed to create workqueue_test!\n");
        return -1;
    }
    INIT_DELAYED_WORK(&mywork, work_handle);
    for(;i<= 3; i++){
        queue_delayed_work(queue, &mywork, 5* HZ);
        ssleep(15);
    }
    return 0;
}

static void __exit timewq_exit(void)
{
    flush_workqueue(queue);
    destroy_workqueue(queue);
    printk(KERN_ALERT "Exit workqueue_test module.");
}

module_init(timewq_init);
module_exit(timewq_exit);

#include <signal.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

void signal_handler(int sig)
{
    switch(sig) {
        case SIGINT:
            printf("\nGet a signal:SIGINT. You pressed ctrl+c.\n");
            break;
        case SIGQUIT:
            printf("\nGet a signal:SIGQUIT. You pressed ctrl+\\.\n");
            break;
        case SIGTSTP: 
            printf("\nGet a signal:SIGTSTP. You pressed ctrl+z.\n");
            break;
    }
    exit(0);
}

int main()
{
    printf("Current process ID is %d\n", getpid());
    signal(SIGINT, signal_handler);
    signal(SIGQUIT, signal_handler);
    signal(SIGTSTP, signal_handler);
    for(;;);
}

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/rtc.h>
#include <linux/file.h>
#include <linux/uaccess.h>

#define BUF_SIZE 1024
#define WRITE_TIMES 524288

MODULE_LICENSE("GPL");

struct timeval tv;

static int __init write_disk_init(void)
{
    struct file *fp_write;
    char buf[BUF_SIZE];
    int i;
    int write_start_time;
    int write_start_time_u;
    int write_end_time;
    int write_end_time_u;
    int write_time;
    loff_t pos;

    printk("Start write_to_disk module...\n");

    for (i = 0; i < BUF_SIZE; i++)
    {
        buf[i] = i + '0';
    }

    fp_write = filp_open("/home/tmp_file", O_RDWR | O_CREAT, 0644);
    if (IS_ERR(fp_write))
    {
        printk("Failed to open file...\n");
        return -1;
    }

    pos = 0;
    do_gettimeofday(&tv);
    write_start_time = (int)tv.tv_sec;
    write_start_time_u = (int)tv.tv_usec;

    for (i = 0; i < WRITE_TIMES; i++)
    {
        kernel_write(fp_write, buf, BUF_SIZE, &pos);
    }

    do_gettimeofday(&tv);
    write_end_time = (int)tv.tv_sec;
    write_end_time_u = (int)tv.tv_usec;

    filp_close(fp_write, NULL);

    write_time = (write_end_time - write_start_time) * 1000000 + (write_end_time_u - write_start_time_u);

    printk(KERN_ALERT "Writing to file costs %d us\n", write_time);
    printk("Writing speed is %d M/s\n", BUF_SIZE * WRITE_TIMES / write_time);

    return 0;
}

static void __exit write_disk_exit(void)
{
    printk("Exit write_to_disk module...\n");
}

module_init(write_disk_init);
module_exit(write_disk_exit);

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/rtc.h>
#include <linux/file.h>
#include <linux/uaccess.h>

#define BUF_SIZE 1024
#define READ_TIMES 524288

MODULE_LICENSE("GPL");

struct timeval tv;

static int __init read_disk_init(void)
{
    struct file *fp_read;
    char buf[BUF_SIZE];
    int i;
    int read_start_time;
    int read_start_time_u;
    int read_end_time;
    int read_end_time_u;
    int read_time;
    loff_t pos;

    printk("Start read_from_disk module...\n");

    fp_read = filp_open("/home/tmp_file", O_RDONLY, 0);
    if (IS_ERR(fp_read))
    {
        printk("Failed to open file...\n");
        return -1;
    }

    pos = 0;
    do_gettimeofday(&tv);
    read_start_time = (int)tv.tv_sec;
    read_start_time_u = (int)tv.tv_usec;

    for (i = 0; i < READ_TIMES; i++)
    {
        kernel_read(fp_read, buf, BUF_SIZE, &pos);
    }

    do_gettimeofday(&tv);
    read_end_time = (int)tv.tv_sec;
    read_end_time_u = (int)tv.tv_usec;

    filp_close(fp_read, NULL);

    read_time = (read_end_time - read_start_time) * 1000000 + (read_end_time_u - read_start_time_u);

    printk(KERN_ALERT "Reading from file costs %d us\n", read_time);
    printk("Reading speed is %d M/s\n", BUF_SIZE * READ_TIMES / read_time);

    return 0;
}

static void __exit read_disk_exit(void)
{
    printk("Exit read_from_disk module...\n");
}

module_init(read_disk_init);
module_exit(read_disk_exit);

#include <linux/module.h>
#include <linux/fs.h>

MODULE_LICENSE("GPL");
static struct file_system_type myfs_type = {
    .name = "myfs",
    .owner = THIS_MODULE,
};

static int __init register_newfs_init(void)
{
    printk("Start register_newfs module...");
    return register_filesystem(&myfs_type);
}

static void __exit register_newfs_exit(void)
{
    printk("Exit register_newfs module...");
    unregister_filesystem(&myfs_type);
}

module_init(register_newfs_init);
module_exit(register_newfs_exit);

#include <linux/module.h>
#include <linux/proc_fs.h>

MODULE_LICENSE("GPL");
static struct proc_dir_entry *myproc_dir;

static int __init myproc_init(void)
{
    int ret = 0;
    printk("Start proc_mkdir module...");
    myproc_dir = proc_mkdir("myproc", NULL);
    if (myproc_dir == NULL)
        return -ENOMEM;
    return ret;
}

static void __exit myproc_exit(void)
{
    printk("Exit proc_mkdir module...");
    proc_remove(myproc_dir);
}

module_init(myproc_init);
module_exit(myproc_exit);

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

#define PORT 40000
#define BUF_SIZE 1024

int main(void)
{
    int sock_fd;
    char buffer[BUF_SIZE];
    int size;
    int len;
    int ret;
    struct sockaddr_in server_addr; 
    if ((sock_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP)) == -1) { 
        printf("Failed to create a socket!\n");
        return 0;
    }

    // server information
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    bzero(buffer, BUF_SIZE);
    len = sizeof(server_addr);

    // read from stdin and send to server
    while (1) {
        printf("Please enter the content to be sent:\n");
        size = read(0, buffer, BUF_SIZE);
        if (size) {
            sendto(sock_fd, buffer, size, 0, (struct sockaddr*)&server_addr, len);
            bzero(buffer, BUF_SIZE);
        }
    }
    close(sock_fd);
    return 0;
}

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

#define PORT 40000
#define BUF_SIZE 1024

int main(void) {
    int sock_fd;
    int len;
    char buffer[BUF_SIZE];
    struct sockaddr_in server_addr, client_addr;
    
    if ((sock_fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
        printf("Failed to create a socket!\n");
        return 0;
    }
    
    // server information
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    
    if (bind(sock_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        printf("Failed to bind the socket!\n");
        return 0;
    }
    
    len = sizeof(client_addr);
    
    // receive and print
    while (1) {
        bzero(buffer, BUF_SIZE);
        
        if (recvfrom(sock_fd, buffer, BUF_SIZE, 0, (struct sockaddr*)&client_addr, &len) != -1) {
            printf("The message received is: %s", buffer);
        }
    }
    
    return 0;
}

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

#define PORT 40000
#define BUF_SIZE 1024

int main(void) {
    int sock_fd;
    int len;
    char buffer[BUF_SIZE];
    struct sockaddr_in server_addr;
    
    if ((sock_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("Failed to create a socket!\n");
        return 0;
    }
    
    // server information
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    if (connect(sock_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        printf("Failed to connect to the server!\n");
        return 0;
    }
    
    // send and receive messages
    while (1) {
        printf("Enter message to send to server: ");
        fgets(buffer, BUF_SIZE, stdin);
        
        // send message to server
        if (send(sock_fd, buffer, strlen(buffer), 0) == -1) {
            printf("Failed to send message to the server!\n");
            break;
        }
        
        // receive message from server
        bzero(buffer, BUF_SIZE);
        if (recv(sock_fd, buffer, BUF_SIZE, 0) == -1) {
            printf("Failed to receive message from the server!\n");
            break;
        }
        
        printf("Received message from server: %s\n", buffer);
    }
    
    close(sock_fd);
    
    return 0;
}

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

#define PORT 40000
#define BUF_SIZE 1024

int main(void) {
    int server_fd, client_fd;
    int len;
    char buffer[BUF_SIZE];
    struct sockaddr_in server_addr, client_addr;
    
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("Failed to create a socket!\n");
        return 0;
    }
    
    // server information
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    
    if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        printf("Failed to bind the socket!\n");
        return 0;
    }
    
    if (listen(server_fd, 5) == -1) {
        printf("Failed to listen on the socket!\n");
        return 0;
    }
    
    len = sizeof(client_addr);
    
    // accept connection from client
    if ((client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &len)) == -1) {
        printf("Failed to accept the connection!\n");
        return 0;
    }
    
    // send and receive messages
    while (1) {
        // receive message from client
        bzero(buffer, BUF_SIZE);
        if (recv(client_fd, buffer, BUF_SIZE, 0) == -1) {
            printf("Failed to receive message from the client!\n");
            break;
        }
        
        printf("Received message from client: %s\n", buffer);
        
        printf("Enter message to send to client: ");
        fgets(buffer, BUF_SIZE, stdin);
        
        // send message to client
        if (send(client_fd, buffer, strlen(buffer), 0) == -1) {
            printf("Failed to send message to the client!\n");
            break;
        }
    }
    
    close(client_fd);
    close(server_fd);
    
    return 0;
}