fs_inode.c

Go to the documentation of this file.

#ifndef __KERNEL__
#       define __KERNEL__
#endif


#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/version.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/statfs.h>
#include <linux/mm.h>
#include <asm/uaccess.h>
#include <asm/errno.h>
#include <linux/buffer_head.h>
#include <linux/pagemap.h> /* unlock_page */
#include <linux/proc_fs.h>
#include <asm/atomic.h>
#include <linux/string.h>
#include <linux/smp_lock.h>


#include "fsc_device.h"
#include "rkfs.h"
#include "parser.h"


static struct inode *rkfs_root_inode;


struct super_operations rkfs_sops = {
        read_inode: rkfs_super_read_inode,
        statfs: simple_statfs, /* handler from libfs */
        write_inode: rkfs_super_write_inode,
        delete_inode: rkfs_super_delete_inode
};


struct inode_operations rkfs_iops = {
        lookup: rkfs_inode_lookup,
        mkdir: rkfs_mkdir,
        rmdir: rkfs_rmdir,
        create : rkfs_inode_create,
        unlink: rkfs_inode_unlink,
        truncate: rkfs_inode_truncate,
        rename: rkfs_inode_rename
};


static int rkfs_fill_super(struct super_block *sb, void *data, int silent) {
        char query_string[MAX_QUERY_LENGTH + 1];
        char file_dircount[MAX_SIZE_LENGTH + 1];
        char file_filecount[MAX_SIZE_LENGTH + 1];
        char *data_pos;
        
        FSPDEBUG("rkfs_fill_super\n");
        // rkfs_deamon_test();
        
        /* test deamon connection */
        if (query("MYSQL1.1 TS", strlen("MYSQL1.1 TS")) != RKFS_DEF_QUERY_OK) {         
                return -EFAULT;
        } 
        else {
                if (ret_command.command_nr == CMD_ER_NR) {
                        FSPDEBUG("filesystem mount error, db connection failed\n");
                        return -EFAULT;
                }
                
        }

        sb->s_blocksize = RKFS_BLOCKSIZE;
        sb->s_blocksize_bits = RKFS_BLOCKSIZE_BITS;
        sb->s_magic = RKFS_MAGIC;
        
        /* super block operations */
        sb->s_op = &rkfs_sops;
        
        /* file_system_type */ 
        sb->s_type = &rkfs; 
        
        /* allocate an inode */
        rkfs_root_inode = iget(sb, RKFS_ROOT_INODE);
         
        /* set the inode ops */
        rkfs_root_inode->i_op = &rkfs_iops;
         
        rkfs_root_inode->i_mode = S_IFDIR|S_IRWXU;
        rkfs_root_inode->i_fop = &rkfs_dops;

        /* count of dirs in the root directory */
        snprintf(query_string, MAX_QUERY_LENGTH + 1, "MYSQL1.1 RI %d", RKFS_ROOT_INODE);
        if (query(query_string, strlen(query_string)) != RKFS_DEF_QUERY_OK) {
                return -EFAULT;
        } 
        else {
                if (ret_command.command_nr == CMD_ER_NR) {
                        return -EFAULT;
                }
        }
                
        data_pos = ret_command.data;
        /* get number of dirs inside this dir */
        rkfs_next_data_item(&data_pos, file_dircount);
         
        /* get number of files inside this dir */
        rkfs_next_data_item(&data_pos, file_filecount);
        
        FSPDEBUG("dircount = '%s', filecount = '%s'\n", file_dircount, file_filecount);
        rkfs_root_inode->i_size = rkfs_atoi(file_dircount) + rkfs_atoi(file_filecount);
         
        /* we declare directorysize as sum of files and dirs inside */
        rkfs_root_inode->i_nlink = rkfs_atoi(file_dircount) + 2; 

        if (!(sb->s_root = d_alloc_root(rkfs_root_inode))) {
                iput(rkfs_root_inode);
                FSPDEBUG("filesystem mount error, not enough memory\n");
                return -ENOMEM;
        }
        
        return 0;
}


