void print_help(){
printf("\n");
print_info();
printf("\n\n\n");
print_argument();
printf("\n\n\n");
print_examples();
printf("\n\n\n");
print_ouput_info();
printf("\n\n\n");
if( ! FIXAGE_MODE)
print_table_info();
printf("\n");
exit(99);
}
int main(int argc, char* argv[]) {
void * mem = open_table_head("/var/run/30m2k.shm", 'i');
printf("--- --- --- INFO --- --- ---\n");
print_table_info(mem);
printf("--- --- --- TEST --- --- ---\n");
test_all(mem);
if (argc > 1) {
printf("--- --- --- DATA --- --- ---\n");
print_item(mem, atoi(argv[1]));
}
printf("--- --- --- ---- --- --- ---\n");
if (mem != (void *) -1) {
close_table(mem);
}
return EXIT_SUCCESS;
}
/* Writes SIZE bytes from BUFFER into INODE, starting at OFFSET.
Returns the number of bytes actually written, which may be
less than SIZE if end of file is reached or an error occurs.
(Normally a write at end of file would extend the inode, but
growth is not yet implemented.) */
off_t
inode_write_at (struct inode *inode, const void *buffer_, off_t size,
off_t offset)
{
const uint8_t *buffer = buffer_;
off_t bytes_written = 0;
uint8_t *bounce = NULL;
/* Debugging */
bool debug = false;
if (inode->deny_write_cnt)
return 0;
//printf("inode_length : %d\n",inode_length(inode));
ASSERT(inode->sector <20000);
//printf("*node[%d]->extension=%d \n", inode->sector, inode->extension);
while(inode->extension);
//printf("inode_write_at called size: %d, offset : %d, inode_length : %d\n",size,offset,inode->data.length);
while (size > 0)
{
/* Sector to write, starting byte offset within sector. */
block_sector_t sector_idx = byte_to_sector (inode, offset);
int sector_ofs = offset % BLOCK_SECTOR_SIZE;
/* Bytes left in inode, bytes left in sector, lesser of the two. */
off_t inode_left = inode_length (inode) - offset;
int sector_left = BLOCK_SECTOR_SIZE - sector_ofs;
int min_left = inode_left < sector_left ? inode_left : sector_left;
/* Number of bytes to actually write into this sector. */
int chunk_size = size < min_left ? size : min_left;
struct cache * cache = find_cache(sector_idx);
//if(debug) printf("sector_idx : %d\n",sector_idx);
if(offset > inode_length(inode))
{
//printf("setting node[%d]->extension=true \n", inode->sector);
inode->extension = true;
//printf("You made me true\n");
int left = (offset - inode_length(inode));
int i;
int sectors = (left+1)/BLOCK_SECTOR_SIZE;
//printf("Offset Over\n");
block_sector_t new_sector;
int check = inode_length(inode) + BLOCK_SECTOR_SIZE - inode_length(inode)%512+1;
inode->data.length += left;
block_write(fs_device,inode->sector,&(inode->data));
//printf("offset inode length increase from :%d to %d sector num : %d check : %d\n",inode_length(inode),inode_length(inode)-left,sectors,check);
for(i=0; i<sectors; i++)
{
//printf("check is : %d\n",check);
if(!free_map_allocate(1,&new_sector))
{
printf("Fail to allocate freemap\n");
ASSERT(false);
}
updateBlock(inode,check,new_sector);
//printf("Allocate new Sector : %d\n",new_sector);
check += BLOCK_SECTOR_SIZE;
}
//debug = true;
continue;
}
else if((size >= inode_left - offset) && min_left == 0)
{
int sector_num;
int i;
//printf("Size Over\n");
if((size-sector_left+1) <=0)
sector_num = 0;
else
sector_num = bytes_to_sectors((size-sector_left)+1);
//printf("size : %d , offset : %d, sector_left : %d\n",size,offset,sector_left);
block_sector_t new_sector;
int check = inode_length(inode) + sector_left ;
//printf("setting node[%d]->extension=true \n", inode->sector);
inode->extension = true;
//printf("You made me true\n");
//file_extension(inode,buffer+bytes_written,size);
inode->data.length = inode->data.length + size;
block_write(fs_device,inode->sector,&(inode->data));
//printf("Sector_left : %d\n",sector_left);
//printf("size inode length increase from :%d to %d now sector num : %d sector_num : %d\n",inode_length(inode),inode_length(inode)-size,sector_idx,sector_num);
for(i=0; i<sector_num; i++)
{
if(!free_map_allocate(1,&new_sector))
{
printf("Freemap Fail\n");
ASSERT(false);
}
updateBlock(inode,check,new_sector);
//printf("Allocate new Sector : %d\n",new_sector);
// print_table_info(inode);
check +=BLOCK_SECTOR_SIZE;
}
debug = true;
continue;
}
else if(sector_idx == -1)
{
print_table_info(inode);
//printf("offset : %d inode : %#x inode_sector : %d length : %d\n",offset,inode,inode->sector,inode_length(inode));
}
if(debug)
{
}
//ASSERT(sector_idx < 20000);
if (chunk_size <= 0)
break;
/*
if(debug)
{
print_table_info(inode);
}
*/
//printf("inode read at called chunksize : %d , sector_ofs : %d, sector_idx : %d\n",chunk_size,sector_ofs,sector_idx);
if(cache == NULL)
{
cache = add_cache(sector_idx);
if(cache == NULL)
{
print_table_info(inode);
printf("read Error\n");
return bytes_written;
}
}
cache->accessed = true;
cache->pin = true;
//if(inode_left - sector_ofs > 512)
// read_ahead(sector_idx +1);
write_cache(cache , buffer+bytes_written , sector_ofs ,chunk_size);
/* Advance. */
cache->pin = false;
size -= chunk_size;
offset += chunk_size;
bytes_written += chunk_size;
} // free (bounce);
if(inode->extension == true)
{
//printf("set node[%d]->extension as false\n", inode->sector);
inode->extension = false;
ASSERT(inode->extension==false);
}
return bytes_written;
}
int main(void)
{
t_table *table = table_init(128);
if (table == NULL) {
fprintf(stderr, "Table could not be initialized!\n");
return EXIT_FAILURE;
}
print_table_info(table);
print_table(table);
int data_pole[NUM] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
t_string key_pole[NUM];
int i;
for (i = 0; i < NUM; i++) {
stringInit(&key_pole[i]);
}
for (i = 0; i < NUM; i++) {
stringAddChar(&key_pole[i], 'a' + i);
}
int ret = 0;
t_tab_data * data_ptr;
for (i = 0; i < NUM; i++) {
ret = table_insert(table, &key_pole[i], &data_ptr);
switch (ret) {
case TAB_INSERT_OK:
data_ptr->a = data_pole[i];
break;
case TAB_INSERT_FOUND:
fprintf(stderr, "Item already inserted\n");
break;
case TAB_INSERT_ALL_ERR:
fprintf(stderr, "Allocation error\n");
break;
}
}
print_table_info(table);
print_table(table);
/*
//1. raz
printf("INSERT\n\n");
for (i = 0; i < NUM; i++) {
ret = table_insert(table, key_pole[i], 7, (t_tab_data **) &data);
switch (ret) {
case TAB_INSERT_FAIL:
fprintf(stderr, "Item already inserted.\n");
break;
case TAB_INSERT_FULL:
while (ret == TAB_INSERT_FULL) {
if (table_resize(table) == TAB_RESIZE_FAIL) {
fprintf(stderr, "RESIZE FAIL\n");
table_destroy(table);
return EXIT_FAILURE;
}
ret = table_insert(table, key_pole[i], 7, (t_tab_data **)&data);
}
if (ret == TAB_INSERT_FAIL) {
fprintf(stderr, "Item already inserted.\n");
break;
}
if (ret == TAB_INSERT_ALL_ERR) {
fprintf(stderr, "ALLOC ERR\n");
table_destroy(table);
return EXIT_FAILURE;
}
*(int *)data = data_pole[i];
break;
case TAB_INSERT_OK:
*(int *)data = data_pole[i];
break;
case TAB_INSERT_ALL_ERR:
fprintf(stderr, "ALLOC ERROR\n");
table_destroy(table);
return EXIT_FAILURE;
}
}
print_table(table);
*/
printf("-----------------------------------------------------------------------------------------\n\n");
printf("GET DATA\n\n");
for (i = 0; i < NUM; i++) {
ret = table_search(table, &key_pole[i], (t_tab_data **) &data_ptr);
if (ret == TAB_SEARCH_OK) {
printf("Key: %s\n", key_pole[i].string);
printf("Data: %d\n\n", data_ptr == NULL ? -1 : ((t_tab_data *)data_ptr)->a);
}
}
/*
print_table(table);
*/
for (i = 0; i < NUM; i++) {
stringFree(&key_pole[i]);
}
table_destroy(table);
return EXIT_SUCCESS;
}
