Linux 查询哪个文件夹有文件占用内存

您可以使用 `du` 命令来查询哪个文件夹有文件占用内存。具体命令如下：

du -sh /*

这个命令会列出根目录下所有直接子目录的大小。您可以根据需要自己调整参数和路径。其中：

- `du`：表示查看磁盘使用情况。
- `-s`：表示显示每个指定文件或目录的总大小。
- `-h`：表示以易于人类理解的格式显示大小。
- `/*`：表示查看根目录下的所有直接子目录。

执行上述命令后，系统会输出每个子目录的大小，您可以查看其中哪个目录占用了较大的空间，然后进入该目录进行进一步的查找和处理。

相关问题

linux系统proc文件夹作用

在 Linux 系统中，/proc 文件夹是一个特殊的文件系统，它是一个虚拟文件系统，不占用磁盘空间，而是在内存中。/proc 文件夹主要用于向用户和内核进程提供一些系统信息，包括：

1. 进程信息：/proc 中有一个以数字命名的子目录，每个子目录代表一个正在运行的进程，其中包含了该进程的详细信息，如进程 ID、进程状态、进程命令行参数、进程环境变量等。

2. 系统信息：/proc 中包含了一些系统信息，如内核版本、CPU 信息、内存使用情况、进程间通信（IPC）信息等。

3. 硬件信息：/proc 中还包含了一些硬件信息，如硬盘、网卡、串口等设备的信息。

4. 其他信息：/proc 中还包含了一些其他的信息，如文件系统信息、网络协议信息、系统调用信息等。

总的来说，/proc 文件夹是一个非常重要的文件系统，它提供了非常多的系统信息和调试工具，方便用户和开发人员对系统进行调试和优化。

写一个在 Linux 下的内存文件系统代码，要求至少实现以下功能： 使用文件系统注册/注销函数，注册一个文件系统类型，名称为"mrfs"或其他自定义名称； ls:查看当前目录下的文件和文件夹信息命令。 cd:进入下级目录命令。 mv:移动文件命令 touch：新建文件命令 mkdir：新建文件夹命令 rm:删除文件命令 rmdir:删除文件夹命令 read：从某文件内读取信息命令 write：向某文件内写入信息命令 exit：退出文件系统命令

很抱歉，作为一个语言模型，我无法提供完整的代码实现。但我可以给你一些代码框架和伪代码来帮助你开始实现一个基本的内存文件系统。

首先，你需要定义一个内存结构体来存储文件系统的超级块、inode 表和数据块。以下是一个可能的结构体定义：

struct mrfs_sb_info {
    unsigned long s_blocksize;  /* 块大小 */
    unsigned long s_blocksize_bits;  /* 块大小的位数 */
    unsigned long s_inodes_count;  /* inode 数量 */
    unsigned long s_blocks_count;  /* 块数量 */
    unsigned long s_free_blocks_count;  /* 空闲块数量 */
    unsigned long s_free_inodes_count;  /* 空闲 inode 数量 */
};

struct mrfs_inode {
    unsigned short i_mode;  /* 文件类型和权限 */
    unsigned short i_uid;  /* 用户 ID */
    unsigned short i_gid;  /* 组 ID */
    unsigned short i_links_count;  /* 文件链接数量 */
    unsigned long i_size;  /* 文件大小 */
    unsigned long i_blocks;  /* 文件占用的块数量 */
    unsigned long i_data[15];  /* 文件数据块地址 */
};

struct mrfs_dir_entry {
    unsigned long inode;  /* inode 号 */
    char name[NAME_MAX];  /* 文件名 */
};

接下来，你需要实现文件系统注册/注销函数，用于在系统中注册或注销文件系统类型。以下是一个可能的实现：

static struct file_system_type mrfs_fs_type = {
    .name = "mrfs",
    .fs_flags = 0,
    .mount = mrfs_mount,
    .kill_sb = mrfs_kill_sb,
};

int mrfs_init(void)
{
    int ret;

    ret = register_filesystem(&mrfs_fs_type);
    if (ret != 0) {
        printk(KERN_ERR "failed to register mrfs: %d\n", ret);
        return ret;
    }

    return 0;
}

