fs_file.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 "fsc_device.h"
#include "rkfs.h"
#include "parser.h"


struct file_operations rkfs_fops = {
        open: rkfs_file_open,
        read: rkfs_file_read,
        readdir: rkfs_file_readdir,
        write: rkfs_file_write,
        release: rkfs_file_release,
        fsync: simple_sync_file,
        llseek: rkfs_file_llseek
};


ssize_t rkfs_file_read (struct file *filp, char __user *buf, size_t count, loff_t *ppos) {
        struct inode *file_inode = filp->f_dentry->d_inode;     
        char query_string[MAX_QUERY_LENGTH + 1];
        char *data_pos;
        int block_number, block_end, curr_read_end;

        FSPDEBUG("rkfs_file_read (*ppos = '%lu', count = '%lu')\n", (long)*ppos, (long)count);

        if (*ppos > file_inode->i_size) {
                FSPDEBUG("file pos (%lu) > file size (%lu)\n", (long)*ppos, (long)file_inode->i_size);
        return 0;
        }
        FSPDEBUG("ppos = '%lu'\n", (long) *ppos);
        
        /* blocks are always full except the last one*/
        block_number = ((long) *ppos) / RKFS_BLOCKSIZE;
        FSPDEBUG("block_number='%d'\n", block_number);
        
        block_end = (block_number + 1) * RKFS_BLOCKSIZE;
        
        FSPDEBUG("block_end='%d'\n", block_end);
        FSPDEBUG("filesize = '%lu'\n", (long)file_inode->i_size);
        
        curr_read_end = min((long)block_end, (long)(file_inode->i_size));
        FSPDEBUG("curr_read_end='%d'\n", curr_read_end);

        if (*ppos + count > curr_read_end) {
                count = curr_read_end - *ppos;
                FSPDEBUG("count bigger, count = '%lu'\n", (long)count);
        }

        if (count == 0) {
                return count;
        }
        
        FSPDEBUG("count = '%lu' OK\n", (long)count);

        snprintf(query_string, MAX_QUERY_LENGTH + 1, "MYSQL1.1 GB %lu %d", file_inode->i_ino, block_number);
        if (query(query_string, strlen(query_string)) != RKFS_DEF_QUERY_OK) {
                return 0;
        } 
        else {
                if (ret_command.command_nr == CMD_ER_NR) {
                        /* return empty dentry, cannot return ENOENT! try cd or md*/
                        return 0; 
                }
        }
        
        data_pos = ret_command.data;    
        
        if (copy_to_user(buf, data_pos + *ppos - block_number * RKFS_BLOCKSIZE, count)) {
                return -EFAULT;
        }
        
        *ppos += count;
        return count;
}


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