int rkfs_get_sb (struct file_system_type *fs_type, int flags, const char *devname, void *data, 
                                 struct vfsmount *mnt) {
        int result;
        FSPDEBUG("rkfs_get_sb\n");
        /* rkfs_fill_super this will be called to fill the superblock */
        result = get_sb_single(
                                         fs_type,
                                         flags,
                                         data,
                                         &rkfs_fill_super, mnt);
        if (result == 0) {
                FSPDEBUG("rkfs_get_sb succesfull\n");
        } 
        else {
                FSPDEBUG("rkfs_get_sb: get_sb_single failed, return=%d\n", result);
        }
        
        return result;
}


void rkfs_kill_sb(struct super_block *super) {
        FSPDEBUG("rkfs_kill_sb\n\n\n\n");
        kill_anon_super(super);
}


void rkfs_super_read_inode(struct inode *inode) {
        char query_string[MAX_QUERY_LENGTH + 1];
        char file_size[MAX_SIZE_LENGTH + 1];
        char file_dircount[MAX_SIZE_LENGTH + 1];
        char file_filecount[MAX_SIZE_LENGTH + 1];
        char *data_pos = NULL;

        FSPDEBUG("rkfs_super_read_inode (%lu)\n", inode->i_ino);
        
        snprintf(query_string, MAX_QUERY_LENGTH + 1, "MYSQL1.1 RI %lu", inode->i_ino);
        if (query(query_string, strlen(query_string)) != RKFS_DEF_QUERY_OK) {
                make_bad_inode(inode); 
                return;
        } 
        else {
                if (ret_command.command_nr == CMD_ER_NR) {
                        make_bad_inode(inode);
                        /* return empty dentry, cannot return ENOENT! try cd or md*/
                        return; 
                }
        }
        
        FSPRETCMD();
        data_pos = ret_command.data;
        
        /* we DON'T support file information like rights user etc. */
        if (strcmp(ret_command.param, "IS_FILE") == 0) { 
                rkfs_next_data_item(&data_pos, file_size);
                inode->i_size = rkfs_atoi(file_size);
                
                /* file */
                inode->i_mode = S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH; 
                inode->i_fop = &rkfs_fops;
                
                /* set the inode ops */
                inode->i_op = &rkfs_iops; 
                FSPDEBUG("end of rkfs_super_read_inode from file branch\n");
        } 
        else {
                
                /* get number of dirs inside this dir */
                rkfs_next_data_item(&data_pos, file_dircount);
                
                /* get number of files inside this dir */ 
                rkfs_next_data_item(&data_pos, file_filecount);
                FSPDEBUG("dircount = '%s', filecount = '%s'\n", file_dircount, file_filecount);
                inode->i_size = rkfs_atoi(file_dircount) + rkfs_atoi(file_filecount); 
                
                /* we declare directory size as sum of files and dirs inside */
                inode->i_nlink = rkfs_atoi(file_dircount) + 2;
                 
                /* +1 for .. an . directory inside */
                /* dir */
                inode->i_mode = S_IFDIR|S_IXUSR|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH; 
                inode->i_fop = &rkfs_dops;
                
                /* set the inode ops */
                inode->i_op = &rkfs_iops; 
                FSPDEBUG("end of rkfs_super_read_inode from dir branch\n");
        }
}


int rkfs_super_write_inode(struct inode *inode, int wait) {
        FSPDEBUG("rkfs_super_write_inode (i_ino = %d) = %d\n",
                (int)inode->i_ino,(int)i_size_read(inode));
        return 0;
}


int rkfs_inode_unlink (struct inode *dir, struct dentry *dentry) {
        struct inode * inode = dentry->d_inode;
        char query_string[MAX_QUERY_LENGTH + 1];
        FSPDEBUG("rkfs_unlink_inode (i_ino = %lu)\n", (unsigned long int)inode->i_ino);

        snprintf(query_string, MAX_QUERY_LENGTH + 1, "MYSQL1.1 RF %lu", (long unsigned int)inode->i_ino);
        
        /* test deamon connection */
        if (query(query_string, strlen(query_string)) != RKFS_DEF_QUERY_OK) {           
                return -EFAULT;
        } 
        else {
                if (ret_command.command_nr == CMD_ER_NR) {
                        return -EACCES; 
                }
        }

        inode->i_size = 0;
        /* we have to update the number of files and dirs in parent directory - this value is used by readdir */
        dir->i_size--;  
        
        return 0;
}


