file.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <malloc.h>
   4
   5 #include "tfs.h"
   6 #include "cache.h"
   7 #include "file.h"
   8
   9
  10 struct file *tfs_open(struct tfs_sb_info *sbi, const char *filename)
  11 {
  12         struct inode *inode;
  13         struct file *file;
  14
  15         inode = tfs_namei(sbi, filename, 0);
  16         if (!inode) {
  17                 printf("ERROR: open file: %s falied!\n", filename);
  18                 return NULL;
  19         }
  20
  21         file = malloc(sizeof(*file));
  22         if (!file) {
  23                 printf("malloc file structure error!\n");
  24                 free_inode(inode);
  25                 return NULL;
  26         }
  27
  28         file->sbi    = sbi;
  29         file->inode  = inode;
  30         file->offset = 0;
  31
  32         return file;
  33 }
  34
  35 uint32_t fstk_lseek(struct file *file, uint32_t off, int mode)
  36 {
  37         if (mode == SEEK_CUR)
  38                 file->offset += off;
  39         else if (mode == SEEK_END)
  40                 file->offset = file->inode->i_size + off;
  41         else if (mode == SEEK_SET)
  42                 file->offset = off;
  43         else
  44                 file->offset = -1;
  45         return file->offset;
  46 }
  47
  48 int tfs_read(struct file *file, void *buf, uint32_t count)
  49 {
  50         struct tfs_sb_info *sbi = file->sbi;
  51         int blocks = roundup(count, sbi->s_block_size);
  52         int index  = file->offset >> sbi->s_block_shift;
  53         int block  = file->inode->i_data[index++];
  54         int bufoff = file->offset & (sbi->s_block_size - 1);
  55         int bytes_read = 0;
  56
  57         if (!blocks)
  58                 return -1;
  59         if (!block)
  60                 return -1;
  61         if (file->offset >= file->inode->i_size)
  62                 return -1;
  63         tfs_bread(sbi, block, buf);
  64         bytes_read = sbi->s_block_size - bufoff;
  65         memcpy(buf, buf + bufoff, bytes_read);
  66         buf          += bytes_read;
  67         file->offset += bytes_read;
  68         blocks--;
  69
  70         while (blocks--) {
  71                 block = file->inode->i_data[index++];
  72                 if (!block)
  73                         break;
  74                 tfs_bread(sbi, block, buf);
  75                 bytes_read   += sbi->s_block_size;
  76                 file->offset += sbi->s_block_size;
  77                 buf          += sbi->s_block_size;
  78         }
  79
  80         return bytes_read;
  81 }
  82
  83 int tfs_write(struct file *file, void *buf, uint32_t count)
  84 {
  85         struct tfs_sb_info *sbi = file->sbi;
  86         struct cache_struct *cs;
  87         int blocks = roundup(count, sbi->s_block_size);
  88         int index  = file->offset >> sbi->s_block_shift;
  89         int block  = file->inode->i_data[index++];
  90         int bufoff = file->offset & (sbi->s_block_size - 1);
  91         int bytes_written = 0;
  92
  93         if (!blocks)
  94                 return -1;
  95         if (!block) {
  96                 block = tfs_alloc_block(sbi, sbi->s_data_area);
  97                 if (block == -1) {
  98                         printf("allocating block for new file faile! OUT OF SPACE!\n");
  99                         return -1;
 100                 }
 101                 file->inode->i_data[index - 1] = block;
 102         }
 103         cs = get_cache_block(sbi, block);
 104         bytes_written = sbi->s_block_size - bufoff;
 105         memcpy(cs->data + bufoff, buf, bytes_written);
 106         buf          += bytes_written;
 107         file->offset += bytes_written;
 108         /* write back to disk */
 109         if (tfs_bwrite(sbi, block, cs->data) == -1) {
 110                 printf("disk I/O error:failed to write file data back to disk!\n");
 111                 return -1;
 112         }
 113         blocks--;
 114
 115         while (blocks--) {
 116                 block = file->inode->i_data[index++];
 117                 if (!block) {
 118                         block = tfs_alloc_block(sbi, sbi->s_data_area);
 119                         if (block == -1) {
 120                                 printf("allocating block for new file faile: out of space!\n");
 121                                 return -1;
 122                         }
 123                         file->inode->i_data[index - 1] = block;
 124                 }
 125                 cs = get_cache_block(sbi, block);
 126                 memcpy(cs->data, buf, sbi->s_block_size);
 127                 bytes_written += sbi->s_block_size;
 128                 file->offset  += sbi->s_block_size;
 129                 buf           += sbi->s_block_size;
 130                 if (tfs_bwrite(sbi, block, cs->data) == -1) {
 131                         printf("disk I/O error:failed to write file data back to disk!\n");
 132                         return -1;
 133                 }
 134         }
 135
 136         return bytes_written;
 137 }
 138
 139 void tfs_close(struct file *file)
 140 {
 141         if (file) {
 142                 free_inode(file->inode);
 143                 free(file);
 144         }
 145 }
 146