ssize_t rkfs_file_write (struct file *filp, const char __user *buf, size_t count, loff_t *ppos) {
        struct inode *file_inode = filp->f_dentry->d_inode;
        int block_number, block_end, curr_write_end, curr_block_length;
        char* data_pos;
        char* query_pos;
        int i;
        int append = 0;

        FSPDEBUG("rkfs_file_write (*ppos = '%lu', count = '%lu')\n", (long)*ppos, (long)count);

        FSPDEBUG("ppos = '%lu'\n", (long) *ppos);
        
        /* blocks are always full except the last one*/
        block_number = ((long) *ppos) / RKFS_BLOCKSIZE;
        
        FSPDEBUG("block_number='%d'\n", block_number);
        
        block_end = (block_number + 1) * RKFS_BLOCKSIZE;
        
        FSPDEBUG("block_end='%d'\n", block_end);
        FSPDEBUG("filesize = '%lu'\n", (long)file_inode->i_size);
        
    curr_block_length = min((long)((long)file_inode->i_size - block_number * RKFS_BLOCKSIZE), 
        (long)RKFS_BLOCKSIZE);
    
        FSPDEBUG("curr_block_length='%d'\n", curr_block_length);
        
        curr_write_end = min((long)block_end, (long)(count + *ppos));
        
        FSPDEBUG("curr_write_end='%d'\n", curr_write_end);
        
        count = curr_write_end - *ppos;
        
        FSPDEBUG("count bigger, count = '%lu'\n", (long)count);

        if (*ppos > file_inode->i_size) {
        FSPDEBUG("*ppos > file_inode->i_size = '%lu'\n", (long)file_inode->i_size);
                file_inode->i_size = *ppos;
                rkfs_inode_truncate(file_inode);        
                curr_block_length = min((long)((long)file_inode->i_size - block_number * RKFS_BLOCKSIZE), 
                        (long)RKFS_BLOCKSIZE);
                append = 1;     
        }

        if (*ppos == file_inode->i_size) {
                append = 1;
        }

        if (count == 0) {
                FSPDEBUG("count == 0, return count\n");
                return count;
        }

        if (copy_from_user(write_buffer.data_buf, buf, count)) {
                return -EFAULT;
        }

        FSPDEBUG("reading block from database\n");
        snprintf(write_buffer.query_buf, MAX_QUERY_LENGTH + 1, "MYSQL1.1 GB %lu %d", 
                (long)file_inode->i_ino, block_number);
        if (query(write_buffer.query_buf, strlen(write_buffer.query_buf)) != RKFS_DEF_QUERY_OK) {
                FSPDEBUG("return from database - error\n");
                return 0;
        } 
        else {
                if (ret_command.command_nr == CMD_ER_NR) {
                        if ((strcmp(ret_command.param, "BLOCK_NOT_EXISTS") == 0)) {
                                snprintf(write_buffer.query_buf, MAX_QUERY_LENGTH + 1, "MYSQL1.1 AB %lu ", 
                                        (long)file_inode->i_ino);
                                write_buffer.query_len = strlen(write_buffer.query_buf);
                                query_pos = write_buffer.query_buf + strlen(write_buffer.query_buf);
                                memcpy(query_pos, write_buffer.data_buf, count);
                                write_buffer.query_len += count;
                                                                        
                                if (query(write_buffer.query_buf, write_buffer.query_len) != RKFS_DEF_QUERY_OK) {
                                        FSPDEBUG("return from database - error\n");
                                        return 0;
                                } 
                                else {
                                        if (ret_command.command_nr == CMD_ER_NR) {
                                                FSPDEBUG("return from database - command ret error\n");
                                                /* return empty dentry, cannot return ENOENT! try cd or md*/
                                                return 0; 
                                        }
                                }
                                
                                *ppos += count;
                                file_inode->i_size = max ((long)curr_write_end, (long)file_inode->i_size);
                                FSPDEBUG("returning count = '%lu', filesize='%lu',\n", (long unsigned int) count, 
                                        (long unsigned int)file_inode->i_size);
                                
                                return count;
                                } 
                                else {
                                        FSPDEBUG("return from database - command ret error\n");
                                        /* return empty dentry, cannot return ENOENT! try cd or md*/
                                        return 0; 
                        }
                        
                }
                
        }

        data_pos = ret_command.data + *ppos - block_number * RKFS_BLOCKSIZE;
        for (i=0; i<count; i++) {
                *(data_pos) = write_buffer.data_buf[i];
                data_pos++;
        }
        

        FSPDEBUG("block_number='%d'\n", block_number);
        snprintf(write_buffer.query_buf, MAX_QUERY_LENGTH + 1, "MYSQL1.1 RB %lu %d ", 
                (long)file_inode->i_ino, block_number);
        
        query_pos = write_buffer.query_buf + strlen(write_buffer.query_buf);
        write_buffer.query_len = strlen(write_buffer.query_buf);

        if (append) {
                FSPDEBUG("curr_block_len='%d'\n", curr_block_length);
                FSPDEBUG("count = '%lu'\n", (long)count);
                
                memcpy(query_pos, ret_command.data, curr_block_length + count); 
                write_buffer.query_len += curr_block_length + count;    
        } else {
                memcpy(query_pos, ret_command.data, curr_block_length); 
                write_buffer.query_len += curr_block_length;    
        }
        
        if (query(write_buffer.query_buf, write_buffer.query_len) != RKFS_DEF_QUERY_OK) {
                FSPDEBUG("return from database - error\n");
                return 0;
        } 
        else {
                if (ret_command.command_nr == CMD_ER_NR) {
                        FSPDEBUG("return from database - command ret error\n");
                        /* return empty dentry, cannot return ENOENT! try cd or md*/
                        return 0; 
                }
                
        }
  
        *ppos += count;

        file_inode->i_size = max ((long)curr_write_end, (long)file_inode->i_size);
        
        FSPDEBUG("returning count = '%lu', filesize='%lu',\n", (long unsigned int) count, 
                (long unsigned int)file_inode->i_size);
        
        return count; //generic_file_write(filp, buf, count, ppos);
}