void rkfs_super_delete_inode(struct inode *inode) {
        FSPDEBUG("rkfs_delete_inode (i_ino = %lu)\n", (long unsigned int)inode->i_ino);
        return generic_delete_inode(inode);
}


struct dentry *rkfs_inode_lookup(struct inode *parent_inode, struct dentry *dentry,
                                                                 struct nameidata *nameidata) {
        struct inode *file_inode;
        char query_string[MAX_QUERY_LENGTH + 1];
        char file_id[MAX_ID_LENGTH + 1];
        char* data_pos;

        FSPDEBUG("rkfs_inode_lookup\n");
        snprintf(query_string, MAX_QUERY_LENGTH + 1, "MYSQL1.1 LU %lu %s", parent_inode->i_ino, dentry->d_name.name);
        
        /* test deamon connection */
        if (query(query_string, strlen(query_string)) != RKFS_DEF_QUERY_OK) {
                return NULL;
        } 
        else {
                if (ret_command.command_nr == CMD_ER_NR) {
                        /* return empty dentry, cannot return ENOENT! try cd or md*/
                        return NULL; 
                }
        }
        
        data_pos = ret_command.data;
        
        /* get file_id */       
        rkfs_next_data_item(&data_pos, file_id);
        
        file_inode = iget(parent_inode->i_sb, rkfs_atoi(file_id));
        
        if (!file_inode) {
                return ERR_PTR(-EACCES);
        }
        
        d_add(dentry, file_inode);
        return NULL;
}



int rkfs_inode_create(struct inode *dir, struct dentry *dirdentry, int mode, 
                                          struct nameidata *nd) {
        struct inode * inode;
        struct super_block *sb = dir->i_sb;
        char query_string[MAX_QUERY_LENGTH + 1];
        struct qstr qname;
        struct dentry *dentry;

        FSPDEBUG("rkfs_inode_create\n");
        
        /* allocate an inode */
        inode = new_inode(sb); 
        if (IS_ERR(inode)) {
                return PTR_ERR(inode);
        }

        qname.name = dirdentry->d_name.name;
        qname.len = strlen (dirdentry->d_name.name);
        qname.hash = full_name_hash(qname.name, qname.len);
        
        /* Now we can create our dentry and the inode to go with it.*/
        dentry = d_alloc(dirdentry, &qname);
        if (! dentry) {
                return 0;
        }

        snprintf(query_string, MAX_QUERY_LENGTH + 1, "MYSQL1.1 CF %lu %s", dir->i_ino, dirdentry->d_name.name);
        
        /* test deamon connection */
        if (query(query_string, strlen(query_string)) != RKFS_DEF_QUERY_OK) {           
                dput(dentry);
                return 0;
        } 
        else {
                if (ret_command.command_nr == CMD_ER_NR) {
                        dput(dentry);
                        return 0;
                }
        }

        inode->i_ino = rkfs_atoi(ret_command.param);
        
        /* size of the new directory is 0 - no files inside */
        inode->i_size = 0; 
        
        /* create as dir, with wanted mode */
        inode->i_mode = S_IFREG | mode ;
        
        /* set the file ops */ 
        inode->i_fop = &rkfs_fops;
        
        /* set the inode ops */ 
        inode->i_op = &rkfs_iops; 
        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
        inode_inc_link_count(inode);

        d_add(dirdentry, inode);
        
        /* updating info of files present */
        dir->i_size++;
        
        /* ok */ 
        return 0; 
}


struct write_buffer {
        char data_buf[RKFS_BLOCKSIZE];
        char query_buf[RKFS_BLOCKSIZE + MAX_QUERY_LENGTH + 1];
        char query_len;
} truncate_buffer;


