Skip to content

Commit 1e0449f

Browse files
liamHowattliamHowatt
committed
abstract away bit_bufs from user
1 parent 911d0de commit 1e0449f

File tree

2 files changed

+83
-70
lines changed

2 files changed

+83
-70
lines changed

Diff for: ‎mcp_fs.c

+77-66
Original file line numberDiff line numberDiff line change
@@ -72,30 +72,30 @@ static int scan_file(const mfs_t * mfs, int * end_index_dst, int block_index, ui
7272

7373
int current_block_index = block_index;
7474
while(1) {
75-
res = conf->read_block(conf->cb_ctx, current_block_index);
75+
res = conf->read_block(conf->cb_ctx, current_block_index, mfs->block_buf);
7676
if(res) return res;
7777
set_bit(scratch_bit_buf, current_block_index);
7878
*end_index_dst = current_block_index;
7979

8080
int32_t unoccupied_data_bytes;
81-
memcpy(&unoccupied_data_bytes, conf->block_buf + (conf->block_size - 8), 4);
81+
memcpy(&unoccupied_data_bytes, mfs->block_buf + (conf->block_size - 8), 4);
8282
bool has_next_block = unoccupied_data_bytes < 0;
8383
uint32_t next_block_or_target_checksum;
84-
memcpy(&next_block_or_target_checksum, conf->block_buf + (conf->block_size - 4), 4);
84+
memcpy(&next_block_or_target_checksum, mfs->block_buf + (conf->block_size - 4), 4);
8585
if(!has_next_block) {
86-
running_checksum = checksum_update(running_checksum, conf->block_buf, conf->block_size - 4);
86+
running_checksum = checksum_update(running_checksum, mfs->block_buf, conf->block_size - 4);
8787
if(running_checksum != next_block_or_target_checksum) {
8888
*end_index_dst = -1;
8989
}
9090
return 0;
9191
}
9292
if(next_block_or_target_checksum >= conf->block_count
93-
|| get_bit(conf->bit_bufs[OCCUPIED_BLOCKS], next_block_or_target_checksum)
93+
|| get_bit(mfs->bit_bufs[OCCUPIED_BLOCKS], next_block_or_target_checksum)
9494
|| get_bit(scratch_bit_buf, next_block_or_target_checksum)) {
9595
*end_index_dst = -1;
9696
return 0;
9797
}
98-
running_checksum = checksum_update(running_checksum, conf->block_buf, conf->block_size);
98+
running_checksum = checksum_update(running_checksum, mfs->block_buf, conf->block_size);
9999
current_block_index = next_block_or_target_checksum;
100100
}
101101
}
@@ -106,47 +106,47 @@ static int mount_inner(mfs_t * mfs, int file_initial_idx)
106106
const mfs_conf_t * conf = mfs->conf;
107107

108108
int file_end_idx_this;
109-
res = scan_file(mfs, &file_end_idx_this, file_initial_idx, conf->bit_bufs[SCRATCH_1]);
109+
res = scan_file(mfs, &file_end_idx_this, file_initial_idx, mfs->bit_bufs[SCRATCH_1]);
110110
if(res) return res;
111111
if(file_end_idx_this < 0) {
112112
return 0;
113113
}
114114

115-
res = conf->read_block(conf->cb_ctx, file_initial_idx);
115+
res = conf->read_block(conf->cb_ctx, file_initial_idx, mfs->block_buf);
116116
if(res) return res;
117117

118118
uint32_t birthday_this;
119-
memcpy(&birthday_this, conf->block_buf, 4);
119+
memcpy(&birthday_this, mfs->block_buf, 4);
120120

121121
int32_t preferred_if_older;
122-
memcpy(&preferred_if_older, conf->block_buf + 4, 4);
122+
memcpy(&preferred_if_older, mfs->block_buf + 4, 4);
123123
if(preferred_if_older < 0) {
124124
goto label_end_success;
125125
}
126126

127127
int file_end_idx_other;
128-
res = scan_file(mfs, &file_end_idx_other, preferred_if_older, conf->bit_bufs[SCRATCH_2]);
128+
res = scan_file(mfs, &file_end_idx_other, preferred_if_older, mfs->bit_bufs[SCRATCH_2]);
129129
if(res) return res;
130130
if(file_end_idx_other < 0) {
131131
goto label_end_success;
132132
}
133133

