/sys/kernel/slab下是什么文件

在Linux系统中，/sys/kernel/slab目录下包含了一些与内核内存分配器（slab allocator）相关的文件。这些文件用于显示和控制内核中的内存分配情况，可以帮助诊断内存泄漏等问题。常见的文件包括：

- active_objs：当前正在使用的对象数目。
- num_slabs：当前分配的slab数量。
- obj_size：每个对象的大小。
- total_obj：总共分配的对象数目。
- total_slabs：总共分配的slab数目。
- slabs_scanned：扫描的slab数目。
- slabs_alloc：分配的slab数目。
- slabs_free：释放的slab数目。
- slabs_partial：部分使用的slab数目。
- obj_per_slab：每个slab中的对象数目。

这些文件只能被root用户访问。

相关问题

内核和应用层内存映射 I/O的完整源码

这里是一个简单的内核和应用层内存映射 I/O 的完整源码，包含了内核模块和用户程序部分：

##### 内核模块部分

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/mm.h>

#define DEVICE_NAME "my_mmap"

MODULE_LICENSE("GPL");

static int major;
static char* buffer;

static int mmap_fault(struct vm_area_struct* vma, struct vm_fault* vmf)
{
    unsigned long offset = vmf->pgoff << PAGE_SHIFT;
    struct page* page = virt_to_page(buffer + offset);
    get_page(page);
    vmf->page = page;
    return 0;
}

static const struct vm_operations_struct mmap_vm_ops = {
    .fault = mmap_fault
};

static int mmap_mmap(struct file* filp, struct vm_area_struct* vma)
{
    unsigned long size = vma->vm_end - vma->vm_start;
    unsigned long pfn = virt_to_phys(buffer) >> PAGE_SHIFT;
    int ret = io_remap_pfn_range(vma, vma->vm_start, pfn, size, vma->vm_page_prot);
    if (ret) {
        printk(KERN_ERR "io_remap_pfn_range failed\n");
        return ret;
    }
    vma->vm_ops = &mmap_vm_ops;
    mmap_fault(vma, NULL);
    return 0;
}

static struct file_operations fops = {
    .owner = THIS_MODULE,
    .mmap = mmap_mmap
};

static int __init mmap_init(void)
{
    major = register_chrdev(0, DEVICE_NAME, &fops);
    if (major < 0) {
        printk(KERN_ERR "Failed to register_chrdev\n");
        return major;
    }
    buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
    if (!buffer) {
        printk(KERN_ERR "Failed to allocate buffer\n");
        unregister_chrdev(major, DEVICE_NAME);
        return -ENOMEM;
    }
    memset(buffer, 'A', PAGE_SIZE);
    return 0;
}

static void __exit mmap_exit(void)
{
    kfree(buffer);
    unregister_chrdev(major, DEVICE_NAME);
}

module_init(mmap_init);
module_exit(mmap_exit);

这份代码实现了一个简单的内核模块，它注册了一个名为 "my_mmap" 的字符设备，提供了一个 mmap 方法用于内存映射操作。mmap 方法的实现过程中，使用了 io_remap_pfn_range 函数将内核缓冲区的物理地址映射到用户进程的虚拟地址空间中。具体实现细节可以参考代码注释。

##### 用户程序部分

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>

#define DEVICE_NAME "/dev/my_mmap"

int main(int argc, char** argv)
{
    int fd;
    char* buffer;
    size_t offset, length;

    if (argc < 3) {
        printf("Usage: %s <offset> <length>\n", argv[0]);
        return EXIT_FAILURE;
    }

    offset = atol(argv[1]);
    length = atol(argv[2]);

    fd = open(DEVICE_NAME, O_RDONLY);
    if (fd == -1) {
        perror("open");
        return EXIT_FAILURE;
    }

    buffer = mmap(NULL, length, PROT_READ, MAP_PRIVATE, fd, offset);
    if (buffer == MAP_FAILED) {
        perror("mmap");
        close(fd);
        return EXIT_FAILURE;
    }

    for (size_t i = 0; i < length; ++i) {
        putchar(buffer[i]);
    }

    if (munmap(buffer, length) == -1) {
        perror("munmap");
        close(fd);
        return EXIT_FAILURE;
    }

    close(fd);
    return EXIT_SUCCESS;
}

这份代码实现了一个用户程序，它打开了内核模块注册的字符设备 "/dev/my_mmap"，使用 mmap 函数将设备文件的一部分映射到进程的虚拟地址空间中，并输出映射区域的内容。具体实现细节可以参考代码注释。

需要注意的是，用户程序和内核模块需要分别编译并加载到内核和用户空间中。可以使用 Makefile 管理编译过程。

完善例子中的字符设备程序，使之满足以下功能： i.安装设备后从设备中读出字符串为自己学号的后3位； ii. 设备支持每次写入字符不超过1024个，超过部分被丢弃，并且能够保存最近一次修改前的rwbuf里的内容。 iii. 设备支持系统调用ioctl(int d, int req,…),共支持设置三种模式：a. 清除设备中写入的字符串; b. 从设备中读时，读出的是最近一次修改前的内容。 c. 从设备中读时，读出的是最新内容 iv. 设备关闭前不能被多次打开； v. 自己编写测试程序，验证以上功能 vi. 在上述基础上增加mmap接口，使其能够通过mmap读写rwbuf中的内容

下面是一个实现了上述功能的字符设备程序代码（仅供参考）：

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/cdev.h>
#include <linux/semaphore.h>
#include <linux/ioctl.h>
#include <linux/mman.h>
#include <asm/page.h>