void mrfs_exit(void)
{
    unregister_filesystem(&mrfs_fs_type);
}

然后，你需要实现 ls、cd、mv、touch、mkdir、rm、rmdir、read、write 和 exit 等命令的函数。以下是一些可能的伪代码：

int mrfs_ls(struct file *file, void *dirent, filldir_t filldir)
{
    struct mrfs_inode *inode = file->f_path.dentry->d_inode;
    struct mrfs_dir_entry *de;
    int i;

    if (!S_ISDIR(inode->i_mode)) {
        return -ENOTDIR;
    }

    for (i = 0; i < inode->i_blocks; i++) {
        de = (struct mrfs_dir_entry *) mrfs_get_block(inode->i_data[i]);
        while (de->inode != 0) {
            filldir(dirent, de->name, strlen(de->name), 0, de->inode, DT_UNKNOWN);
            de++;
        }
    }

    return 0;
}

int mrfs_cd(struct file *file, const char __user *buf, size_t len)
{
    struct inode *old_inode = file->f_path.dentry->d_inode;
    struct inode *new_inode;
    char *path;
    int err;

    path = memdup_user(buf, len);
    if (IS_ERR(path)) {
        return PTR_ERR(path);
    }

    new_inode = mrfs_find_inode(old_inode, path);
    if (new_inode == NULL) {
        err = -ENOENT;
        goto out;
    }

    if (!S_ISDIR(new_inode->i_mode)) {
        err = -ENOTDIR;
        goto out_iput;
    }

    file->f_path.dentry = d_obtain_alias(d_find_any_alias(new_inode));
    err = 0;

out_iput:
    iput(new_inode);
out:
    kfree(path);
    return err;
}

int mrfs_mv(struct file *file, const char __user *old, size_t old_len,
            const char __user *new, size_t new_len)
{
    struct inode *old_inode = file->f_path.dentry->d_inode;
    struct inode *new_inode;
    char *old_path, *new_path;
    int err;

    old_path = memdup_user(old, old_len);
    if (IS_ERR(old_path)) {
        return PTR_ERR(old_path);
    }

    new_path = memdup_user(new, new_len);
    if (IS_ERR(new_path)) {
        err = PTR_ERR(new_path);
        goto out_old_path;
    }

    new_inode = mrfs_find_inode(old_inode, new_path);
    if (new_inode != NULL) {
        err = -EEXIST;
        goto out_new_path;
    }

    new_inode = mrfs_find_inode(old_inode, old_path);
    if (new_inode == NULL) {
        err = -ENOENT;
        goto out_new_path;
    }

    if (S_ISDIR(new_inode->i_mode)) {
        err = -EISDIR;
        goto out_iput;
    }

    err = mrfs_rename(old_inode, old_path, new_inode, new_path);

out_iput:
    iput(new_inode);
out_new_path:
    kfree(new_path);
out_old_path:
    kfree(old_path);
    return err;
}

int mrfs_touch(struct file *file, const char __user *name, size_t len)
{
    struct inode *inode = file->f_path.dentry->d_inode;
    char *path;
    int err;

    path = memdup_user(name, len);
    if (IS_ERR(path)) {
        return PTR_ERR(path);
    }

    err = mrfs_create(inode, path, S_IFREG | S_IRUSR | S_IWUSR);
    if (err < 0) {
        goto out;
    }

    err = mrfs_open(file, path, len, O_WRONLY | O_TRUNC);
    if (err < 0) {
        goto out_unlink;
    }

    return 0;

out_unlink:
    mrfs_unlink(inode, path);
out:
    kfree(path);
    return err;
}