134-
res = conf->read_block(conf->cb_ctx, preferred_if_older);
134+
res = conf->read_block(conf->cb_ctx, preferred_if_older, mfs->block_buf);
135135
if(res) return res;
136136

137137
uint32_t birthday_other;
138-
memcpy(&birthday_other, conf->block_buf, 4);
138+
memcpy(&birthday_other, mfs->block_buf, 4);
139139
if(birthday_other <= birthday_this) {
140140
return 0;
141141
}
142142

143143
label_end_success:
144144
if(birthday_this > mfs->youngest) mfs->youngest = birthday_this;
145-
set_bit(conf->bit_bufs[FILE_START_BLOCKS], file_initial_idx);
145+
set_bit(mfs->bit_bufs[FILE_START_BLOCKS], file_initial_idx);
146146
mfs->file_count += 1;
147147
int bit_buf_len = MFS_BIT_BUF_SIZE_BYTES(conf->block_count);
148148
for(int i = 0; i < bit_buf_len; i++) {
149-
conf->bit_bufs[OCCUPIED_BLOCKS][i] |= conf->bit_bufs[SCRATCH_1][i];
149+
mfs->bit_bufs[OCCUPIED_BLOCKS][i] |= mfs->bit_bufs[SCRATCH_1][i];
150150
}
151151
return 0;
152152
}
@@ -160,14 +160,25 @@ int mfs_mount(mfs_t * mfs, const mfs_conf_t * conf)
160160
return MFS_BAD_BLOCK_CONFIG_ERROR;
161161
}
162162

163+
int bit_buf_size = MFS_BIT_BUF_SIZE_BYTES(conf->block_count);
164+
163165
mfs->conf = conf;
166+
167+
mfs->block_buf = conf->aligned_aux_memory;
168+
uint8_t * aux_mem_u8 = conf->aligned_aux_memory;
169+
aux_mem_u8 += conf->block_size;
170+
for(int i = 0; i < 4; i++) {
171+
mfs->bit_bufs[i] = aux_mem_u8;
172+
aux_mem_u8 += bit_buf_size;
173+
}
174+
164175
mfs->file_count = 0;
165176
mfs->youngest = 0;
166177
mfs->open_file_mode = -1;
167178
mfs->needs_remount = false;
168179

169-
memset(conf->bit_bufs[FILE_START_BLOCKS], 0, MFS_BIT_BUF_SIZE_BYTES(conf->block_count));
170-
memset(conf->bit_bufs[OCCUPIED_BLOCKS], 0, MFS_BIT_BUF_SIZE_BYTES(conf->block_count));
180+
memset(mfs->bit_bufs[FILE_START_BLOCKS], 0, bit_buf_size);
181+
memset(mfs->bit_bufs[OCCUPIED_BLOCKS], 0, bit_buf_size);
171182

