int main(void)
{
init_blocks();
print_blocks();
block_quick_sort(start, end+1, SORT_BY_ADDRESS);
print_blocks();
return 0;
}
/* Traverse all block references of an i-node, and print out information about
the data blocks and indirect blocks. Instead of printing to standard output,
this appends the output to an array. truncate-test needs this so that it
can compare the expected and actual output for the test. */
void print_inode_blocks(inode *ino, array *out)
{
int lblock = 0;
int i;
for (i = 0; i < 12; i++)
print_blocks(ino,ino->in.block[i],0,0,&lblock,out);
print_blocks(ino,ino->in.block[12],1,0,&lblock,out);
print_blocks(ino,ino->in.block[13],2,0,&lblock,out);
print_blocks(ino,ino->in.block[14],3,0,&lblock,out);
}
void *kmalloc(u32 size)
{
int i;
int j;
struct header *fit = NULL;
struct alloc_list *l;
for_each_alloc_list_entry(l, j) {
struct header *t = l->first;
for_each_block(t, i) {
if (t->used)
continue;
if (fit == NULL) {
fit = t;
continue;
}
if (t->size >= size && t->size < fit->size) {
fit = t;
continue;
}
}
}
if (fit == NULL) {
add_block(GROW_BUFFER_SIZE);
return kmalloc(size);
return NULL;
}
/* Check if we can break the block down */
int left = fit->size - size - sizeof(struct header) - sizeof(struct footer);
if (left > 4)
break_block(fit, size);
fit->used = 1;
print_blocks();
return fit->mem;
}
block* function_block(node* body, int print) {
blockCount = 1;
currentBlock = bb_newBlock(++functionCount, blockCount, currentBlock);
block* tmp = currentBlock;
stmt_list_parse(body);
if(!currentBlock->bottom || currentBlock->bottom->op != O_RETURN) { //default return
emit(O_RETURN, NULL, NULL, NULL);
}
if(print)
print_blocks(tmp);
return tmp;
}
void kfree(void *ptr)
{
struct header *header = (struct header *)((u32)ptr - sizeof(struct header));
if (header->magic != MAGIC_CHECK) {
printk ("Memory corruption!\n");
return;
}
header->used = 0;
if (header->next && header->next->used == 0)
merge_next(header);
if(header->prev && header->prev->used == 0)
merge_prev(header);
print_blocks();
}
int main(int argc, const char *argv[])
{
int fd;
if (argc<2) {
fprintf(stderr,"uage %d file",argv[0]);
return -1;
}
fd = open(argv[1],O_RDONLY);
if (fd<0) {
perror("open");
return 1;
}
print_blocks(fd);
return 0;
}
/* Helper function used by print_inode_blocks */
static void print_blocks(inode *ino, uint32_t blockno, int level, int indent,
int *lblock, array *out)
{
if (0 == blockno)
return;
char str[256];
str[0] = '\0';
char *s = str;
int i;
for (i = 0; i < indent; i++)
s += sprintf(s," ");
switch (level) {
case 0:
s += sprintf(s,"Direct %d",blockno);
break;
case 1:
s += sprintf(s,"Single indirect %d",blockno);
break;
case 2:
s += sprintf(s,"Double indirect %d",blockno);
break;
case 3:
s += sprintf(s,"Triple indirect %d",blockno);
break;
}
if (level == 0) {
array_printf(out,"%-40s %d\n",str,*lblock);
(*lblock)++;
}
else {
array_printf(out,"%s\n",str);
}
if (level > 0) {
buffer *table;
try(bufcache_get(ino->fs->bc,blockno,&table));
for (i = 0; i < RPB; i++)
print_blocks(ino,((uint32_t*)table->data)[i],level-1,indent+1,lblock,out);
}
}
int make_ext4fs_internal(int fd, const char *_directory,
fs_config_func_t fs_config_func, int gzip,
int sparse, int crc, int wipe,
int verbose, time_t fixed_time,
FILE* block_list_file)
{
u32 root_inode_num;
u16 root_mode;
char *directory = NULL;
if (setjmp(setjmp_env))
return EXIT_FAILURE; /* Handle a call to longjmp() */
if (_directory == NULL) {
fprintf(stderr, "Need a source directory\n");
return EXIT_FAILURE;
}
directory = canonicalize_rel_slashes(_directory);
if (info.len <= 0)
info.len = get_file_size(fd);
if (info.len <= 0) {
fprintf(stderr, "Need size of filesystem\n");
return EXIT_FAILURE;
}
if (info.block_size <= 0)
info.block_size = compute_block_size();
/* Round down the filesystem length to be a multiple of the block size */
info.len &= ~((u64)info.block_size - 1);
if (info.journal_blocks == 0)
info.journal_blocks = compute_journal_blocks();
if (info.no_journal == 0)
info.feat_compat = EXT4_FEATURE_COMPAT_HAS_JOURNAL;
else
info.journal_blocks = 0;
if (info.blocks_per_group <= 0)
info.blocks_per_group = compute_blocks_per_group();
if (info.inodes <= 0)
info.inodes = compute_inodes();
if (info.inode_size <= 0)
info.inode_size = 256;
if (info.label == NULL)
info.label = "";
info.inodes_per_group = compute_inodes_per_group();
info.feat_compat |=
EXT4_FEATURE_COMPAT_RESIZE_INODE |
EXT4_FEATURE_COMPAT_EXT_ATTR;
info.feat_ro_compat |=
EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER |
EXT4_FEATURE_RO_COMPAT_LARGE_FILE |
EXT4_FEATURE_RO_COMPAT_GDT_CSUM;
info.feat_incompat |=
EXT4_FEATURE_INCOMPAT_EXTENTS |
EXT4_FEATURE_INCOMPAT_FILETYPE;
info.bg_desc_reserve_blocks = compute_bg_desc_reserve_blocks();
printf("Creating filesystem with parameters:\n");
printf(" Size: %"PRIu64"\n", info.len);
printf(" Block size: %d\n", info.block_size);
printf(" Blocks per group: %d\n", info.blocks_per_group);
printf(" Inodes per group: %d\n", info.inodes_per_group);
printf(" Inode size: %d\n", info.inode_size);
printf(" Journal blocks: %d\n", info.journal_blocks);
printf(" Label: %s\n", info.label);
ext4_create_fs_aux_info();
printf(" Blocks: %"PRIu64"\n", aux_info.len_blocks);
printf(" Block groups: %d\n", aux_info.groups);
printf(" Reserved blocks: %"PRIu64"\n", (aux_info.len_blocks / 100) * info.reserve_pcnt);
printf(" Reserved block group size: %d\n", info.bg_desc_reserve_blocks);
ext4_sparse_file = sparse_file_new(info.block_size, info.len);
block_allocator_init();
ext4_fill_in_sb();
if (reserve_inodes(0, 10) == EXT4_ALLOCATE_FAILED)
error("failed to reserve first 10 inodes");
if (info.feat_compat & EXT4_FEATURE_COMPAT_HAS_JOURNAL)
ext4_create_journal_inode();
if (info.feat_compat & EXT4_FEATURE_COMPAT_RESIZE_INODE)
ext4_create_resize_inode();
root_inode_num = build_directory_structure(directory, "", 0,
fs_config_func, verbose, fixed_time);
root_mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
inode_set_permissions(root_inode_num, root_mode, 0, 0, 0);
ext4_update_free();
ext4_queue_sb();
if (block_list_file) {
size_t dirlen = strlen(directory);
struct block_allocation* p = get_saved_allocation_chain();
while (p) {
if (strncmp(p->filename, directory, dirlen) == 0) {
fprintf(block_list_file, "%s", p->filename + dirlen);
} else {
fprintf(block_list_file, "%s", p->filename);
}
print_blocks(block_list_file, p);
struct block_allocation* pn = p->next;
free_alloc(p);
p = pn;
}
}
printf("Created filesystem with %d/%d inodes and %d/%d blocks\n",
aux_info.sb->s_inodes_count - aux_info.sb->s_free_inodes_count,
aux_info.sb->s_inodes_count,
aux_info.sb->s_blocks_count_lo - aux_info.sb->s_free_blocks_count_lo,
aux_info.sb->s_blocks_count_lo);
if (wipe && WIPE_IS_SUPPORTED) {
wipe_block_device(fd, info.len);
}
write_ext4_image(fd, gzip, sparse, crc);
sparse_file_destroy(ext4_sparse_file);
ext4_sparse_file = NULL;
free(directory);
return 0;
}
// Functions to pretty-print inline and node_block lists, for debugging.
// Prettyprint an inline list, for debugging.
static void print_blocks(node_block* b, int indent)
{
struct ListData *data;
while(b != NULL) {
for (int i=0; i < indent; i++) {
putchar(' ');
}
switch(b->tag) {
case BLOCK_DOCUMENT:
printf("document\n");
print_blocks(b->children, indent + 2);
break;
case BLOCK_BQUOTE:
printf("block_quote\n");
print_blocks(b->children, indent + 2);
break;
case BLOCK_LIST_ITEM:
printf("list_item\n");
print_blocks(b->children, indent + 2);
break;
case BLOCK_LIST:
data = &(b->as.list);
if (data->list_type == ordered) {
printf("list (type=ordered tight=%s start=%d delim=%s)\n",
(data->tight ? "true" : "false"),
data->start,
(data->delimiter == parens ? "parens" : "period"));
} else {
printf("list (type=bullet tight=%s bullet_char=%c)\n",
(data->tight ? "true" : "false"),
data->bullet_char);
}
print_blocks(b->children, indent + 2);
break;
case BLOCK_ATX_HEADER:
printf("atx_header (level=%d)\n", b->as.header.level);
print_inlines(b->inline_content, indent + 2);
break;
case BLOCK_SETEXT_HEADER:
printf("setext_header (level=%d)\n", b->as.header.level);
print_inlines(b->inline_content, indent + 2);
break;
case BLOCK_PARAGRAPH:
printf("paragraph\n");
print_inlines(b->inline_content, indent + 2);
break;
case BLOCK_HRULE:
printf("hrule\n");
break;
case BLOCK_INDENTED_CODE:
printf("indented_code ");
print_str(b->string_content.ptr, -1);
putchar('\n');
break;
case BLOCK_FENCED_CODE:
printf("fenced_code length=%d info=",
b->as.code.fence_length);
print_str(b->as.code.info.ptr, -1);
putchar(' ');
print_str(b->string_content.ptr, -1);
putchar('\n');
break;
case BLOCK_HTML:
printf("html_block ");
print_str(b->string_content.ptr, -1);
putchar('\n');
break;
case BLOCK_REFERENCE_DEF:
printf("reference_def\n");
break;
default:
printf("# NOT IMPLEMENTED (%d)\n", b->tag);
break;
}
b = b->next;
}
}
void stmd_debug_print(node_block *root)
{
print_blocks(root, 0);
}
int main(int argc, char **argv)
{
int rc;
char *dev_path;
size_t block_size;
char *endptr;
aoff64_t block_offset = 0;
aoff64_t block_count = 1;
aoff64_t dev_nblocks;
bool toc = false;
if (argc < 2) {
printf(NAME ": Error, argument missing.\n");
syntax_print();
return 1;
}
--argc; ++argv;
if (str_cmp(*argv, "--toc") == 0) {
--argc; ++argv;
toc = true;
goto devname;
}
if (str_cmp(*argv, "--relative") == 0) {
--argc; ++argv;
relative = true;
}
if (str_cmp(*argv, "--offset") == 0) {
--argc; ++argv;
if (*argv == NULL) {
printf(NAME ": Error, argument missing (offset).\n");
syntax_print();
return 1;
}
block_offset = strtol(*argv, &endptr, 10);
if (*endptr != '\0') {
printf(NAME ": Error, invalid argument (offset).\n");
syntax_print();
return 1;
}
--argc; ++argv;
}
if (str_cmp(*argv, "--count") == 0) {
--argc; ++argv;
if (*argv == NULL) {
printf(NAME ": Error, argument missing (count).\n");
syntax_print();
return 1;
}
block_count = strtol(*argv, &endptr, 10);
if (*endptr != '\0') {
printf(NAME ": Error, invalid argument (count).\n");
syntax_print();
return 1;
}
--argc; ++argv;
}
devname:
if (argc != 1) {
printf(NAME ": Error, unexpected argument.\n");
syntax_print();
return 1;
}
dev_path = *argv;
rc = loc_service_get_id(dev_path, &service_id, 0);
if (rc != EOK) {
printf(NAME ": Error resolving device `%s'.\n", dev_path);
return 2;
}
rc = block_init(service_id, 2048);
if (rc != EOK) {
printf(NAME ": Error initializing libblock.\n");
return 2;
}
rc = block_get_bsize(service_id, &block_size);
if (rc != EOK) {
printf(NAME ": Error determining device block size.\n");
return 2;
}
rc = block_get_nblocks(service_id, &dev_nblocks);
if (rc != EOK) {
printf(NAME ": Warning, failed to obtain block device size.\n");
}
printf("Device %s has %" PRIuOFF64 " blocks, %" PRIuOFF64 " bytes each\n", dev_path, dev_nblocks, (aoff64_t) block_size);
if (toc)
rc = print_toc();
else
rc = print_blocks(block_offset, block_count, block_size);
block_fini(service_id);
return rc;
}
/*void print_block ( int fd, struct ext3_super_block *sb, __u32 block_num )
{
print_blocks ( fd, sb, block_num, 0, PLAIN_DATA );
}
*/
void print_blocks ( int fd, struct ext3_super_block *sb,
__u32 block_num, short rec_level, int mode ) {
/*
This function reads and print recursively the indexed blocks :
a rec_level of 1 means to consider block_num as an index of blocks
2 block_num as an index of index of blocks
and so on ...
*/
unsigned int c = 0;
char octet;
__u32 iblock_num;
off_t lret;
size_t sret;
if ( rec_level == 0 ) {
DEBUG_PRINT("Reading block %u", block_num);
lret = lseek( fd, ((off_t) block_num)*EXT3_BLOCK_SIZE(sb), SEEK_SET);
if ( lret <= 0 ) {
perror("ext3Viewer error - lseek block print_blocks");
exit (-1);
}
if ( mode == HEXA_DATA ) {
print_block_hexa_noline ( fd, sb, block_num );
}
else if ( mode == PLAIN_DATA ) {
for ( c = 0 ; c < EXT3_BLOCK_SIZE(sb) ; c++ )
{
sret = read ( fd, &octet, sizeof(char) );
if ( sret <= 0 ) {
perror("ext3Viewer error - read octet print_blocks");
exit (-1);
}
putchar(octet);
}
}
}
else {
if ( block_num > 0 ) {
DEBUG_PRINT("Reading block index %u", block_num);
lret = lseek( fd, ((off_t) block_num)*EXT3_BLOCK_SIZE(sb), SEEK_SET);
if ( lret <= 0 ) {
perror("ext3Viewer error - lseek 2 print_blocks");
exit (-1);
}
sret = read ( fd, &iblock_num, 4 ); /*we read the block number of the
indexed block */
if ( sret <= 0 ) {
perror("ext3Viewer error - read 2 print_blocks");
exit (-1);
}
while ( iblock_num != 0 && c < (EXT3_BLOCK_SIZE(sb)/4) )
{
// Go through the block table
// For each block, display it or go through it if it's a table
print_blocks ( fd, sb, iblock_num, rec_level-1, mode );
c++;
lret = lseek( fd, ((off_t) block_num)*EXT3_BLOCK_SIZE(sb)+(c*4),
SEEK_SET);
if ( lret <= 0 ) {
perror("ext3Viewer error - lseek 3 print_blocks");
exit (-1);
}
// Move 4 by 4 octets because it's the size of u_32 on which the block
// number are stored
sret = read ( fd, &iblock_num, 4 );
if ( sret <= 0 ) {
perror("ext3Viewer error - read 3 print_blocks");
exit (-1);
}
}
}
}
}
int make_ext4fs_internal(int fd, const char *_directory, const char *_target_out_directory,
const char *_mountpoint, fs_config_func_t fs_config_func, int gzip,
int sparse, int crc, int wipe, int real_uuid,
struct selabel_handle *sehnd, int verbose, time_t fixed_time,
FILE* block_list_file)
{
u32 root_inode_num;
u16 root_mode;
char *mountpoint;
char *directory = NULL;
char *target_out_directory = NULL;
if (setjmp(setjmp_env))
return EXIT_FAILURE; /* Handle a call to longjmp() */
info.block_device = is_block_device_fd(fd);
if (info.block_device && (sparse || gzip || crc)) {
fprintf(stderr, "No sparse/gzip/crc allowed for block device\n");
return EXIT_FAILURE;
}
if (_mountpoint == NULL) {
mountpoint = strdup("");
} else {
mountpoint = canonicalize_abs_slashes(_mountpoint);
}
if (_directory) {
directory = canonicalize_rel_slashes(_directory);
}
if (_target_out_directory) {
target_out_directory = canonicalize_rel_slashes(_target_out_directory);
}
if (info.len <= 0)
info.len = get_file_size(fd);
if (info.len <= 0) {
fprintf(stderr, "Need size of filesystem\n");
return EXIT_FAILURE;
}
if (info.block_size <= 0)
info.block_size = compute_block_size();
/* Round down the filesystem length to be a multiple of the block size */
info.len &= ~((u64)info.block_size - 1);
if (info.journal_blocks == 0)
info.journal_blocks = compute_journal_blocks();
if (info.no_journal == 0)
info.feat_compat = EXT4_FEATURE_COMPAT_HAS_JOURNAL;
else
info.journal_blocks = 0;
if (info.blocks_per_group <= 0)
info.blocks_per_group = compute_blocks_per_group();
if (info.inodes <= 0)
info.inodes = compute_inodes();
if (info.inode_size <= 0)
info.inode_size = 256;
if (info.label == NULL)
info.label = "";
info.inodes_per_group = compute_inodes_per_group();
info.feat_compat |=
EXT4_FEATURE_COMPAT_RESIZE_INODE |
EXT4_FEATURE_COMPAT_EXT_ATTR;
info.feat_ro_compat |=
EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER |
EXT4_FEATURE_RO_COMPAT_LARGE_FILE |
EXT4_FEATURE_RO_COMPAT_GDT_CSUM;
info.feat_incompat |=
EXT4_FEATURE_INCOMPAT_EXTENTS |
EXT4_FEATURE_INCOMPAT_FILETYPE;
info.bg_desc_reserve_blocks = compute_bg_desc_reserve_blocks();
printf("Creating filesystem with parameters:\n");
printf(" Size: %"PRIu64"\n", info.len);
printf(" Block size: %d\n", info.block_size);
printf(" Blocks per group: %d\n", info.blocks_per_group);
printf(" Inodes per group: %d\n", info.inodes_per_group);
printf(" Inode size: %d\n", info.inode_size);
printf(" Journal blocks: %d\n", info.journal_blocks);
printf(" Label: %s\n", info.label);
ext4_create_fs_aux_info();
printf(" Blocks: %"PRIu64"\n", aux_info.len_blocks);
printf(" Block groups: %d\n", aux_info.groups);
printf(" Reserved block group size: %d\n", info.bg_desc_reserve_blocks);
ext4_sparse_file = sparse_file_new(info.block_size, info.len);
block_allocator_init();
ext4_fill_in_sb(real_uuid);
if (reserve_inodes(0, 10) == EXT4_ALLOCATE_FAILED)
error("failed to reserve first 10 inodes");
if (info.feat_compat & EXT4_FEATURE_COMPAT_HAS_JOURNAL)
ext4_create_journal_inode();
if (info.feat_compat & EXT4_FEATURE_COMPAT_RESIZE_INODE)
ext4_create_resize_inode();
#ifdef USE_MINGW
// Windows needs only 'create an empty fs image' functionality
assert(!directory);
root_inode_num = build_default_directory_structure(mountpoint, sehnd);
#else
if (directory)
root_inode_num = build_directory_structure(directory, mountpoint, target_out_directory, 0,
fs_config_func, sehnd, verbose, fixed_time);
else
root_inode_num = build_default_directory_structure(mountpoint, sehnd);
#endif
root_mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
inode_set_permissions(root_inode_num, root_mode, 0, 0, 0);
#ifndef USE_MINGW
if (sehnd) {
char *secontext = NULL;
if (selabel_lookup(sehnd, &secontext, mountpoint, S_IFDIR) < 0) {
error("cannot lookup security context for %s", mountpoint);
}
if (secontext) {
if (verbose) {
printf("Labeling %s as %s\n", mountpoint, secontext);
}
inode_set_selinux(root_inode_num, secontext);
}
freecon(secontext);
}
#endif
ext4_update_free();
if (block_list_file) {
size_t dirlen = directory ? strlen(directory) : 0;
struct block_allocation* p = get_saved_allocation_chain();
while (p) {
if (directory && strncmp(p->filename, directory, dirlen) == 0) {
// substitute mountpoint for the leading directory in the filename, in the output file
fprintf(block_list_file, "%s%s", mountpoint, p->filename + dirlen);
} else {
fprintf(block_list_file, "%s", p->filename);
}
print_blocks(block_list_file, p);
struct block_allocation* pn = p->next;
free_alloc(p);
p = pn;
}
}
printf("Created filesystem with %d/%d inodes and %d/%d blocks\n",
aux_info.sb->s_inodes_count - aux_info.sb->s_free_inodes_count,
aux_info.sb->s_inodes_count,
aux_info.sb->s_blocks_count_lo - aux_info.sb->s_free_blocks_count_lo,
aux_info.sb->s_blocks_count_lo);
if (wipe && WIPE_IS_SUPPORTED) {
wipe_block_device(fd, info.len);
}
write_ext4_image(fd, gzip, sparse, crc);
sparse_file_destroy(ext4_sparse_file);
ext4_sparse_file = NULL;
free(mountpoint);
free(directory);
return 0;
}
int main(int argc, char *argv[]) {
int i;
bool ast = false;
int g = 0;
int numfps = 0;
int files[argc];
for (i=1; i < argc; i++) {
if (strcmp(argv[i], "--version") == 0) {
printf("stmd %s", VERSION);
printf(" - standard markdown converter (c) 2014 John MacFarlane\n");
exit(0);
} else if ((strcmp(argv[i], "--help") == 0) ||
(strcmp(argv[i], "-h") == 0)) {
print_usage();
exit(0);
} else if (strcmp(argv[i], "--ast") == 0) {
ast = true;
} else if (*argv[i] == '-') {
print_usage();
exit(1);
} else { // treat as file argument
files[g] = i;
g++;
}
}
numfps = g;
bstring s = NULL;
bstring html;
g = 0;
block * cur = make_document();
int linenum = 1;
extern int errno;
FILE * fp = NULL;
if (numfps == 0) {
// read from stdin
while ((s = bgets((bNgetc) fgetc, stdin, '\n'))) {
check(incorporate_line(s, linenum, &cur) == 0,
"error incorporating line %d", linenum);
bdestroy(s);
linenum++;
}
} else {
// iterate over input file pointers
for (g=0; g < numfps; g++) {
fp = fopen(argv[files[g]], "r");
if (fp == NULL) {
fprintf(stderr, "Error opening file %s: %s\n",
argv[files[g]], strerror(errno));
exit(1);
}
while ((s = bgets((bNgetc) fgetc, fp, '\n'))) {
check(incorporate_line(s, linenum, &cur) == 0,
"error incorporating line %d", linenum);
bdestroy(s);
linenum++;
}
fclose(fp);
}
}
while (cur != cur->top) {
finalize(cur, linenum);
cur = cur->parent;
}
check(cur == cur->top, "problems finalizing open containers");
finalize(cur, linenum);
process_inlines(cur, cur->attributes.refmap);
if (ast) {
print_blocks(cur, 0);
} else {
check(blocks_to_html(cur, &html, false) == 0, "could not format as HTML");
printf("%s", html->data);
bdestroy(html);
}
free_blocks(cur);
return 0;
error:
return -1;
}
