include/lafs/lafs.h

   1
   2 #include <stdint.h>
   3 #include <stdlib.h>
   4
   5 #define u8 uint8_t
   6 #define u16 uint16_t
   7 #define u32 uint32_t
   8 #define u64 uint64_t
   9 #include <lafs/layout.h>
  10 #include <lafs/struct.h>
  11 #include <lafs/endian.h>
  12
  13
  14 struct lafs *lafs_alloc(void);
  15 int lafs_new(struct lafs *, int block_bytes);
  16
  17 char *lafs_validate_geometry(long *block_bytes,
  18                              long *segment_bytes,
  19                              long *stride_bytes,
  20                              int *width,
  21                              long long device_bytes);
  22 struct lafs_device *lafs_add_device(struct lafs *, char *devname, int fd,
  23                                     loff_t segblocks, loff_t strideblock,
  24                                     int width, int usage_inum);
  25 struct lafs_device *lafs_load(int fd, long long device_bytes, char **err);
  26 int lafs_include_dev(struct lafs *fs, struct lafs_device *dev, char **err);
  27
  28 struct lafs_ino *lafs_get_itable(struct lafs *);
  29 struct lafs_ino *lafs_add_inode(struct lafs_ino*, int inum, int type);
  30 struct lafs_ino *lafs_get_inode(struct lafs_ino *fsys, int inum);
  31 int lafs_imap_set(struct lafs_ino *, int inum);
  32
  33 int lafs_add_free_seg(struct lafs*, int dev, loff_t seg);
  34
  35 void lafs_inode_init(struct lafs *, char *, int type);
  36 struct lafs_ino *lafs_import_inode_buf(struct lafs *fs,
  37                                        char *buf, int inum,
  38                                        struct lafs_ino *parent);
  39 void lafs_dirty_inode(struct lafs_ino *);
  40 void lafs_inode_fillblock(struct lafs_ino *ino, char *buf);
  41 void lafs_make_iblock(struct lafs_ino *ino);
  42
  43 struct lafs_dblk *lafs_dblk(struct lafs_ino *ino,
  44                            loff_t bnum);
  45 int lafs_load_dblk(struct lafs_dblk *);
  46 int lafs_find_dblk(struct lafs_dblk *);
  47 struct lafs_ino *lafs_import_inode(struct lafs_dblk *db);
  48
  49 int lafs_read_virtual(struct lafs *, char *, loff_t);
  50 int lafs_sched_blk(struct lafs_blk *);
  51
  52 int lafs_write_dev(struct lafs_device *dev);
  53 int lafs_write_state(struct lafs *fs);
  54 int lafs_checkpoint(struct lafs *fs);
  55 void lafs_incorporate(struct lafs_iblk *ib);
  56 void lafs_cluster_allocate(struct lafs_blk *b, int cnum);
  57 void lafs_cluster_flush(struct lafs *fs, int cnum);
  58 int lafs_new_segment(struct lafs *, int cnum);
  59 struct lafs_device *lafs_dev_find(struct lafs *fs, loff_t virt);
  60 void lafs_allocated_block(struct lafs_blk *b, loff_t addr);
  61 void lafs_cluster_init(struct lafs *fs, int cnum,
  62                        loff_t addr, loff_t prev, loff_t seq);
  63 void lafs_summary_update(struct lafs_ino *ino,
  64                          loff_t oldaddr, loff_t newaddr,
  65                          int is_index);
  66 void lafs_segment_count(struct lafs *fs, loff_t addr, int diff);
  67
  68 void lafs_print_device(struct lafs_device *dev);
  69 void lafs_print_devblock(struct lafs_dev *dev);
  70 char *lafs_mount(struct lafs *fs, int force);
  71
  72 static inline struct lafs_dblk *dblk(struct lafs_blk *b)
  73 {
  74         return container_of(b, struct lafs_dblk, b);
  75 }
  76
  77 static inline struct lafs_iblk *iblk(struct lafs_blk *b)
  78 {
  79         return container_of(b, struct lafs_iblk, b);
  80 }
  81
  82 static inline int lafs_dirty_blk(struct lafs_blk *blk)
  83 {
  84         blk->flags |= B_Dirty;
  85         return lafs_sched_blk(blk);
  86 }
  87
  88 static inline uint64_t lafs_encode_timeval(struct timeval *tm)
  89 {
  90         uint64_t nano = tm->tv_usec * 1000;
  91         uint64_t sec = tm->tv_sec & (0x7FFFFFFFFULL);
  92         nano &= ~1ULL;
  93         return sec | (nano << 34);
  94 }
  95 static inline void lafs_decode_timeval(struct timeval *tm, uint64_t te)
  96 {
  97         /* low 35 bits are seconds (800 years)
  98          * high 29 bits are 2nanoseconds
  99          */
 100         long nano;
 101         tm->tv_sec = (te & 0X7FFFFFFFFULL);
 102         nano = (te >> 34) & ~(long)1;
 103         tm->tv_usec = nano / 1000;
 104 }
 105
 106 static inline struct lafs_device *dev_by_num(struct lafs *fs, int num)
 107 {
 108         struct lafs_device *dv;
 109         for (dv = fs->devs ; dv ; dv = dv->next)
 110                 if (dv->devnum == num)
 111                         return dv;
 112         return NULL;
 113 }
 114
 115
 116 static inline void
 117 virttoseg(struct lafs *fs, loff_t virt, int *devp, loff_t *segp, loff_t *offsetp)
 118 {
 119         struct lafs_device *dv = lafs_dev_find(fs, virt);
 120
 121         virt -= dv->start;
 122         if (dv->segment_size >= dv->width * dv->stride) {
 123                 *offsetp = virt % dv->segment_size;
 124                 *segp = virt / dv->segment_size;
 125         } else {
 126                 int of = virt % dv->stride;
 127                 int strp =virt / (dv->width * dv->stride);
 128
 129                 *segp = (strp * dv->stride + of) /
 130                         (dv->segment_size / dv->width);
 131                 *offsetp = virt - dv->segment_stride * *segp;
 132         }
 133         *devp = dv->devnum;
 134 }
 135
 136 static inline void
 137 virttophys(struct lafs *fs, loff_t virt, int *devp, loff_t *sectp)
 138 {
 139         struct lafs_device *dv = lafs_dev_find(fs, virt);
 140
 141         if (dv == NULL)
 142                 return;
 143         *devp = dv->devnum;
 144
 145         virt -= dv->start;
 146         virt *= fs->blocksize;
 147         virt += dv->segment_offset;
 148         *sectp = virt;
 149 }