Exemple #1
0
/*
void* change_entry(void* entry, int offset, int size)
{
}
*/
void* first_fit(kma_size_t size) 
{
  int min_size = sizeof(entry_t*);
  page_t* first_page = (page_t*)(gpage_entry->ptr);
  entry_t* entry = (entry_t*)(first_page->first);
  if(size < min_size)
    size = min_size;
  while(entry)
    {
       if(size > entry->size)
	{
	  entry = entry->next;
	  continue;
	}
      else if(size >=  entry->size - min_size)
	{
	  delete_entry(entry);
	  return (void*)entry;
	}
      else
	{
	  add_entry((void*)(entry + size), entry->size - size);
	  delete_entry(entry);
	  return (void*)entry;
	}
    }
  kma_page_t* new_page = get_page();
  init_page(new_page);
  return first_fit(size);
}
Exemple #2
0
void
combine_entry(partition_map *entry)
{
    partition_map *p;
    u32 end;

    if (entry == NULL
	    || istrncmp(entry->data->dpme_type, kFreeType, DPISTRLEN) != 0) {
	return;
    }
    if (entry->next_by_base != NULL) {
	p = entry->next_by_base;
	if (istrncmp(p->data->dpme_type, kFreeType, DPISTRLEN) != 0) {
	    // next is not free
	} else if (entry->data->dpme_pblock_start + entry->data->dpme_pblocks
		!= p->data->dpme_pblock_start) {
	    // next is not contiguous (XXX this is bad)
	    printf("next entry is not contiguous\n");
	    // start is already minimum
	    // new end is maximum of two ends
	    end = p->data->dpme_pblock_start + p->data->dpme_pblocks;
	    if (end > entry->data->dpme_pblock_start + entry->data->dpme_pblocks) {
	    	entry->data->dpme_pblocks = end - entry->data->dpme_pblock_start;
	    }
	    entry->data->dpme_lblocks = entry->data->dpme_pblocks;
	    delete_entry(p);
	} else {
	    entry->data->dpme_pblocks += p->data->dpme_pblocks;
	    entry->data->dpme_lblocks = entry->data->dpme_pblocks;
	    delete_entry(p);
	}
    }
    if (entry->prev_by_base != NULL) {
	p = entry->prev_by_base;
	if (istrncmp(p->data->dpme_type, kFreeType, DPISTRLEN) != 0) {
	    // previous is not free
	} else if (p->data->dpme_pblock_start + p->data->dpme_pblocks
		!= entry->data->dpme_pblock_start) {
	    // previous is not contiguous (XXX this is bad)
	    printf("previous entry is not contiguous\n");
	    // new end is maximum of two ends
	    end = p->data->dpme_pblock_start + p->data->dpme_pblocks;
	    if (end < entry->data->dpme_pblock_start + entry->data->dpme_pblocks) {
		end = entry->data->dpme_pblock_start + entry->data->dpme_pblocks;
	    }
	    entry->data->dpme_pblocks = end - p->data->dpme_pblock_start;
	    // new start is previous entry's start
	    entry->data->dpme_pblock_start = p->data->dpme_pblock_start;
	    entry->data->dpme_lblocks = entry->data->dpme_pblocks;
	    delete_entry(p);
	} else {
	    entry->data->dpme_pblock_start = p->data->dpme_pblock_start;
	    entry->data->dpme_pblocks += p->data->dpme_pblocks;
	    entry->data->dpme_lblocks = entry->data->dpme_pblocks;
	    delete_entry(p);
	}
    }
    entry->contains_driver = contains_driver(entry);
}
Exemple #3
0
void CScriptCache::DecrementScriptUsage(uint32 scriptName)
{
	CScriptCacheEntry *p_cache_entry=mp_cache_hash_table->GetItem(scriptName);
	if (p_cache_entry)
	{
		Dbg_MsgAssert(p_cache_entry->mUsage,("Zero cache entry usage for script '%s'",Script::FindChecksumName(scriptName)));
		
		--p_cache_entry->mUsage;
		if (p_cache_entry->mUsage==0)
		{
			#ifdef __NOPT_ASSERT__
			--m_num_used_scripts;
			#endif
			
			if (m_delete_zero_usage_straight_away)
			{
				// For testing
				delete_entry(p_cache_entry);
			}
			else
			{
				add_to_zero_usage_list(p_cache_entry);
			}	
		}
	}
}
/** verify DS matches DNSKEY from a file */
static void
dstest_file(const char* fname)
{
	/* 
	 * The file contains a list of ldns-testpkts entries.
	 * The first entry must be a query for DNSKEY.
	 * The answer rrset is the keyset that will be used for verification
	 */
	struct regional* region = regional_create();
	struct alloc_cache alloc;
	ldns_buffer* buf = ldns_buffer_new(65535);
	struct entry* e;
	struct entry* list = read_datafile(fname);
	struct module_env env;

	if(!list)
		fatal_exit("could not read %s: %s", fname, strerror(errno));
	alloc_init(&alloc, NULL, 1);
	memset(&env, 0, sizeof(env));
	env.scratch = region;
	env.scratch_buffer = buf;
	unit_assert(region && buf);

	/* ready to go! */
	for(e = list; e; e = e->next) {
		dstest_entry(e, &alloc, region, buf, &env);
	}

	delete_entry(list);
	regional_destroy(region);
	alloc_clear(&alloc);
	ldns_buffer_free(buf);
}
int main(int argc, char **argv) {
	if(argc != 3) {
		fprintf(stderr, "Usage: ext2_rm <image file name> <path to file>\n");
		exit(1);
	}
	disk_initialization(argv[1]); /* initialize disk */
	unsigned int dir_inode = inode_from_path(extract_parent_path(argv[2])); /* get inode index from path */

	struct ext2_dir_entry_2 *de = dir_find(dir_inode, extract_filename(argv[2]));
	if (de == NULL) {
		fprintf(stderr, "No such file or directory\n");
		exit(ENOENT);
	}
	unsigned int inode_index = de->inode;

	if (has_file_type(EXT2_INODE_FT_DIR, inode_index)) { 
		fprintf(stderr, "%s: is a directory\n", argv[2]);
		exit(EISDIR);
	}
	else {
		/* remove directory entry associated with file */
		delete_entry(dir_inode, extract_filename(argv[2]));
	}

        return 0;
}
Exemple #6
0
vm_exit_code handle_action_change(int pid, char *action, vm_act_state state)
{
    Graph g;
    char msg[256], *this_state;
    vm_exit_code exit_status;

    peos_context_t *context = peos_get_context(pid);

    this_state = act_state_name(state);
    sprintf(msg, "%s %s %s %d ",login_name, this_state, action, pid);
    log_event(msg);

    g = context -> process_graph;
    if (g == NULL) {
        peos_error("handle_resource_event: process graph is null");
        return VM_INTERNAL_ERROR;
    }

    if ((exit_status =  set_act_state_graph(g, action, state)) == VM_DONE) {
        sprintf(msg,"%s DONE %s %d",login_name, context->model, pid);
        log_event(msg);
        delete_entry(context->pid);
  	return exit_status;
    }
    
    if (exit_status == VM_INTERNAL_ERROR) {  
        return exit_status;
    }
                                                                
    return exit_status;
}
Exemple #7
0
int main() {
 if(count < 3)
  {
  count++; 
  add_entry("Ankit Request","Monday","Cache",true);
  }
 if(count < 3)
  {
   count++;
   add_entry("Gupta Request","Friday","Namaste.txt",true);
  }
    
 cacheEntry * tmp = search_entry("Ankit Request");
 printf("tmp file is %s\n",tmp->filename);
  if(count < 3)
  {
  printf("Added\n");
  count++;
  add_entry("Atish Request","12-12-12","atish.txt",false);
  }
  print_cacheEntry();
  if(count < 4)
  {
   count++;add_entry("amruth Request","11-11-11","atish.txt",false);
  }
  printf("***********NOW DELETE *********************");
  delete_entry();
 print_cacheEntry();  
 printf("****************NOW DELETE AND ADD************************"); 
 updateremoveaddtoHead("Gupta Request","TIME X",false); 
print_cacheEntry();
    return 0;

}
int main(int argc, char** argv, char** envp) {
	int i;
	phone_entry* phonebook;
	phonebook=malloc(sizeof(phone_entry)*MAX_ENTRIES_IN_PHONEBOOK);
	for(i=0; i<MAX_ENTRIES_IN_PHONEBOOK; i++) {
		phone_entry_init(phonebook+i);
		// phone_entry_init(&phonebook[i]);
	}
	while(!over) {
		int selection=show_menu();
		switch(selection) {
		case 1:
			add_entry(phonebook, MAX_ENTRIES_IN_PHONEBOOK);
			break;
		case 2:
			delete_entry(phonebook, MAX_ENTRIES_IN_PHONEBOOK);
			break;
		case 3:
			find_entry(phonebook, MAX_ENTRIES_IN_PHONEBOOK);
			break;
		case 4:
			print_phonebook(phonebook, MAX_ENTRIES_IN_PHONEBOOK);
			break;
		case 5:
			printf("terminating\n");
			over=1;
			break;
		}
	}
	// release the memory
	free(phonebook);
	return EXIT_SUCCESS;
}
Exemple #9
0
static ModeMode run_mode_result ( Mode *sw, int mretv, char **input, unsigned int selected_line )
{
    RunModePrivateData *rmpd = (RunModePrivateData *) sw->private_data;
    ModeMode           retv  = MODE_EXIT;

    gboolean           run_in_term = ( ( mretv & MENU_CUSTOM_ACTION ) == MENU_CUSTOM_ACTION );

    if ( mretv & MENU_NEXT ) {
        retv = NEXT_DIALOG;
    }
    else if ( mretv & MENU_PREVIOUS ) {
        retv = PREVIOUS_DIALOG;
    }
    else if ( mretv & MENU_QUICK_SWITCH ) {
        retv = ( mretv & MENU_LOWER_MASK );
    }
    else if ( ( mretv & MENU_OK ) && rmpd->cmd_list[selected_line] != NULL ) {
        exec_cmd ( rmpd->cmd_list[selected_line], run_in_term );
    }
    else if ( ( mretv & MENU_CUSTOM_INPUT ) && *input != NULL && *input[0] != '\0' ) {
        exec_cmd ( *input, run_in_term );
    }
    else if ( ( mretv & MENU_ENTRY_DELETE ) && rmpd->cmd_list[selected_line] ) {
        delete_entry ( rmpd->cmd_list[selected_line] );

        // Clear the list.
        retv = RELOAD_DIALOG;
        run_mode_destroy ( sw );
        run_mode_init ( sw );
    }
    return retv;
}
Exemple #10
0
void filelist138 :: clear()
{
	//clear every file
	for(unsigned i = 0; i < files.size(); i++)
		delete_entry(files[i]);

	files.clear(); //clear vector
};
Exemple #11
0
/** delete range */
static void
replay_range_delete(struct replay_range* rng)
{
	if(!rng)
		return;
	delete_entry(rng->match);
	free(rng);
}
Exemple #12
0
void BPTree::myDelete(pKey_Attr pPrimKey, _F_FileAddr& pRec) {
	setPath();
	Key_Location KeyLoca;
	if(search(pPrimKey, &KeyLoca)) {
		pRec = getCurRecAddr(KeyLoca);
		delete_entry(KeyLoca.ptr, pPrimKey, pRec);    
	}
	else
		throw 1023;
}
Exemple #13
0
static void ht_delete_entry_chain(const census_ht_option *options,
                                  ht_entry *first) {
  if (first == NULL) {
    return;
  }
  if (first->next != NULL) {
    ht_delete_entry_chain(options, first->next);
  }
  delete_entry(options, first);
}
Exemple #14
0
void	do_unsetenv(char **t, t_env *env)
{
  if (t[1] == NULL)
    return;
  if (my_strcmp_casse(t[1], "*") == 0)
    clean_list(&env->list);
  else
    delete_entry(&env->list, t[1]);
  clean_wordtab(env->environ);
  env->environ = convert_to_tab(env->list);
}
Exemple #15
0
void
atf_list_append_list(atf_list_t *l, atf_list_t *src)
{
    struct list_entry *e1, *e2, *ghost1, *ghost2;

    ghost1 = (struct list_entry *)l->m_end;
    ghost2 = (struct list_entry *)src->m_begin;

    e1 = ghost1->m_prev;
    e2 = ghost2->m_next;

    delete_entry(ghost1);
    delete_entry(ghost2);

    e1->m_next = e2;
    e2->m_prev = e1;

    l->m_end = src->m_end;
    l->m_size += src->m_size;
}
Exemple #16
0
/* Master deletion function.
 */
