kernel打印ssize_t ret变量

你可以使用 printk 函数来打印 ssize_t 类型的变量 ret，例如：

printk("ret = %zd\n", ret);

其中，%zd 是格式控制符，对应 ssize_t 类型的变量。

相关问题

使用int kernel_read_file(struct file *file, void **buf, loff_t *size, loff_t max_size, enum kernel_read_file_id id)写一段kernel的代码读取/sys/block/mmcblk0/stat的内容

可以使用以下代码读取 `/sys/block/mmcblk0/stat` 文件的内容：

#include <linux/fs.h>
#include <linux/dcache.h>
#include <linux/namei.h>
#include <linux/uaccess.h>

#define BUF_SIZE 256

int read_mmcblk0_stat(void)
{
    struct file *file;
    struct path path;
    void *buf = NULL;
    loff_t pos = 0;
    loff_t size = 0;
    ssize_t ret;

    // 解析文件路径
    if (kern_path("/sys/block/mmcblk0/stat", 0, &path)) {
        printk(KERN_ERR "Failed to resolve path\n");
        return -ENOENT;
    }

    // 打开文件
    file = dentry_open(&path, O_RDONLY, current_cred());
    if (IS_ERR(file)) {
        printk(KERN_ERR "Failed to open file\n");
        return PTR_ERR(file);
    }

    // 读取文件内容
    ret = kernel_read_file(file, &buf, &size, BUF_SIZE - 1, KERNEL_READ_FILE_NONE);
    if (ret < 0) {
        printk(KERN_ERR "Failed to read file\n");
        goto out;
    }

    // 在字符串末尾添加结束符
    ((char *)buf)[size] = '\0';

    // 输出文件内容
    printk(KERN_INFO "%s", buf);

out:
    // 释放缓冲区
    kfree(buf);

    // 关闭文件
    filp_close(file, NULL);
    return ret;
}

上述代码中，我们使用 `kern_path` 函数将文件路径转换为 `struct path` 结构体，然后使用 `dentry_open` 函数打开文件。接下来，我们使用 `kernel_read_file` 函数读取文件内容，并将结果存储在 `buf` 指针中，同时将文件大小存储在 `size` 变量中。最后，我们在字符串末尾添加结束符，并使用 `printk` 函数输出文件内容。

需要注意的是，与前面的代码不同，我们使用了 `kernel_read_file` 函数来读取文件内容，而不是 `kernel_read` 函数。`kernel_read_file` 函数的第二个参数 `buf` 是一个指向指针的指针，它会分配一个缓冲区来存储文件内容，并将缓冲区的地址存储在 `buf` 指针中。因此，在使用完 `buf` 指针后，我们需要使用 `kfree` 函数释放缓冲区。

另外，`kernel_read_file` 函数的第四个参数 `max_size` 表示最大的读取字节数，如果文件的大小超过了 `max_size`，则 `kernel_read_file` 函数只会读取 `max_size` 个字节。在本例中，我们将 `max_size` 设为 `BUF_SIZE - 1`，以留出一个字节存储结束符。

BIN_ATTR_RW(name，2*PAGE_SIZE) ，name_read(struct file *, struct kobject *, struct bin_attribute *, char *, loff_t, size_t)参数size_t显示大小为PAGE_SIZE，是用户空间提供的buf大小，用户空间每次最多只copy PAGE_SIZE大小，重复调用name_read直到loff_t是2*PAGE_SIZE为止，那name_read函数怎么写才能保证大于PAGE_SIZE的数据都能cat出来，要求调用回调函数，只用vsnprintf不用copy_to_use？

如果要保证大于PAGE_SIZE的数据都能被cat出来，且需要支持多次调用name_read函数来读取全部数据，可以在函数中使用一个偏移量来记录已经读取的数据量，然后在每次调用name_read函数时，从设备中读取剩余的数据，并将其格式化到用户提供的缓冲区中。

以下是示例代码：

static ssize_t name_read(struct file *filp, struct kobject *kobj,
                          struct bin_attribute *attr, char *buf,
                          loff_t pos, size_t size)
{
    ssize_t ret = 0;
    char *tmp = NULL;
    size_t len = 0;
    static loff_t off = 0;

    /* allocate temporary buffer */
    tmp = kmalloc(size + 1, GFP_KERNEL);
    if (!tmp) {
        return -ENOMEM;
    }

    /* read data from device */
    ret = read_data_from_device(tmp, off, size);
    if (ret <= 0) {
        goto out;
    }

    /* null-terminate temporary buffer */
    tmp[ret] = '\0';

    /* format data to user space buffer */
    len = vsnprintf(buf, size, "%s", tmp);
    if (len >= size) {
        ret = -EINVAL;
        goto out;
    }

    ret = len;
    off += len;

    /* check if all data has been read */
    if (off >= 2 * PAGE_SIZE) {
        /* call callback function */
        if (attr->private && attr->private->read_completed) {
            attr->private->read_completed(attr);
        }
    }

out:
    kfree(tmp);
    return ret;
}

在该函数中，使用一个静态变量`off`来记录已经读取的数据量。在每次调用name_read函数时，从设备中读取剩余的数据，并将其格式化到用户提供的缓冲区中。然后，将已经读取的数据量加上这次读取的数据量，并检查是否已经读取了所有数据。如果已经读取了所有数据，则调用回调函数（如果定义了的话）来通知上层应用程序已经完成读取操作。

需要注意的是，在多次调用name_read函数时，每次调用的偏移量都应该从上一次读取结束的位置开始。否则，可能会出现重复读取或者漏读的情况。