How do you get the size of a file in the linux kernel?

Question

I found this link (http://www.spinics.net/lists/newbies/msg41016.html) and have been looking into doing just that. So I wrote code in a kernel module:

#include <linux/path.h>
#include <linux/namei.h>
#include <linux/fs.h>

struct path p;
struct kstat ks;
kern_path(filepath, 0, &p);
vfs_getattr(&p, &ks);
printk(KERN_INFO "size: %lld\n", ks.size);

Which will not compile because:

/root/kernelmodule/hello.c:15: warning: passing argument 1 of ‘vfs_getattr’ from incompatible pointer type
include/linux/fs.h:2563: note: expected ‘struct vfsmount *’ but argument is of type ‘struct path *’
/root/kernelmodule/hello.c:15: warning: passing argument 2 of ‘vfs_getattr’ from incompatible pointer type
include/linux/fs.h:2563: note: expected ‘struct dentry *’ but argument is of type ‘struct kstat *’
/root/kernelmodule/hello.c:15: error: too few arguments to function ‘vfs_getattr’

So I am really confused since I was looking at this documentation: http://lxr.free-electrons.com/source/fs/stat.c#L40

And now I see inside /linux/fs.h that the prototype for vfs_getattr is:

extern int vfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);

Can anyone help me with my implementation? I am reading into vfsmount and dentry but am still lost.

"in the linux kernel" - meaning that you are trying to write kernel-land code? If not, then just `stat()` or `ftell()`. — , Sep 23 '13 at 18:18

score 5 · Answer 1 · answered Sep 23 '13 at 20:10

The call to this function changes depending on which kernel version you are using. The two argument version was introduced somewhere between 3.8 and 3.9. So if you are using kernel 3.8 or before, you need the "three arguments", and 3.9 onwards, you need two arguments.

If you really want to do this in kernel mode, on an older kernel than 3.9, you may be better off using the vfs_fstat or vfs_stat

However, dealing with files inside the kernel is frowned upon, and you may want to consider if there isn't a BETTER alternative - for example, if you want to load some file-stuff into the memory of a board that is on your system, you could load the file in a user-mode process, and then pass the loaded parts into the kernel via some private IOCTL type function. This is much more "kernel friendly", and if you are planning on ever trying to get your driver/module included in the overall kernel source code, you probably NEED to do this.

Thank you for the response. Do you how I can obtain the file descriptor to pass to vfs_fstat? @MatsPetersson — whwright, Sep 23 '13 at 20:45
Perhaps open the file? That's traditionally the way it's done... ;) — Mats Petersson, Sep 23 '13 at 22:12

score 0 · Answer 2 · answered Jun 22 '20 at 07:19

vfs_stat is an option to do it.

Below is an example:

#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/stat.h>

static char *load_file(char* filename, int *input_size)
{
        struct kstat *stat;
        struct file *fp;
        mm_segment_t fs;
        loff_t pos = 0;
        char *buf;

        fp = filp_open(filename, O_RDWR, 0644);
                if (IS_ERR(fp)) {
                        printk("Open file error!\n");
                        return ERR_PTR(-ENOENT);
        }

        fs = get_fs();
        set_fs(KERNEL_DS);
        
        stat =(struct kstat *) kmalloc(sizeof(struct kstat), GFP_KERNEL);
        if (!stat)
                return ERR_PTR(-ENOMEM);

        vfs_stat(filename, stat);
        *input_size = stat->size;

        buf = kmalloc(*input_size, GFP_KERNEL);
                if (!buf) {
                        kfree(stat);
                        printk("malloc input buf error!\n");
                        return ERR_PTR(-ENOMEM);
                }
        kernel_read(fp, buf, *input_size, &pos);

        filp_close(fp, NULL);
        set_fs(fs);
        kfree(stat);
        return buf;
}

Since the size is not known, so we need to kmalloc inside the function, thus the buf need to kfree later when not use any longer.

score 0 · Answer 3 · answered Sep 24 '21 at 07:29

vfs_stat return me an odd ERROR: modpost: "vfs_fstatat" [/mydir/module.ko] undefined! so i prefer use vfs_getattr or vfs_llseek

static char *load_file(char* filename)
{
    struct kstat *stat;
    struct file *fp;
    mm_segment_t fs;
    loff_t pos = 0;
    char *buf;
    int input_size;
    int rc;
    //loff_t mPos;

    fp = filp_open(filename, O_RDONLY, 0644);// O_RDWR O_RDONLY O_WRONLY O_APPEND O_CREAT
            if (IS_ERR(fp)) {
                    printk("Open file error!\n");
                    return ERR_PTR(-ENOENT);
    }

    fs = get_fs();
    set_fs(KERNEL_DS);
    
    stat =(struct kstat *) kmalloc(sizeof(struct kstat), GFP_KERNEL);

    rc = vfs_getattr(&fp->f_path, stat, STATX_SIZE, AT_STATX_SYNC_AS_STAT);
    if(rc != 0){
        printk("vfs_getattr Error");
    }
    //OR symply
    //mPos = vfs_llseek(fp, 0, SEEK_END);
    
    input_size = stat->size;
    //input_size = (int)mPos;

    buf = kmalloc(input_size, GFP_KERNEL);
            if (!buf) {
                    kfree(stat);
                    printk("malloc input buf error!\n");
                    return ERR_PTR(-ENOMEM);
            }
    kernel_read(fp, buf, input_size, &pos);

    filp_close(fp, NULL);
    set_fs(fs);
    kfree(stat);
    return buf;
}

5andr0 · Answer 4 · 2021-11-29T14:09:46.960

0

If you already have an open file* filp from filp_open you can read the size like that:

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
    loff_t size = i_size_read(file_inode(filp));
#else   
    loff_t size = i_size_read(filp->f_path.dentry->d_inode);
#endif

edited Nov 29 '21 at 14:09

answered Nov 26 '21 at 13:23

5andr0

1,578
1
18
25

How do you get the size of a file in the linux kernel?

4 Answers4

Linked