node * deletee(node * root, int key, int * value) {

  node * key_leaf;
  record * key_record;

  key_record = find(root, key, false, value);
  key_leaf = find_leaf(root, key, false);
  if (key_record != NULL && key_leaf != NULL) {
    root = delete_entry(root, key_leaf, key, key_record);
    free(key_record);
  }
  return root;
}
/* 
 * remove duplicate names in the table - the entries later 
 * in the table are discarded. returns the new size of the
 * table
 */
int str_pairs_remove_duplicates(str_pair *table, int size)
{
	int i, j;

	for(i=0; i < size-1; i++)
		for(j=i+1; j < size; j++)
			if (!strcasecmp(table[i].name, table[j].name)) {
				delete_entry(table, size, j);
				size--;
				j--;
			}
	return size;
}
Exemple #18
0
static imgtoolerr_t rsdos_diskimage_deletefile(imgtool::partition &partition, const char *fname)
{
	imgtoolerr_t err;
	imgtool::image &image(partition.image());
	int pos;
	struct rsdos_dirent ent;

	err = lookup_rsdos_file(image, fname, ent, &pos);
	if (err)
		return err;

	return delete_entry(image, ent, pos);
}
Exemple #19
0
static imgtoolerr_t rsdos_diskimage_deletefile(imgtool_partition *partition, const char *fname)
{
    imgtoolerr_t err;
    imgtool_image *image = imgtool_partition_image(partition);
    int pos;
    struct rsdos_dirent ent;

    err = lookup_rsdos_file(image, fname, &ent, &pos);
    if (err)
        return err;

    return delete_entry(image, &ent, pos);
}
Exemple #20
0
void
combine_entry(partition_map *entry)
{
    partition_map *p;

    if (entry == NULL
	    || strncmp(entry->data->dpme_type, kFreeType, DPISTRLEN) != 0) {
	return;
    }
    if (entry->next_by_base != NULL) {
	p = entry->next_by_base;
	if (strncmp(p->data->dpme_type, kFreeType, DPISTRLEN) != 0) {
	    // next is not free
	} else if (entry->data->dpme_pblock_start + entry->data->dpme_pblocks
		!= p->data->dpme_pblock_start) {
	    // next is not contiguous (XXX this is bad)
	} else {
	    entry->data->dpme_pblocks += p->data->dpme_pblocks;
	    entry->data->dpme_lblocks = entry->data->dpme_pblocks;
	    delete_entry(p);
	}
    }
    if (entry->prev_by_base != NULL) {
	p = entry->prev_by_base;
	if (strncmp(p->data->dpme_type, kFreeType, DPISTRLEN) != 0) {
	    // previous is not free
	} else if (p->data->dpme_pblock_start + p->data->dpme_pblocks
		!= entry->data->dpme_pblock_start) {
	    // previous is not contiguous (XXX this is bad)
	} else {
	    entry->data->dpme_pblock_start = p->data->dpme_pblock_start;
	    entry->data->dpme_pblocks += p->data->dpme_pblocks;
	    entry->data->dpme_lblocks = entry->data->dpme_pblocks;
	    delete_entry(p);
	}
    }
    entry->contains_driver = contains_driver(entry);
}
Exemple #21
0
/** delete moment */
static void
replay_moment_delete(struct replay_moment* mom)
{
	if(!mom)
		return;
	if(mom->match) {
		delete_entry(mom->match);
	}
	free(mom->autotrust_id);
	free(mom->string);
	free(mom->variable);
	config_delstrlist(mom->file_content);
	free(mom);
}
Exemple #22
0
void stop_middleware_frontend(int sock) {

  if (myname[0] == '\0') {
    debug_out(2, "Not registered!\n");
    exit(1);
  }

  if (!delete_entry(NSDB, myname)) {
    debug_out(2, "Failed to delete data from nameserver\n");
    exit(1);
  }

  myname[0] = '\0';
  close(sock);
}
Exemple #23
0
STATUS free_entries_and_head(entry *entry_head)
{
	if(!entry_head)
	{
		DEBUG("free_entries_and_head-> !entry_head, OK\n");
		return OK;
	}
	STATUS free_entries_status = free_entries_from_head(entry_head);
	if(free_entries_status != OK)
	{
		DEBUG("free_entries_and_head->free_entries_status !OK\n");
		return free_entries_status;
	}
	return delete_entry(entry_head);
}
Exemple #24
0
int filelist138 :: delete_file(const char * path, int COMPARE_NAME)
{
	//search for file in the filelist
	int find = find_file(path, COMPARE_NAME);

	if(find >= 0)
	{
		//delete
		delete_entry(files[find]);
		files.erase(files.begin() + find);
		return 1;
	};
	
	return 0;
};
Exemple #25
0
// The scriptName is only passed so that the assert can print the name of the script
// if no space could be freed up for it.
void CScriptCache::remove_some_old_scripts(int space_required, uint32 scriptName)
{
	while (true)
	{
		int largest_malloc_possible=Mem::Manager::sHandle().ScriptHeap()->LargestFreeBlock();
		largest_malloc_possible-=128; // Actually, 32 seems OK, but have a bigger margin just to be sure.
		
		if (space_required <= largest_malloc_possible)
		{
			// Hurrah! It's all clear to decompress another script since we know there is enough heap to hold it.
			
			// Try to keep the total number of decompressed scripts within IDEAL_MAX_DECOMPRESSED_SCRIPTS
			// by removing unused ones until either enough have been removed or there are no more to remove.
			
			// This way the average memory usage can be controlled by tweaking IDEAL_MAX_DECOMPRESSED_SCRIPTS
			// whilst spikes in the number of scripts are still permitted up to the limit set by
			// the pool size of MAX_DECOMPRESSED_SCRIPTS. If that limit is reached, the code will assert.
			while (CScriptCacheEntry::SGetNumUsedItems() >= IDEAL_MAX_DECOMPRESSED_SCRIPTS && mp_last_zero_usage)
			{
				delete_entry(mp_last_zero_usage);
			}	
			break;
		}	

		// Free up some space by deleting the oldest zero-usage decompressed script.
		
		if (!mp_last_zero_usage)
		{
			// Eeeek! There's nothing left to delete ...
			Dbg_MsgAssert(0,("Script heap overflow when trying to allocate decompressed script '%s' of size %d bytes!",Script::FindChecksumName(scriptName),space_required));
		}
		
		//printf("%d: Deleting %s from cache, new free space = %d\n",space_required,Script::FindChecksumName(mp_last_zero_usage->mScriptNameChecksum),Mem::Manager::sHandle().ScriptHeap()->LargestFreeBlock()-128);
		delete_entry(mp_last_zero_usage);
	}	
}
Exemple #26
0
void
delete_partition_from_map(partition_map *entry)
{
    partition_map_header *map;
    DPME *data;

    if (istrncmp(entry->data->dpme_type, kMapType, DPISTRLEN) == 0) {
	printf("Can't delete entry for the map itself\n");
	return;
    }
    if (entry->contains_driver) {
	printf("This program can't install drivers\n");
	if (get_okay("are you sure you want to delete this driver? [n/y]: ", 0) != 1) {
	    return;
	}
    }
    // if past end of disk, delete it completely
    if (entry->next_by_base == NULL &&
	entry->data->dpme_pblock_start >= entry->the_map->media_size) {
      if (entry->contains_driver) {
	remove_driver(entry);	// update block0 if necessary
      }
      delete_entry(entry);
      return;
    }
    // If at end of disk, incorporate extra disk space to partition
    if (entry->next_by_base == NULL) {
      entry->data->dpme_pblocks =
	 entry->the_map->media_size - entry->data->dpme_pblock_start;
    }
    data = create_data(kFreeName, kFreeType,
	    entry->data->dpme_pblock_start, entry->data->dpme_pblocks);
    if (data == NULL) {
	return;
    }
    if (entry->contains_driver) {
    	remove_driver(entry);	// update block0 if necessary
    }
    free(entry->data);
    free(entry->HFS_name);
    entry->HFS_kind = kHFS_not;
    entry->HFS_name = 0;
    entry->data = data;
    combine_entry(entry);
    map = entry->the_map;
    renumber_disk_addresses(map);
    map->changed = 1;
}
Exemple #27
0
STATUS free_entries_from_head(entry *entry_head)
{
	entry *cursor = entry_head->next;
	while(cursor)
	{
		entry_head = cursor;
		cursor = cursor->next;
		STATUS delete_status = delete_entry(entry_head);
		if(delete_status != OK)
		{
			DEBUG("free_entries_from_head->delete_status !OK\n");
			return delete_status;
		}
	}
	DEBUG("free_entries_from_head-> OK\n");
	return OK;
}
Exemple #28
0
STATUS delete_entry_by_key(char *key, entry *entry_head)
{
	entry *entry_ptr = find_entry_by_key(key, entry_head);
	if(!entry_ptr)
	{
		DEBUG("delete_entry_by_key-> !entry_ptr NO_KEY\n");
		return NO_KEY;
	}
	STATUS delete_entry_status = delete_entry(entry_ptr);
	if(delete_entry_status != OK)
	{
		DEBUG("delete_entry_by_key->delete_entry_status !OK\n");
		return delete_entry_status;
	}
		DEBUG("delete_entry_by_key-> OK\n");
	return OK;
}
Exemple #29
0
// Needed for when a script is qbr'd.
void CScriptCache::RefreshAfterReload(uint32 scriptName)
{
	CScriptCacheEntry *p_cache_entry=mp_cache_hash_table->GetItem(scriptName);
	if (p_cache_entry)
	{
		// Store the old usage
		uint32 old_usage=p_cache_entry->mUsage;
		
		// Remove from the cache, then add it again so that it is up to date.
		delete_entry(p_cache_entry);
		GetScript(scriptName);
		
		// Put the usage value back.
		p_cache_entry=mp_cache_hash_table->GetItem(scriptName);
		Dbg_MsgAssert(p_cache_entry,("NULL p_cache_entry ?"));
		p_cache_entry->mUsage=old_usage;
	}	
}
Exemple #30
0
/*******************************************************************
*   Adds entry to ARP Cache if not already in Cache. Also deletes any entries that are past 
*   their expiration time.
*******************************************************************/
void add_cache_entry(struct packet_state* ps,const uint32_t ip, const unsigned char* mac)
{
	if(search_cache(ps, ip)==NULL) /*Entry is not already in cache so add. */
	{
        struct arp_cache_entry* cache_walker=0;
    
        assert(ps);
        assert(mac);
        assert(ip);
    
        if(ps->sr->arp_cache ==0)	/*If there are no entries in cache */
        {
            ps->sr->arp_cache=(struct arp_cache_entry*)malloc(sizeof(struct arp_cache_entry));
            assert(ps->sr->arp_cache);
            ps->sr->arp_cache->next=0;
            ps->sr->arp_cache->ip_add=ip;
            memmove(ps->sr->arp_cache->mac, mac,ETHER_ADDR_LEN);
            ps->sr->arp_cache->timenotvalid=time(NULL) +ARP_TIMEOUT;
        }
        else
        {
            cache_walker = ps->sr->arp_cache;
            while(cache_walker->next)
            {
                if(cache_walker->timenotvalid < time(NULL))
                {
                    cache_walker = delete_entry(ps,cache_walker);
                }
                else
                {
               		cache_walker=cache_walker->next;
               	}	
            }
            cache_walker->next=(struct arp_cache_entry*)malloc(sizeof(struct arp_cache_entry));
            assert(cache_walker->next);
            cache_walker=cache_walker->next;
            cache_walker->ip_add=ip;
            memmove(cache_walker->mac, mac,ETHER_ADDR_LEN);
            cache_walker->timenotvalid=time(NULL) +ARP_TIMEOUT;
            cache_walker->next=0;
        }
	}

}