lunaix-os/kernel/fs/ext2/group.c

   1 #include <lunaix/mm/valloc.h>
   2
   3 #include "ext2.h"
   4
   5 bcache_zone_t gdesc_bcache_zone;
   6
   7 static void
   8 __cached_gdesc_evict(struct bcache* bc, void* data)
   9 {
  10     struct ext2_gdesc* gd;
  11     gd = (struct ext2_gdesc*)data;
  12
  13     llist_delete(&gd->groups);
  14     llist_delete(&gd->free_grps_blk);
  15     llist_delete(&gd->free_grps_ino);
  16
  17     fsblock_put(gd->buf);
  18
  19     vfree(gd);
  20 }
  21
  22 static void
  23 __cached_gdesc_sync(struct bcache*, unsigned long tag, void* data)
  24 {
  25     // since all mods to gdesc goes directly into fs buffer,
  26     // we just need to invoke the sync on the underlying.
  27
  28     struct ext2_gdesc* gd;
  29     gd = (struct ext2_gdesc*)data;
  30
  31     fsblock_sync(gd->buf);
  32 }
  33
  34 static struct bcache_ops gdesc_bc_ops = {
  35     .release_on_evict = __cached_gdesc_evict,
  36     .sync_cached = __cached_gdesc_sync
  37 };
  38
  39 void
  40 ext2gd_prepare_gdt(struct v_superblock* vsb)
  41 {
  42     struct ext2b_super* sb;
  43     unsigned int nr_parts;
  44     unsigned int nr_gd_pb, nr_gd;
  45     struct ext2_sbinfo* ext2sb;
  46
  47     ext2sb = EXT2_SB(vsb);
  48     sb = ext2sb->raw;
  49
  50     nr_gd_pb = ext2sb->block_size / sizeof(struct ext2b_gdesc);
  51     nr_gd    = ICEIL(sb->s_blk_cnt, sb->s_blk_per_grp);
  52     nr_parts = ICEIL(nr_gd, nr_gd_pb);
  53
  54     ext2sb->gdt_frag    = (bbuf_t*)vcalloc(sizeof(bbuf_t), nr_parts);
  55     ext2sb->nr_gdesc_pb = nr_gd_pb;
  56     ext2sb->nr_gdesc    = nr_gd;
  57
  58     bcache_init_zone(&ext2sb->gd_caches, gdesc_bcache_zone,
  59                 ilog2(64), 0, sizeof(struct ext2b_gdesc), &gdesc_bc_ops);
  60
  61     llist_init_head(&ext2sb->gds);
  62     llist_init_head(&ext2sb->free_grps_blk);
  63     llist_init_head(&ext2sb->free_grps_ino);
  64 }
  65
  66 void
  67 ext2gd_release_gdt(struct v_superblock* vsb)
  68 {
  69     unsigned int parts_cnt;
  70     struct ext2_sbinfo* ext2sb;
  71
  72     ext2sb = EXT2_SB(vsb);
  73     parts_cnt = ICEIL(ext2sb->nr_gdesc, ext2sb->nr_gdesc_pb);
  74     for (size_t i = 0; i < parts_cnt; i++)
  75     {
  76         if (!ext2sb->gdt_frag[i]) {
  77             continue;
  78         }
  79
  80         fsblock_put(ext2sb->gdt_frag[i]);
  81         ext2sb->gdt_frag[i] = NULL;
  82     }
  83 }
  84
  85 static inline bool
  86 __try_load_bitmap(struct v_superblock* vsb,
  87                   struct ext2_gdesc* gd, int type)
  88 {
  89     struct ext2_sbinfo* ext2sb;
  90     struct ext2_bmp* bmp;
  91     struct llist_header* flist, *flist_entry;
  92     unsigned int bmp_blk_id, bmp_size;
  93     bbuf_t buf;
  94
  95     ext2sb = EXT2_SB(vsb);
  96
  97     if (type == GDESC_INO_SEL) {
  98         bmp_blk_id = gd->info->bg_ino_map;
  99         bmp_size = ext2sb->raw->s_ino_per_grp;
 100         bmp = &gd->ino_bmp;
 101     }
 102     else if (type == GDESC_BLK_SEL) {
 103         bmp_blk_id = gd->info->bg_blk_map;
 104         bmp_size = ext2sb->raw->s_blk_per_grp;
 105         bmp = &gd->blk_bmp;
 106     }
 107     else {
 108         fail_fs("unknown bitmap type");
 109     }
 110
 111     flist = &ext2sb->free_list_sel[type];
 112     flist_entry = &gd->free_list_sel[type];
 113
 114     buf = fsblock_get(vsb, bmp_blk_id);
 115     if (blkbuf_errbuf(buf)) {
 116         return false;
 117     }
 118
 119     ext2bmp_init(bmp, buf, bmp_size);
 120
 121     if (ext2bmp_check_free(bmp)) {
 122         llist_append(flist, flist_entry);
 123     }
 124
 125     return true;
 126 }
 127
 128 int
 129 ext2gd_take_at(struct v_superblock* vsb,
 130                unsigned int index, struct ext2_gdesc** out)
 131 {
 132     bbuf_t part, buf;
 133     struct ext2_sbinfo* ext2sb;
 134     unsigned int blk_id, blk_off;
 135
 136     ext2sb = EXT2_SB(vsb);
 137
 138     if (index >= ext2sb->nr_gdesc) {
 139         return ENOENT;
 140     }
 141
 142     bcobj_t cached;
 143     if (bcache_tryget(&ext2sb->gd_caches, index, &cached)) {
 144         *out = (struct ext2_gdesc*)bcached_data(cached);
 145         return 0;
 146     }
 147
 148     blk_id  = index / ext2sb->nr_gdesc_pb;
 149     blk_off = index % ext2sb->nr_gdesc_pb;
 150
 151     part = ext2sb->gdt_frag[blk_id];
 152     if (!part) {
 153         blk_id = ext2_datablock(vsb, blk_id + 1);
 154         part   = fsblock_get(vsb, blk_id);
 155         if (!part) {
 156             return EIO;
 157         }
 158
 159         ext2sb->gdt_frag[blk_id] = part;
 160     }
 161
 162     struct ext2_gdesc* gd;
 163
 164     gd = valloc(sizeof(struct ext2_gdesc));
 165     *gd = (struct ext2_gdesc) {
 166         .info = &block_buffer(part, struct ext2b_gdesc)[blk_off],
 167         .buf  = part,
 168         .base = index * ext2sb->raw->s_blk_per_grp,
 169         .ino_base = index * ext2sb->raw->s_ino_per_grp
 170     };
 171
 172     mutex_init(&gd->lock);
 173
 174     *out = gd;
 175
 176     if (!ext2sb->read_only) {
 177         if (!__try_load_bitmap(vsb, gd, GDESC_INO_SEL)) {
 178             goto cleanup;
 179         }
 180
 181         if (!__try_load_bitmap(vsb, gd, GDESC_BLK_SEL)) {
 182             llist_delete(&gd->free_grps_ino);
 183             goto cleanup;
 184         }
 185     }
 186
 187     llist_append(&ext2sb->gds, &gd->groups);
 188
 189     cached = bcache_put_and_ref(&ext2sb->gd_caches, index, gd);
 190     gd->cache_ref = cached;
 191     gd->sb = ext2sb;
 192
 193     return 0;
 194
 195 cleanup:
 196     *out = NULL;
 197
 198     vfree(gd);
 199     return EIO;
 200 }
 201
 202 static void
 203 __ext2bmp_update_next_free_cell(struct ext2_bmp* e_bmp)
 204 {
 205     unsigned int i;
 206     unsigned int end;
 207
 208     i = valid_bmp_slot(e_bmp->next_free) ? e_bmp->next_free : 0;
 209     end = i;
 210
 211     // next fit, try to maximize our locality without going after
 212     //  some crazy algorithm
 213     do {
 214         if (e_bmp->bmp[i] != 0xff) {
 215             e_bmp->next_free = i;
 216             return;
 217         }
 218
 219         if (++i == e_bmp->nr_bytes) {
 220             i = 0;
 221         }
 222     }
 223     while (i != end);
 224
 225     e_bmp->next_free = ALLOC_FAIL;
 226 }
 227
 228 void
 229 ext2bmp_init(struct ext2_bmp* e_bmp, bbuf_t bmp_buf, unsigned int nr_bits)
 230 {
 231     assert(nr_bits % 8 == 0);
 232
 233     e_bmp->bmp = blkbuf_data(bmp_buf);
 234     e_bmp->raw = bmp_buf;
 235     e_bmp->nr_bytes = nr_bits / 8;
 236
 237     __ext2bmp_update_next_free_cell(e_bmp);
 238 }
 239
 240 int
 241 ext2bmp_alloc_nolock(struct ext2_bmp* e_bmp)
 242 {
 243     assert(e_bmp->raw);
 244
 245     u8_t cell;
 246     int slot, next_free;
 247
 248     if (!valid_bmp_slot(e_bmp->next_free)) {
 249         return ALLOC_FAIL;
 250     }
 251
 252     slot = 0;
 253     next_free = e_bmp->next_free;
 254     cell = e_bmp->bmp[next_free];
 255     assert(cell != 0xff);
 256
 257     while ((cell & (1 << slot++)));
 258
 259     cell |= (1 << --slot);
 260     slot += (next_free * 8);
 261     e_bmp->bmp[next_free] = cell;
 262
 263     if (cell == 0xff) {
 264         __ext2bmp_update_next_free_cell(e_bmp);
 265     }
 266
 267     fsblock_dirty(e_bmp->raw);
 268     return slot;
 269 }
 270
 271 void
 272 ext2bmp_free_nolock(struct ext2_bmp* e_bmp, unsigned int pos)
 273 {
 274     assert(e_bmp->raw);
 275
 276     int cell_idx = pos / 8;
 277     u8_t cell_mask = 1 << (pos % 8);
 278     e_bmp->bmp[cell_idx] &= ~cell_mask;
 279
 280     if (!valid_bmp_slot(e_bmp->next_free)) {
 281         e_bmp->next_free = cell_idx;
 282     }
 283
 284     fsblock_dirty(e_bmp->raw);
 285 }
 286
 287 void
 288 ext2bmp_discard_nolock(struct ext2_bmp* e_bmp)
 289 {
 290     assert(e_bmp->raw);
 291
 292     fsblock_put(e_bmp->raw);
 293     e_bmp->raw = NULL;
 294 }