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(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     *out = gd;
 173
 174     if (!ext2sb->read_only) {
 175         if (!__try_load_bitmap(vsb, gd, GDESC_INO_SEL)) {
 176             goto cleanup;
 177         }
 178
 179         if (!__try_load_bitmap(vsb, gd, GDESC_BLK_SEL)) {
 180             llist_delete(&gd->free_grps_ino);
 181             goto cleanup;
 182         }
 183     }
 184
 185     llist_append(&ext2sb->gds, &gd->groups);
 186
 187     cached = bcache_put_and_ref(&ext2sb->gd_caches, index, gd);
 188     gd->cache_ref = cached;
 189     gd->sb = ext2sb;
 190
 191     return 0;
 192
 193 cleanup:
 194     *out = NULL;
 195
 196     vfree(gd);
 197     return EIO;
 198 }
 199
 200 static void
 201 __ext2bmp_update_next_free_cell(struct ext2_bmp* e_bmp)
 202 {
 203     unsigned int i;
 204     unsigned int end;
 205
 206     i = valid_bmp_slot(e_bmp->next_free) ? e_bmp->next_free : 0;
 207     end = i;
 208
 209     // next fit, try to maximize our locality without going after
 210     //  some crazy algorithm
 211     do {
 212         if (e_bmp->bmp[i] != 0xff) {
 213             e_bmp->next_free = i;
 214             return;
 215         }
 216
 217         if (++i == e_bmp->nr_bytes) {
 218             i = 0;
 219         }
 220     }
 221     while (i != end);
 222
 223     e_bmp->next_free = ALLOC_FAIL;
 224 }
 225
 226 void
 227 ext2bmp_init(struct ext2_bmp* e_bmp, bbuf_t bmp_buf, unsigned int nr_bits)
 228 {
 229     assert(nr_bits % 8 == 0);
 230
 231     e_bmp->bmp = blkbuf_data(bmp_buf);
 232     e_bmp->raw = bmp_buf;
 233     e_bmp->nr_bytes = nr_bits / 8;
 234
 235     __ext2bmp_update_next_free_cell(e_bmp);
 236 }
 237
 238 bool
 239 ext2bmp_check_free(struct ext2_bmp* e_bmp)
 240 {
 241     assert(e_bmp->raw);
 242
 243     return valid_bmp_slot(e_bmp->next_free);
 244 }
 245
 246 int
 247 ext2bmp_alloc_one(struct ext2_bmp* e_bmp)
 248 {
 249     assert(e_bmp->raw);
 250
 251     u8_t cell;
 252     int slot, next_free;
 253
 254     if (!valid_bmp_slot(e_bmp->next_free)) {
 255         return ALLOC_FAIL;
 256     }
 257
 258     slot = 0;
 259     next_free = e_bmp->next_free;
 260     cell = e_bmp->bmp[next_free];
 261     assert(cell != 0xff);
 262
 263     while ((cell & (1 << slot++)));
 264
 265     cell |= (1 << --slot);
 266     slot += (next_free * 8);
 267     e_bmp->bmp[next_free] = cell;
 268
 269     if (cell == 0xff) {
 270         __ext2bmp_update_next_free_cell(e_bmp);
 271     }
 272
 273     fsblock_dirty(e_bmp->raw);
 274     return slot;
 275 }
 276
 277 void
 278 ext2bmp_free_one(struct ext2_bmp* e_bmp, unsigned int pos)
 279 {
 280     assert(e_bmp->raw);
 281
 282     int cell_idx = pos / 8;
 283     u8_t cell_mask = 1 << (pos % 8);
 284     e_bmp->bmp[cell_idx] &= ~cell_mask;
 285
 286     if (!valid_bmp_slot(e_bmp->next_free)) {
 287         e_bmp->next_free = cell_idx;
 288     }
 289
 290     fsblock_dirty(e_bmp->raw);
 291 }
 292
 293 void
 294 ext2bmp_discard(struct ext2_bmp* e_bmp)
 295 {
 296     assert(e_bmp->raw);
 297
 298     fsblock_put(e_bmp->raw);
 299     e_bmp->raw = NULL;
 300 }