172183
for(int file_initial_idx = 0; file_initial_idx < conf->block_count; file_initial_idx++) {
173184
res = mount_inner(mfs, file_initial_idx);
@@ -208,12 +219,12 @@ int mfs_list_files(mfs_t * mfs, void * list_file_cb_ctx, void (*list_file_cb)(vo
208219

209220
int files_left = mfs->file_count;
210221
for(int i = 0; files_left; i++) {
211-
if(!get_bit(conf->bit_bufs[FILE_START_BLOCKS], i)) {
222+
if(!get_bit(mfs->bit_bufs[FILE_START_BLOCKS], i)) {
212223
continue;
213224
}
214-
res = conf->read_block(conf->cb_ctx, i);
225+
res = conf->read_block(conf->cb_ctx, i, mfs->block_buf);
215226
if(res) return res;
216-
list_file_cb(list_file_cb_ctx, (char *) conf->block_buf + 8);
227+
list_file_cb(list_file_cb_ctx, (char *) mfs->block_buf + 8);
217228
files_left--;
218229
}
219230

@@ -243,13 +254,13 @@ int mfs_delete(mfs_t * mfs, const char * name)
243254

244255
int files_left = mfs->file_count;
245256
for(i = 0; files_left; i++) {
246-
if(!get_bit(conf->bit_bufs[FILE_START_BLOCKS], i)) {
257+
if(!get_bit(mfs->bit_bufs[FILE_START_BLOCKS], i)) {
247258
continue;
248259
}
249-
res = conf->read_block(conf->cb_ctx, i);
260+
res = conf->read_block(conf->cb_ctx, i, mfs->block_buf);
250261
if(res) return res;
251262

252-
if(0 == strcmp(name, (char *) conf->block_buf + 8)) {
263+
if(0 == strcmp(name, (char *) mfs->block_buf + 8)) {
253264
break;
254265
}
255266

@@ -261,30 +272,30 @@ int mfs_delete(mfs_t * mfs, const char * name)
261272
}
262273
int delete_file_page_1 = i;
263274

264-
clear_bit(conf->bit_bufs[FILE_START_BLOCKS], delete_file_page_1);
275+
clear_bit(mfs->bit_bufs[FILE_START_BLOCKS], delete_file_page_1);
265276

266277
uint32_t birthday;
267-
memcpy(&birthday, conf->block_buf, 4);
278+
memcpy(&birthday, mfs->block_buf, 4);
268279
if(birthday == mfs->youngest) mfs->youngest--;
269280

270281
int end_idx;
271-
res = scan_file(mfs, &end_idx, delete_file_page_1, conf->bit_bufs[SCRATCH_1]);
282+
res = scan_file(mfs, &end_idx, delete_file_page_1, mfs->bit_bufs[SCRATCH_1]);
272283
if(res) SET_NEEDS_REMOUNT_THEN_RETURN(mfs, res);
273284
if(end_idx < 0) SET_NEEDS_REMOUNT_THEN_RETURN(mfs, MFS_INTERNAL_ASSERTION_ERROR);
274285

275286
int bit_buf_len = MFS_BIT_BUF_SIZE_BYTES(conf->block_count);
276287
for(i = 0; i < bit_buf_len; i++) {
277-
conf->bit_bufs[OCCUPIED_BLOCKS][i] &= ~conf->bit_bufs[SCRATCH_1][i];
288+
mfs->bit_bufs[OCCUPIED_BLOCKS][i] &= ~mfs->bit_bufs[SCRATCH_1][i];
278289
}
279290

280291
/* clobber the first page */
281-
memset(conf->block_buf, 0xff, conf->block_size);
282-
res = conf->write_block(conf->cb_ctx, delete_file_page_1);
292+
memset(mfs->block_buf, 0xff, conf->block_size);
293+
res = conf->write_block(conf->cb_ctx, delete_file_page_1, mfs->block_buf);
283294
if(res) SET_NEEDS_REMOUNT_THEN_RETURN(mfs, res);
284-
res = conf->read_block(conf->cb_ctx, delete_file_page_1);
295+
res = conf->read_block(conf->cb_ctx, delete_file_page_1, mfs->block_buf);
285296
if(res) SET_NEEDS_REMOUNT_THEN_RETURN(mfs, res);
286297
for(i = 0; i < conf->block_size; i++) {
287-
if(conf->block_buf[i] != 0xff) SET_NEEDS_REMOUNT_THEN_RETURN(mfs, MFS_READBACK_ERROR);
298+
if(mfs->block_buf[i] != 0xff) SET_NEEDS_REMOUNT_THEN_RETURN(mfs, MFS_READBACK_ERROR);
288299
}
289300

290301
mfs->file_count -= 1;
@@ -315,13 +326,13 @@ int mfs_open(mfs_t * mfs, const char * name, mfs_mode_t mode)
315326

316327
int files_left = mfs->file_count;
317328
for(i = 0; files_left; i++) {
318-
if(!get_bit(conf->bit_bufs[FILE_START_BLOCKS], i)) {
329+
if(!get_bit(mfs->bit_bufs[FILE_START_BLOCKS], i)) {
319330
continue;
320331
}
321-
res = conf->read_block(conf->cb_ctx, i);
332+
res = conf->read_block(conf->cb_ctx, i, mfs->block_buf);
322333
if(res) return res;
323334

324-
if(0 == strcmp(name, (char *) conf->block_buf + 8)) {
335+
if(0 == strcmp(name, (char *) mfs->block_buf + 8)) {
325336
break;
326337
}
327338

@@ -336,21 +347,21 @@ int mfs_open(mfs_t * mfs, const char * name, mfs_mode_t mode)
336347
else {
337348
mfs->open_file_match_index = files_left ? i : -1;
338349
for(i = 0; i < conf->block_count; i++) {
339-
if(!get_bit(conf->bit_bufs[OCCUPIED_BLOCKS], i)) break;
350+
if(!get_bit(mfs->bit_bufs[OCCUPIED_BLOCKS], i)) break;
340351
}
341352
if(i == conf->block_count) {
342353
return MFS_NO_SPACE_ERROR;
343354
}
344-
set_bit(conf->bit_bufs[OCCUPIED_BLOCKS], i);
345-
set_bit(conf->bit_bufs[FILE_START_BLOCKS], i);
355+
set_bit(mfs->bit_bufs[OCCUPIED_BLOCKS], i);
356+
set_bit(mfs->bit_bufs[FILE_START_BLOCKS], i);
346357
if(mfs->youngest == UINT32_MAX) {
347358
SET_NEEDS_REMOUNT_THEN_RETURN(mfs, MFS_BIRTHDAY_LIMIT_REACHED_ERROR);
348359
}
349360
mfs->youngest += 1;
350-
memcpy(conf->block_buf, &mfs->youngest, 4);
351-
memcpy(conf->block_buf + 4, &mfs->open_file_match_index, 4);
352-
strcpy((char *) conf->block_buf + 8, name);
353-
mfs->writer_checksum = checksum_update(CHECKSUM_INIT_VAL, conf->block_buf, 8 + name_len + 1);
361+
memcpy(mfs->block_buf, &mfs->youngest, 4);
362+
memcpy(mfs->block_buf + 4, &mfs->open_file_match_index, 4);
363+
strcpy((char *) mfs->block_buf + 8, name);
364+
mfs->writer_checksum = checksum_update(CHECKSUM_INIT_VAL, mfs->block_buf, 8 + name_len + 1);
354365
mfs->open_file_block = i;
355366
mfs->open_file_first_block = i;
356367
}
@@ -377,7 +388,7 @@ int mfs_read(mfs_t * mfs, uint8_t * dst, int size)
377388

378389
while(size) {
379390
int32_t unoccupied_data_bytes;
380-
memcpy(&unoccupied_data_bytes, conf->block_buf + (conf->block_size - 8), 4);
391+
memcpy(&unoccupied_data_bytes, mfs->block_buf + (conf->block_size - 8), 4);
381392
bool has_next_block = unoccupied_data_bytes < 0;
382393
if(has_next_block) unoccupied_data_bytes = 0;
383394

@@ -389,21 +400,21 @@ int mfs_read(mfs_t * mfs, uint8_t * dst, int size)
389400
}
390401

391402
uint32_t new_block_idx;
392-
memcpy(&new_block_idx, conf->block_buf + (conf->block_size - 4), 4);
403+
memcpy(&new_block_idx, mfs->block_buf + (conf->block_size - 4), 4);
393404

394-
res = conf->read_block(conf->cb_ctx, new_block_idx);
405+
res = conf->read_block(conf->cb_ctx, new_block_idx, mfs->block_buf);
395406
if(res) SET_FILE_CLOSED_THEN_RETURN(mfs, res);
396407

397408
mfs->open_file_block_cursor = 0;
398409

399-
memcpy(&unoccupied_data_bytes, conf->block_buf + (conf->block_size - 8), 4);
410+
memcpy(&unoccupied_data_bytes, mfs->block_buf + (conf->block_size - 8), 4);
400411
if(unoccupied_data_bytes < 0) unoccupied_data_bytes = 0;
401412
block_len_remaining = conf->block_size - unoccupied_data_bytes - 8;
402413
}
403414

404415
int copy_amount = block_len_remaining < size ? block_len_remaining : size;
405416

406-
memcpy(dst, &conf->block_buf[mfs->open_file_block_cursor], copy_amount);
417+
memcpy(dst, &mfs->block_buf[mfs->open_file_block_cursor], copy_amount);
407418

408419
size -= copy_amount;
409420
dst += copy_amount;
@@ -433,19 +444,19 @@ int mfs_write(mfs_t * mfs, const uint8_t * src, int size)
433444
if(!block_len_remaining) {
434445
uint32_t i;
435446
for(i = 0; i < conf->block_count; i++) {
436-
if(!get_bit(conf->bit_bufs[OCCUPIED_BLOCKS], i)) break;
447+
if(!get_bit(mfs->bit_bufs[OCCUPIED_BLOCKS], i)) break;
437448
}
438449
if(i == conf->block_count) {
439450
SET_NEEDS_REMOUNT_THEN_RETURN(mfs, MFS_NO_SPACE_ERROR);
440451
}
441-
set_bit(conf->bit_bufs[OCCUPIED_BLOCKS], i);
452+
set_bit(mfs->bit_bufs[OCCUPIED_BLOCKS], i);
442453

443454
int32_t unoccupied_data_bytes = -1;
444-
memcpy(conf->block_buf + (conf->block_size - 8), &unoccupied_data_bytes, 4);
445-
memcpy(conf->block_buf + (conf->block_size - 4), &i, 4);
446-
mfs->writer_checksum = checksum_update(mfs->writer_checksum, conf->block_buf + (conf->block_size - 8), 8);
455+
memcpy(mfs->block_buf + (conf->block_size - 8), &unoccupied_data_bytes, 4);
456+
memcpy(mfs->block_buf + (conf->block_size - 4), &i, 4);
457+
mfs->writer_checksum = checksum_update(mfs->writer_checksum, mfs->block_buf + (conf->block_size - 8), 8);
447458

448-
res = conf->write_block(conf->cb_ctx, mfs->open_file_block);
459+
res = conf->write_block(conf->cb_ctx, mfs->open_file_block, mfs->block_buf);
449460
if(res) SET_NEEDS_REMOUNT_THEN_RETURN(mfs, res);
450461

451462
mfs->open_file_block_cursor = 0;
@@ -456,7 +467,7 @@ int mfs_write(mfs_t * mfs, const uint8_t * src, int size)
456467
int copy_amount = block_len_remaining < write_size_left ? block_len_remaining : write_size_left;
457468

458469
mfs->writer_checksum = checksum_update(mfs->writer_checksum, src, copy_amount);
459-
memcpy(conf->block_buf + mfs->open_file_block_cursor, src, copy_amount);
470+
memcpy(mfs->block_buf + mfs->open_file_block_cursor, src, copy_amount);
460471

461472
write_size_left -= copy_amount;
462473
src += copy_amount;
@@ -479,38 +490,38 @@ int mfs_close(mfs_t * mfs)
479490

480491
if(mfs->open_file_mode == MFS_MODE_WRITE) {
481492
int32_t unoccupied_data_bytes = conf->block_size - mfs->open_file_block_cursor - 8;
482-
memset(conf->block_buf + mfs->open_file_block_cursor, 0xff, unoccupied_data_bytes);
483-
memcpy(conf->block_buf + (conf->block_size - 8), &unoccupied_data_bytes, 4);
484-
mfs->writer_checksum = checksum_update(mfs->writer_checksum, conf->block_buf + mfs->open_file_block_cursor, unoccupied_data_bytes + 4);
485-
memcpy(conf->block_buf + (conf->block_size - 4), &mfs->writer_checksum, 4);
493+
memset(mfs->block_buf + mfs->open_file_block_cursor, 0xff, unoccupied_data_bytes);
494+
memcpy(mfs->block_buf + (conf->block_size - 8), &unoccupied_data_bytes, 4);
495+
mfs->writer_checksum = checksum_update(mfs->writer_checksum, mfs->block_buf + mfs->open_file_block_cursor, unoccupied_data_bytes + 4);
496+
memcpy(mfs->block_buf + (conf->block_size - 4), &mfs->writer_checksum, 4);
486497

487-
res = conf->write_block(conf->cb_ctx, mfs->open_file_block);
498+
res = conf->write_block(conf->cb_ctx, mfs->open_file_block, mfs->block_buf);
488499
if(res) SET_NEEDS_REMOUNT_THEN_RETURN(mfs, res);
489500

490501
int end_index;
491-
res = scan_file(mfs, &end_index, mfs->open_file_first_block, conf->bit_bufs[SCRATCH_1]);
502+
res = scan_file(mfs, &end_index, mfs->open_file_first_block, mfs->bit_bufs[SCRATCH_1]);
492503
if(res) SET_NEEDS_REMOUNT_THEN_RETURN(mfs, res);
493504

494505
if(mfs->open_file_match_index != -1) {
495-
clear_bit(conf->bit_bufs[FILE_START_BLOCKS], mfs->open_file_match_index);
506+
clear_bit(mfs->bit_bufs[FILE_START_BLOCKS], mfs->open_file_match_index);
496507

497-
res = scan_file(mfs, &end_index, mfs->open_file_match_index, conf->bit_bufs[SCRATCH_1]);
508+
res = scan_file(mfs, &end_index, mfs->open_file_match_index, mfs->bit_bufs[SCRATCH_1]);
498509
if(res) SET_NEEDS_REMOUNT_THEN_RETURN(mfs, res);
499510
if(end_index < 0) SET_NEEDS_REMOUNT_THEN_RETURN(mfs, MFS_INTERNAL_ASSERTION_ERROR);
500511

501512
int bit_buf_len = MFS_BIT_BUF_SIZE_BYTES(conf->block_count);
502513
for(int i = 0; i < bit_buf_len; i++) {
503-
conf->bit_bufs[OCCUPIED_BLOCKS][i] &= ~conf->bit_bufs[SCRATCH_1][i];
514+
mfs->bit_bufs[OCCUPIED_BLOCKS][i] &= ~mfs->bit_bufs[SCRATCH_1][i];
504515
}
505516

506517
/* clobber the first page */
507-
memset(conf->block_buf, 0xff, conf->block_size);
508-
res = conf->write_block(conf->cb_ctx, mfs->open_file_match_index);
518+
memset(mfs->block_buf, 0xff, conf->block_size);
519+
res = conf->write_block(conf->cb_ctx, mfs->open_file_match_index, mfs->block_buf);
509520
if(res) SET_NEEDS_REMOUNT_THEN_RETURN(mfs, res);
510-
res = conf->read_block(conf->cb_ctx, mfs->open_file_match_index);
521+
res = conf->read_block(conf->cb_ctx, mfs->open_file_match_index, mfs->block_buf);
511522
if(res) SET_NEEDS_REMOUNT_THEN_RETURN(mfs, res);
512523
for(int i = 0; i < conf->block_size; i++) {
513-
if(conf->block_buf[i] != 0xff) SET_NEEDS_REMOUNT_THEN_RETURN(mfs, MFS_READBACK_ERROR);
524+
if(mfs->block_buf[i] != 0xff) SET_NEEDS_REMOUNT_THEN_RETURN(mfs, MFS_READBACK_ERROR);
514525
}
515526
}
516527
else {

Diff for: ‎mcp_fs.h

+6-4
Original file line numberDiff line numberDiff line change
@@ -12,24 +12,26 @@
1212
#define MFS_BIRTHDAY_LIMIT_REACHED_ERROR -1007
1313

1414
#define MFS_BIT_BUF_SIZE_BYTES(block_count) (((block_count) - 1) / 8 + 1)
15+
#define MFS_ALIGNED_AUX_MEMORY_SIZE(block_size, block_count) ((block_size) + MFS_BIT_BUF_SIZE_BYTES((block_count)) * 4)
1516

1617
typedef enum {
1718
MFS_MODE_READ,
1819
MFS_MODE_WRITE
1920
} mfs_mode_t;
2021

2122
typedef struct {
22-
uint8_t * block_buf;
23-
uint8_t * bit_bufs[4];
23+
void * aligned_aux_memory;
2424
int block_size;
2525
int block_count;
2626
void * cb_ctx;
27-
int (*read_block)(void * cb_ctx, int block_index);
28-
int (*write_block)(void * cb_ctx, int block_index);
27+
int (*read_block)(void * cb_ctx, int block_index, void * dst);
28+
int (*write_block)(void * cb_ctx, int block_index, const void * src);
2929
} mfs_conf_t;
3030

3131
typedef struct {
3232
const mfs_conf_t * conf;
33+
uint8_t * block_buf;
34+
uint8_t * bit_bufs[4];
3335
int file_count;
3436
uint32_t youngest;
3537
int8_t open_file_mode;

0 commit comments

Comments
 (0)