void bin_index_t::file_node::remove_oldest()
{
for(page_wptr wp=last_page;pages.size()>=max_pages&&!wp.expired();)
{
page_ptr r;
page_ptr l;
{
page_ptr p=wp.lock();
r=p->right.lock();
l=p->left.lock();
flush_page(*p);
pages.erase(p->page_offset);
remove_from_list(p);
}
//Somebody still use this page and we can't delete it
if(!wp.expired())
{
page_ptr p=wp.lock();
pages[p->page_offset]=p;
insert_into_list(p,r);
}
wp=l;
}
}
void bin_index_t::file_node::add_page(const page_ptr& p)
{
pages[p->page_offset]=p;
insert_into_list(p,first_page.lock());
remove_oldest();
}
int handle_file(t_gen *gen, t_elem *elem)
{
if (gen->opts[get_pos_strchr(OPTIONS, 'B')]
&& get_file_ending_with_tild(elem));
else if (!gen->opts[get_pos_strchr(OPTIONS, 'd')] && !gen->opts[get_pos_strchr(OPTIONS, 'a')]
&& !gen->opts[get_pos_strchr(OPTIONS, 'A')]
&& elem->name[0] == '.');
else if (!gen->opts[get_pos_strchr(OPTIONS, 'd')] && !gen->opts[get_pos_strchr(OPTIONS, 'a')]
&& gen->opts[get_pos_strchr(OPTIONS, 'A')]
&& (!my_strcmp(elem->name, ".") || !my_strcmp(elem->name, "..")));
else
{
gen->elem = insert_into_list(elem, gen->elem, gen->opts);
return (1);
}
return (0);
}
local_ent *get_local_list(){
struct hwa_info *hwa,*hwahead;
struct sockaddr *sa;
local_ent *root=NULL;
local_ent curr;
for(hwahead=hwa=Get_hw_addrs();hwa!=NULL;hwa=hwa->hwa_next){
if(strcmp(hwa->if_name,"eth0")==0){
if((sa=hwa->ip_addr)!=NULL){
char *temp=Sock_ntop_host(sa,sizeof(*sa));
strncpy(curr.ip_info.ip,temp,INET_ADDRSTRLEN);
}
memcpy(curr.ip_info.hw_addr,hwa->if_haddr,HADDR_SIZE);
root=insert_into_list(root,&curr);
}
}
free_hwa_info(hwahead);
return root;
}
int main()
{
list_element* root = create_new_element(-1);
list_element* new_elem;
int i;
for(i = 0; i < 10; i++) {
new_elem = create_new_element(i);
insert_into_list(new_elem, root);
}
print_list(root);
int value = 10;
if( search_by_value(root, value) == 0 ) {
printf("Value %d exists in the list\n", value);
} else {
printf("There is no value %d in the list\n", value);
}
return 0;
}
bin_index_t::page_ptr bin_index_t::file_node::get_page(file_offset_t page_offset)
{
pages_t::iterator it=pages.find(page_offset);
if(it!=pages.end())
{
page_ptr p=it->second;
if(!p->left.expired())
{
remove_from_list(p);
insert_into_list(p,first_page.lock());
}
return p;
}
page_ptr p(create_page());
p->self=p;
p->page_offset=page_offset;
load_page(*p);
add_page(p);
return p;
}
/*Recieves the client request and addes it to the queue
* Input:
* int client_fd : specifies the connection identifier
* */
void server_response (int client_fd, thread_pool_t *pool_obj, C_Request* c_request)
{
char* buffer;
char* data;
int len = 0;
int ret = 0;
long res = 0;
int buf_ptr = 0;
buffer = (char*) calloc (1,1024);
ret = read (client_fd, buffer, 1024);
printf ("Recieved bytes %d\n", ret);
if(ret > 0)
{
/* Read the footer. */
memcpy (&res, (buffer + (ret - sizeof (int)) ), sizeof (int));
/* Checking the message is valid or not .*/
if (res != 0xbaadf00d) {
goto out;
}
/* Read the length of the message */
memcpy (&len, buffer, sizeof (int));
buf_ptr += sizeof (int);
/* If valid message read the type of the request. */
memcpy (&res, buffer + buf_ptr, sizeof (int));
buf_ptr += sizeof (int);
switch (res)
{
case file_request:
/* Process the file request */
c_request -> type = file_request;
c_request -> buf = (char*) calloc (1, ret - buf_ptr);
memcpy (c_request -> buf, buffer + buf_ptr,
ret - buf_ptr) ;
c_request -> client_fd = client_fd;
c_request -> operation = (void*) file_handler;
break;
case write_request:
/* Process the write request */
c_request -> type = write_request;
c_request -> buf = buffer;
c_request -> client_fd = client_fd;
c_request -> operation = (void*) write_handler;
break;
case open_file_request:
/* Process the open_file_request */
c_request -> type = open_file_request;
c_request -> buf = (char*) calloc (1, ret - buf_ptr);
memcpy (c_request -> buf, buffer + buf_ptr,
ret - buf_ptr) ;
c_request -> client_fd = client_fd;
c_request -> operation = (void*) open_file_handler;
break;
case close_file_request:
/* Process the close file request */
c_request -> type = close_file_request;
c_request -> buf = (char*) calloc (1, ret - buf_ptr);
memcpy (c_request -> buf, buffer + buf_ptr,
ret - buf_ptr);
c_request -> client_fd = client_fd;
c_request -> operation = (void*) close_file_handler;
break;
case read_in_chunks:
/* Process the read in chunks from the file
* and send it back to the client */
c_request -> type = read_in_chunks;
c_request -> buf = (char*) calloc (1, ret - buf_ptr);
memcpy (c_request -> buf, buffer + buf_ptr,
ret - buf_ptr);
c_request -> client_fd = client_fd;
c_request -> operation = (void*) read_chunks_handler;
break;
}
/* Check whether the list is full or not
* if list is full then send feedback to client that
* client is full otherwise the request is added to the
* queue
* */
data_read:
if (list_full (pool -> list) == 1)
{
/* Clears the buffer */
memset (buffer, 0, 1024);
res = 0;
/* Gives the length of the response. */
len = calc_response_queue_full ();
/* Allocate the memory */
buffer = (char*) calloc (1, len + 4);
/* Copy the length of the request. */
memcpy (buffer, &len, sizeof (int));
res += sizeof (int);
/*Copy the type of the response */
len = fail_response;
memcpy (buffer + res, &len, sizeof (int));
res += sizeof (int);
/* Copy the response */
len = queue_ful;
memcpy (buffer + res, &len, sizeof (int));
res +=sizeof (int);
/* Send the response to the client */
ret = write (client_fd, data, res);
if (ret < 0)
{
printf ("\tSome error ocurred\n");
goto data_read;
}
goto out;
}
/*Calls the function to add the client_request to the
* list */
pool_obj -> list -> first_node = insert_into_list
(pool_obj -> list, c_request);
printf ("\tClient : %d's request is inserted\n", client_fd);
pthread_mutex_lock (& (pool_obj -> q_lock));
pthread_cond_broadcast (& pool_obj -> cond_t);
pthread_mutex_unlock (& (pool_obj -> q_lock));
}
out:
return ;
}
/*
* Enable memory and I/O on pci devices. Care about already enabled devices
* (probabaly by the console driver).
*
* The idea behind the following code is:
* We build a by sizes sorted list of the requirements of the different
* pci devices. After that we choose the start addresses of that areas
* in such a way that they are placed as closed as possible together.
*/
static void
enable_pci_devices(void)
{
PCI_MEMREG memlist;
PCI_MEMREG iolist;
struct pci_memreg *p, *q;
int dev, reg, id, class;
pcitag_t tag;
pcireg_t csr, address, mask;
pci_chipset_tag_t pc;
int sizecnt, membase_1m;
pc = 0;
csr = 0;
tag = 0;
LIST_INIT(&memlist);
LIST_INIT(&iolist);
/*
* first step: go through all devices and gather memory and I/O
* sizes
*/
for (dev = 0; dev < pci_bus_maxdevs(pc,0); dev++) {
tag = pci_make_tag(pc, 0, dev, 0);
id = pci_conf_read(pc, tag, PCI_ID_REG);
if (id == 0 || id == 0xffffffff)
continue;
csr = pci_conf_read(pc, tag, PCI_COMMAND_STATUS_REG);
/*
* special case: if a display card is found and memory is enabled
* preserve 128k at 0xa0000 as vga memory.
* XXX: if a display card is found without being enabled, leave
* it alone! You will usually only create conflicts by enabeling
* it.
*/
class = pci_conf_read(pc, tag, PCI_CLASS_REG);
switch (PCI_CLASS(class)) {
case PCI_CLASS_PREHISTORIC:
case PCI_CLASS_DISPLAY:
if (csr & (PCI_COMMAND_MEM_ENABLE | PCI_COMMAND_MASTER_ENABLE)) {
p = (struct pci_memreg *)malloc(sizeof(struct pci_memreg),
M_TEMP, M_WAITOK);
memset(p, '\0', sizeof(struct pci_memreg));
p->dev = dev;
p->csr = csr;
p->tag = tag;
p->reg = 0; /* there is no register about this */
p->size = 0x20000; /* 128kByte */
p->mask = 0xfffe0000;
p->address = 0xa0000;
insert_into_list(&memlist, p);
}
else continue;
}
for (reg = PCI_MAPREG_START; reg < PCI_MAPREG_END; reg += 4) {
address = pci_conf_read(pc, tag, reg);
pci_conf_write(pc, tag, reg, 0xffffffff);
mask = pci_conf_read(pc, tag, reg);
pci_conf_write(pc, tag, reg, address);
if (mask == 0)
continue; /* Register unused */
p = (struct pci_memreg *)malloc(sizeof(struct pci_memreg),
M_TEMP, M_WAITOK);
memset(p, '\0', sizeof(struct pci_memreg));
p->dev = dev;
p->csr = csr;
p->tag = tag;
p->reg = reg;
p->mask = mask;
p->address = 0;
if (mask & PCI_MAPREG_TYPE_IO) {
p->size = PCI_MAPREG_IO_SIZE(mask);
/*
* Align IO if necessary
*/
if (p->size < PCI_MAPREG_IO_SIZE(PCI_MACHDEP_IO_ALIGN_MASK)) {
p->mask = PCI_MACHDEP_IO_ALIGN_MASK;
p->size = PCI_MAPREG_IO_SIZE(p->mask);
}
/*
* if I/O is already enabled (probably by the console driver)
* save the address in order to take care about it later.
*/
if (csr & PCI_COMMAND_IO_ENABLE)
p->address = address;
insert_into_list(&iolist, p);
} else {
p->size = PCI_MAPREG_MEM_SIZE(mask);
/*
* Align memory if necessary
*/
if (p->size < PCI_MAPREG_IO_SIZE(PCI_MACHDEP_MEM_ALIGN_MASK)) {
p->mask = PCI_MACHDEP_MEM_ALIGN_MASK;
p->size = PCI_MAPREG_MEM_SIZE(p->mask);
}
/*
* if memory is already enabled (probably by the console driver)
* save the address in order to take care about it later.
*/
if (csr & PCI_COMMAND_MEM_ENABLE)
p->address = address;
insert_into_list(&memlist, p);
if (PCI_MAPREG_MEM_TYPE(mask) == PCI_MAPREG_MEM_TYPE_64BIT)
reg++;
}
}
#if defined(_ATARIHW_)
/*
* Both interrupt pin & line are set to the device (== slot)
* number. This makes sense on the atari Hades because the
* individual slots are hard-wired to a specific MFP-pin.
*/
csr = (DEV2SLOT(dev) << PCI_INTERRUPT_PIN_SHIFT);
csr |= (DEV2SLOT(dev) << PCI_INTERRUPT_LINE_SHIFT);
pci_conf_write(pc, tag, PCI_INTERRUPT_REG, csr);
#else
/*
* On the Milan, we accept the BIOS's choice.
*/
#endif
}
/*
* second step: calculate the memory and I/O addresses beginning from
* PCI_MEM_START and PCI_IO_START. Care about already mapped areas.
*
* begin with memory list
*/
address = PCI_MEM_START;
sizecnt = 0;
membase_1m = 0;
p = LIST_FIRST(&memlist);
while (p != NULL) {
if (!(p->csr & PCI_COMMAND_MEM_ENABLE)) {
if (PCI_MAPREG_MEM_TYPE(p->mask) == PCI_MAPREG_MEM_TYPE_32BIT_1M) {
if (p->size > membase_1m)
membase_1m = p->size;
do {
p->address = membase_1m;
membase_1m += p->size;
} while (overlap_pci_areas(LIST_FIRST(&memlist), p, p->address,
p->size, PCI_COMMAND_MEM_ENABLE));
if (membase_1m > 0x00100000) {
/*
* Should we panic here?
*/
printf("\npcibus0: dev %d reg %d: memory not configured",
p->dev, p->reg);
p->reg = 0;
}
} else {
if (sizecnt && (p->size > sizecnt))
sizecnt = ((p->size + sizecnt) & p->mask) &
PCI_MAPREG_MEM_ADDR_MASK;
if (sizecnt > address) {
address = sizecnt;
sizecnt = 0;
}
do {
p->address = address + sizecnt;
sizecnt += p->size;
} while (overlap_pci_areas(LIST_FIRST(&memlist), p, p->address,
p->size, PCI_COMMAND_MEM_ENABLE));
if ((address + sizecnt) > PCI_MEM_END) {
/*
* Should we panic here?
*/
printf("\npcibus0: dev %d reg %d: memory not configured",
p->dev, p->reg);
p->reg = 0;
}
}
if (p->reg > 0) {
pci_conf_write(pc, p->tag, p->reg, p->address);
csr = pci_conf_read(pc, p->tag, PCI_COMMAND_STATUS_REG);
csr |= PCI_COMMAND_MEM_ENABLE | PCI_COMMAND_MASTER_ENABLE;
pci_conf_write(pc, p->tag, PCI_COMMAND_STATUS_REG, csr);
p->csr = csr;
}
}
p = LIST_NEXT(p, link);
}
/*
* now the I/O list
*/
address = PCI_IO_START;
sizecnt = 0;
p = LIST_FIRST(&iolist);
while (p != NULL) {
if (!(p->csr & PCI_COMMAND_IO_ENABLE)) {
if (sizecnt && (p->size > sizecnt))
sizecnt = ((p->size + sizecnt) & p->mask) &
PCI_MAPREG_IO_ADDR_MASK;
if (sizecnt > address) {
address = sizecnt;
sizecnt = 0;
}
do {
p->address = address + sizecnt;
sizecnt += p->size;
} while (overlap_pci_areas(LIST_FIRST(&iolist), p, p->address,
p->size, PCI_COMMAND_IO_ENABLE));
if ((address + sizecnt) > PCI_IO_END) {
/*
* Should we panic here?
*/
printf("\npcibus0: dev %d reg %d: io not configured",
p->dev, p->reg);
} else {
pci_conf_write(pc, p->tag, p->reg, p->address);
csr = pci_conf_read(pc, p->tag, PCI_COMMAND_STATUS_REG);
csr |= PCI_COMMAND_IO_ENABLE | PCI_COMMAND_MASTER_ENABLE;
pci_conf_write(pc, p->tag, PCI_COMMAND_STATUS_REG, csr);
p->csr = csr;
}
}
p = LIST_NEXT(p, link);
}
#ifdef DEBUG_PCI_MACHDEP
printf("\nI/O List:\n");
p = LIST_FIRST(&iolist);
while (p != NULL) {
printf("\ndev: %d, reg: 0x%02x, size: 0x%08x, addr: 0x%08x", p->dev,
p->reg, p->size, p->address);
p = LIST_NEXT(p, link);
}
printf("\nMemlist:");
p = LIST_FIRST(&memlist);
while (p != NULL) {
printf("\ndev: %d, reg: 0x%02x, size: 0x%08x, addr: 0x%08x", p->dev,
p->reg, p->size, p->address);
p = LIST_NEXT(p, link);
}
#endif
/*
* Free the lists
*/
p = LIST_FIRST(&iolist);
while (p != NULL) {
q = p;
LIST_REMOVE(q, link);
free(p, M_WAITOK);
p = LIST_FIRST(&iolist);
}
p = LIST_FIRST(&memlist);
while (p != NULL) {
q = p;
LIST_REMOVE(q, link);
free(p, M_WAITOK);
p = LIST_FIRST(&memlist);
}
}