int rkfs_file_open(struct inode *inode, struct file *file) {
        
        FSPDEBUG("rkfs_file_open (%lu)\n", file->f_dentry->d_inode->i_ino);
        /* No read-ahead */
        file->f_ra.ra_pages = 0; 
        
        return generic_file_open(inode, file);
}


int rkfs_file_release (struct inode *ino, struct file *file) {
        /* nothing else to do */
        FSPDEBUG("rkfs_file_release\n"); 
        return 0;
}


int rkfs_file_readdir(struct file *file, void *dirent, filldir_t filldir) {
        struct dentry *de = file->f_dentry;

        int i;
        int filename_len;
        char filename[MAX_NAME_LENGTH + 1]="";
        char file_id[MAX_ID_LENGTH + 1]="";
        char *com_data_pos = NULL;
        char query_string[MAX_QUERY_LENGTH + 1];
        struct inode *dir = file->f_dentry->d_inode; 

        FSPDEBUG("rkfs_file_readdir\n");
        /* inode->size is number of files and directories in the dir */
        if (file->f_pos > (dir->i_size - 1 + 2)) 
                return 1;
                
        if (filldir(dirent, ".", 1 /* len */, file->f_pos++, de->d_inode->i_ino, DT_DIR))
                return 0;
                
        if (filldir(dirent, "..", 2 /* len */, file->f_pos++, de->d_parent->d_inode->i_ino, DT_DIR))
                return 0;
                
        snprintf(query_string, MAX_QUERY_LENGTH + 1, "MYSQL1.1 RE %lu", dir->i_ino);
        query(query_string, strlen(query_string));

        if (ret_command.command_nr != CMD_OK_NR) {
                FSPDEBUG("rkfs_file_readdir error='%s'\n", ret_command.param);
                return 1;
        } 
        else {
                com_data_pos = ret_command.data;
                for(i = 1; i <= rkfs_atoi(ret_command.param); i++) {
                        
                        filename_len = rkfs_next_data_item(&com_data_pos, filename);
                        rkfs_next_data_item(&com_data_pos, file_id);
                        
                        if (*com_data_pos == 'f') {
                                if (filldir(dirent, filename, filename_len, file->f_pos++, rkfs_atoi(file_id), DT_REG)) {
                                        return 0;
                                }
                                
                        }
                        /* com_data_pos == 'd' */ 
                        else {
                                if (filldir(dirent, filename, filename_len, file->f_pos++, rkfs_atoi(file_id), DT_DIR))
                                        return 0;
                        }
                        /* eat f or d and slash */
                        com_data_pos += 2;
                }
                
                return 1;
        }
        
}


loff_t rkfs_file_llseek (struct file * file , loff_t offset, int origin) {
        FSPDEBUG("rkfs_file_llseek (offset='%lu', origin='%lu')\n", (long)offset, (long)origin);
        return generic_file_llseek(file, offset, origin);
}

---