int mrfs_mkdir(struct file *file, const char __user *name, size_t len)
{
    struct inode *inode = file->f_path.dentry->d_inode;
    char *path;
    int err;

    path = memdup_user(name, len);
    if (IS_ERR(path)) {
        return PTR_ERR(path);
    }

    err = mrfs_create(inode, path, S_IFDIR | S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
    if (err < 0) {
        goto out;
    }

    return 0;

out:
    kfree(path);
    return err;
}

int mrfs_rm(struct file *file, const char __user *name, size_t len)
{
    struct inode *inode = file->f_path.dentry->d_inode;
    char *path;
    int err;

    path = memdup_user(name, len);
    if (IS_ERR(path)) {
        return PTR_ERR(path);
    }

    err = mrfs_unlink(inode, path);
    if (err < 0) {
        goto out;
    }

    return 0;

out:
    kfree(path);
    return err;
}

int mrfs_rmdir(struct file *file, const char __user *name, size_t len)
{
    struct inode *inode = file->f_path.dentry->d_inode;
    char *path;
    int err;

    path = memdup_user(name, len);
    if (IS_ERR(path)) {
        return PTR_ERR(path);
    }

    err = mrfs_rmdir(inode, path);
    if (err < 0) {
        goto out;
    }

    return 0;

out:
    kfree(path);
    return err;
}

ssize_t mrfs_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
    struct inode *inode = file->f_path.dentry->d_inode;
    char *data;
    ssize_t err;

    if (!S_ISREG(inode->i_mode)) {
        return -EINVAL;
    }

    data = mrfs_get_data(inode, *ppos, count);
    if (IS_ERR(data)) {
        return PTR_ERR(data);
    }

    err = simple_read_from_buffer(buf, count, ppos, data, inode->i_size);

    kfree(data);
    return err;
}

ssize_t mrfs_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
    struct inode *inode = file->f_path.dentry->d_inode;
    char *data;
    ssize_t err;

    if (!S_ISREG(inode->i_mode)) {
        return -EINVAL;
    }

    data = mrfs_get_data(inode, *ppos, count);
    if (IS_ERR(data)) {
        return PTR_ERR(data);
    }

    err = simple_write_to_buffer(data, count, ppos, buf, count);

    mrfs_update_inode(inode);
    kfree(data);
    return err;
}

int mrfs_exit(struct super_block *sb)
{
    struct mrfs_sb_info *sbi = MRFS_SB(sb);
    struct mrfs_inode *inode;
    int i;

    /* 释放 inode 表和数据块 */
    for (i = 0; i < sbi->s_inodes_count; i++) {
        inode = mrfs_get_inode(sb, i);
        if (inode != NULL) {
            mrfs_free_inode(inode);
        }
    }
    for (i = 0; i < sbi->s_blocks_count; i++) {
        mrfs_free_block(sbi->s_blocks[i]);
    }

    kfree(sbi);
    return 0;
}

最后，你需要实现一个文件系统的驱动程序，用于将文件系统挂载到系统中。以下是一个可能的实现：

struct dentry *mrfs_mount(struct file_system_type *fs_type, int flags, const char *dev_name, void *data)
{
    struct dentry *root;
    struct super_block *sb;
    struct mrfs_sb_info *sbi;
    struct mrfs_inode *root_inode;
    int err;

    /* 创建超级块 */
    sb = sget(fs_type, NULL, mrfs_fill_super, NULL);
    if (IS_ERR(sb)) {
        return ERR_CAST(sb);
    }

    /* 创建根目录 */
    root_inode = mrfs_alloc_inode(sb);
    if (root_inode == NULL) {
        err = -ENOMEM;
        goto out;
    }
    root_inode->i_mode = S_IFDIR | S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
    root_inode->i_uid = current_fsuid();
    root_inode->i_gid = current_fsgid();
    err = mrfs_add_entry(root_inode, ".", root_inode);
    if (err < 0) {
        goto out_free_inode;
    }
    err = mrfs_add_entry(root_inode, "..", root_inode);
    if (err < 0) {
        goto out_free_inode;
    }
    root = d_make_root(d_alloc_root(root_inode));
    if (root == NULL) {
        err = -ENOMEM;
        goto out_free_inode;
    }

    return root;

out_free_inode:
    mrfs_free_inode(root_inode);
out:
    deactivate_locked_super(sb);
    return ERR_PTR(err);
}

void mrfs_kill_sb(struct super_block *sb)
{
    kill_litter_super(sb);
}

以上是一个基本的实现框架，具体的实现方法需要根据你的具体情况进行调整和优化。希望这些信息可以对你有所帮助。