void rkfs_inode_truncate (struct inode * inode) {
        char query_string[MAX_QUERY_LENGTH + 1];
        long new_file_size = inode->i_size;

        FSPDEBUG("rkfs_inode_truncate\n");

        /* i_node->i_size contains the length after truncate */
        
        if (new_file_size == 0) {
                snprintf(query_string, MAX_QUERY_LENGTH + 1, "MYSQL1.1 CR %lu", inode->i_ino);
                if (query(query_string, strlen(query_string)) != RKFS_DEF_QUERY_OK) {
                        return;
                } 
                else {
                                if (ret_command.command_nr == CMD_ER_NR) {
                                
                                /* return empty dentry, cannot return ENOENT! try cd or md*/
                                return; 
                        }
                }
                return;
        }

        snprintf(query_string, MAX_QUERY_LENGTH + 1, "MYSQL1.1 TR %lu %lu", inode->i_ino, new_file_size);
        
        if (query(query_string, strlen(query_string)) != RKFS_DEF_QUERY_OK) {
                return;
        } 
        else {
                        if (ret_command.command_nr == CMD_ER_NR) {
                        
                        /* return empty dentry, cannot return ENOENT! try cd or md*/
                        return; 
                }
        }
                        
}


int rkfs_inode_rename(struct inode * old_dir, struct dentry *old_dentry, struct inode * new_dir, 
                                                                        struct dentry *new_dentry) {
        char query_string[MAX_QUERY_LENGTH + 1];
        char file_id[MAX_SIZE_LENGTH + 1];
        char* data_pos;
        long file_id_long;
        int is_file = 0;

        FSPDEBUG("rkfs_inode_rename\n");
        FSPDEBUG("rkfs_inode_rename (old_dir->i_ino='%lu', old_dentry->d_name='%s', new_dir->i_ino='%lu', new_dentry->d_name='%s')\n", (long)old_dir->i_ino, old_dentry->d_name.name, (long)new_dir->i_ino, new_dentry->d_name.name);
        
        snprintf(query_string, MAX_QUERY_LENGTH + 1, "MYSQL1.1 LU %lu %s", old_dir->i_ino, old_dentry->d_name.name);
        
        /* test deamon connection */
        if (query(query_string, strlen(query_string)) != RKFS_DEF_QUERY_OK) {           
                return -ENOENT;
        } 
        else {
                if (ret_command.command_nr == CMD_ER_NR) {
                        
                        /* return empty dentry, cannot return ENOENT! try cd or md*/
                        return -ENOENT; 
                }
                
        }
        
        data_pos = ret_command.data;
                
        /* get file_id */
        rkfs_next_data_item(&data_pos, file_id);
        file_id_long = rkfs_atoi(file_id);
        
        if (strcmp(ret_command.param, "IS_FILE") == 0) {
                is_file = 1;
        }

        if (old_dir->i_ino != new_dir->i_ino) {
                snprintf(query_string, MAX_QUERY_LENGTH + 1, "MYSQL1.1 MV %s %lu", file_id, new_dir->i_ino);
                if (query(query_string, strlen(query_string)) != RKFS_DEF_QUERY_OK) {
                        return -ENOENT;
                } 
                else {
                        if (ret_command.command_nr == CMD_ER_NR) {
                                
                                /* return empty dentry, cannot return ENOENT! try cd or md*/
                                return -ENOENT;
                        }
                }
                
                old_dir->i_size--;
                new_dir->i_size++;
        
                if (!is_file) {
                        old_dir->i_nlink--;
                        new_dir->i_nlink--;     
                }
                
        }
        
        if (strcmp(old_dentry->d_name.name, new_dentry->d_name.name) != 0) {
                if (is_file) {
                        snprintf(query_string, MAX_QUERY_LENGTH + 1, "MYSQL1.1 DN %s %s", file_id, new_dentry->d_name.name);
                        
                } else {        
                        snprintf(query_string, MAX_QUERY_LENGTH + 1, "MYSQL1.1 DD %s %s", file_id, new_dentry->d_name.name);
                }

                if (query(query_string, strlen(query_string)) != RKFS_DEF_QUERY_OK) {
                        return -ENOENT;
                } 
                else {
                        if (ret_command.command_nr == CMD_ER_NR) {
                                
                                /* return empty dentry, cannot return ENOENT! try cd or md*/
                                return -ENOENT; 
                        }
                        
                }
                
        }
        
        return 0;
}

---