#define DEVICE_NAME "mydev"
#define MAJOR_NUM 200
#define MAX_WRITE_LEN 1024
#define RWBUF_SIZE 4096

static char *rwbuf;
static int rwbuf_len = 0;
static struct semaphore sem;
static int dev_open_count = 0;
static int mode = 2;   // 默认为最新内容模式

static int mydev_open(struct inode *inode, struct file *file)
{
    if (dev_open_count > 0) {
        return -EBUSY;
    }
    dev_open_count++;
    try_module_get(THIS_MODULE);
    return 0;
}

static int mydev_release(struct inode *inode, struct file *file)
{
    dev_open_count--;
    module_put(THIS_MODULE);
    return 0;
}

static ssize_t mydev_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
{
    if (down_interruptible(&sem)) {
        return -ERESTARTSYS;
    }

    if (count > rwbuf_len) {
        count = rwbuf_len;
    }

    if (copy_to_user(buf, rwbuf, count)) {
        up(&sem);
        return -EFAULT;
    }

    if (mode == 1) {
        // 读出最近一次修改前的内容
        rwbuf_len = *pos;
    }

    up(&sem);
    return count;
}

static ssize_t mydev_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
{
    if (down_interruptible(&sem)) {
        return -ERESTARTSYS;
    }

    if (count > MAX_WRITE_LEN) {
        count = MAX_WRITE_LEN;
    }

    if (copy_from_user(rwbuf, buf, count)) {
        up(&sem);
        return -EFAULT;
    }

    rwbuf_len = count;

    up(&sem);
    return count;
}

static long mydev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd) {
        case 0: // 清除设备中写入的字符串
            if (down_interruptible(&sem)) {
                return -ERESTARTSYS;
            }
            rwbuf_len = 0;
            up(&sem);
            break;
        case 1: // 读取最近一次修改前的内容
            mode = 1;
            break;
        case 2: // 读取最新内容
            mode = 2;
            break;
        default:
            return -EINVAL;
    }
    return 0;
}

static int mydev_mmap(struct file *file, struct vm_area_struct *vma)
{
    unsigned long pfn;
    if (remap_pfn_range(vma, vma->vm_start, virt_to_phys(rwbuf) >> PAGE_SHIFT, vma->vm_end - vma->vm_start, vma->vm_page_prot)) {
        return -EAGAIN;
    }
    return 0;
}

static const struct file_operations mydev_fops = {
    .owner = THIS_MODULE,
    .open = mydev_open,
    .release = mydev_release,
    .read = mydev_read,
    .write = mydev_write,
    .unlocked_ioctl = mydev_ioctl,
    .mmap = mydev_mmap,
};

static struct cdev mydev_cdev;

static int __init mydev_init(void)
{
    int ret = 0;
    dev_t dev = MKDEV(MAJOR_NUM, 0);

    ret = register_chrdev_region(dev, 1, DEVICE_NAME);
    if (ret < 0) {
        printk(KERN_ALERT "Failed to register device number\n");
        return ret;
    }

    cdev_init(&mydev_cdev, &mydev_fops);
    mydev_cdev.owner = THIS_MODULE;
    ret = cdev_add(&mydev_cdev, dev, 1);
    if (ret < 0) {
        unregister_chrdev_region(dev, 1);
        printk(KERN_ALERT "Failed to add device\n");
        return ret;
    }

    rwbuf = kmalloc(RWBUF_SIZE, GFP_KERNEL);
    if (!rwbuf) {
        cdev_del(&mydev_cdev);
        unregister_chrdev_region(dev, 1);
        printk(KERN_ALERT "Failed to allocate memory\n");
        return -ENOMEM;
    }

    sema_init(&sem, 1);

    printk(KERN_INFO "mydev installed\n");
    return 0;
}

static void __exit mydev_exit(void)
{
    dev_t dev = MKDEV(MAJOR_NUM, 0);
    kfree(rwbuf);
    cdev_del(&mydev_cdev);
    unregister_chrdev_region(dev, 1);
    printk(KERN_INFO "mydev uninstalled\n");
}

module_init(mydev_init);
module_exit(mydev_exit);
MODULE_LICENSE("GPL");

测试程序可以使用以下代码：

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/mman.h>

#define DEVICE_NAME "/dev/mydev"

void clear_device(int fd)
{
    int ret = ioctl(fd, 0);
    if (ret < 0) {
        perror("ioctl");
    } else {
        printf("Device cleared\n");
    }
}

void read_device(int fd)
{
    char buf[1024];
    int ret = read(fd, buf, sizeof(buf));
    if (ret < 0) {
        perror("read");
    } else {
        buf[ret] = '\0';
        printf("Read from device: %s\n", buf);
    }
}

void write_device(int fd, const char *str)
{
    int len = strlen(str);
    int ret = write(fd, str, len);
    if (ret < 0) {
        perror("write");
    } else {
        printf("Write to device: %s\n", str);
    }
}

void mmap_device(int fd)
{
    char *buf = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (buf == MAP_FAILED) {
        perror("mmap");
    } else {
        printf("mmap success\n");
        printf("Content of rwbuf: %s\n", buf);
        strcpy(buf, "Hello, mmap!");
        printf("Content of rwbuf after modification: %s\n", buf);
        munmap(buf, 4096);
    }
}

int main(int argc, char *argv[])
{
    int fd = open(DEVICE_NAME, O_RDWR);
    if (fd < 0) {
        perror("open");
        return -1;
    }

    clear_device(fd);
    write_device(fd, "064");

    printf("Read in default mode (latest content):\n");
    read_device(fd);

    printf("Switch to read mode (recent content):\n");