/* * Add a given buffer by copy to the end of a list * Careful buffer is passed by reference, * and must be free with list_free() */ void list_add_by_copy(list * l, buffer * value) { list_node *ln; buffer *tmp; assert(l); assert(value); assert(l->size < UINT_MAX); ln = list_node_init(); tmp = buffer_init(); buffer_copy(tmp, value); ln->value = tmp; if (!l->first) { ln->prev = NULL; l->first = ln; } else { ln->prev = l->last; l->last->next = ln; } l->last = ln; l->last->next = NULL; l->size++; }
/* * Add a given buffer to the end of a list * Careful buffer is passed by reference, * and must be free with list_free() */ void list_add_str(list * l, char *value) { list_node *ln; assert(l); assert(value); assert(l->size < UINT_MAX); ln = list_node_init(); ln->value = buffer_init(); buffer_add_str(ln->value, value); if (!l->first) { ln->prev = NULL; l->first = ln; } else { ln->prev = l->last; l->last->next = ln; } l->last = ln; l->last->next = NULL; l->size++; }
/* * Add a given list to the end of a list * Careful list is passed by reference, * and must be free with list_free() */ void list_add_list(list * l, list * l_to_add) { list_node *ln, *ln_parse; assert(l); assert(l_to_add); for (ln_parse = l_to_add->first ; ln_parse ; ln_parse = ln_parse->next) { if (!in_list(l, ln_parse->value)) { ln = list_node_init(); ln->value = buffer_init(); buffer_copy(ln->value, ln_parse->value); if (!l->first) { ln->prev = NULL; l->first = ln; } else { ln->prev = l->last; l->last->next = ln; } l->last = ln; l->last->next = NULL; l->size++; } } }
static int aio_schedule(struct tcmu_device *dev, struct tcmulib_cmd *cmd, tcmu_work_fn_t fn) { struct tcmu_work *work; struct tcmur_device *rdev = tcmu_get_daemon_dev_private(dev); struct tcmu_io_queue *io_wq = &rdev->work_queue; work = malloc(sizeof(*work)); if (!work) return SAM_STAT_TASK_SET_FULL; work->fn = fn; work->dev = dev; work->cmd = cmd; list_node_init(&work->entry); /* cleanup push/pop not _really_ required here atm */ pthread_cleanup_push(_cleanup_mutex_lock, &io_wq->io_lock); pthread_mutex_lock(&io_wq->io_lock); list_add_tail(&io_wq->io_queue, &work->entry); pthread_cond_signal(&io_wq->io_cond); // TODO: conditional pthread_mutex_unlock(&io_wq->io_lock); pthread_cleanup_pop(0); return TCMU_ASYNC_HANDLED; }
void list_remove(struct list_node *del_node) { del_node->next->prev = del_node->prev; del_node->prev->next = del_node->next; list_node_init(del_node); }
/** * @brief Initialise a new string container. * @param str String to initialise. */ void string_init(struct string *str) { str->str = NULL; str->len = 0UL; xfiredb_spinlock_init(&str->lock); list_node_init(&str->entry); }
static Process * process_new(const char *p_name, Process *parent) { Process *new_proc = kmalloc(sizeof(Process)); new_proc->kernel_stack = kmalloc(PAGE_SIZE); new_proc->kernel_stack_top = new_proc->kernel_stack + PAGE_SIZE - sizeof(ProcScene); new_proc->current_scene = (volatile ProcScene*)new_proc->kernel_stack_top; new_proc->current_scene->last_scene = 0; list_node_init(&new_proc->_link); sb_node_init(&new_proc->_node); list_node_init(&new_proc->_child_link); new_proc->id = ++_proc_id; new_proc->state = PS_READY; new_proc->retval = 0; strncpy(new_proc->name, p_name, PROC_NAME_LENGTH); new_proc->priv_base = PRIV_NORMAL; new_proc->priv_offset = 0; new_proc->ticks = 0; new_proc->parent = parent; list_init(&new_proc->children); list_init(&new_proc->messages); new_proc->waiting_for = 0; if (parent) { list_append(&parent->children, &new_proc->_child_link); mm_duplicate(&new_proc->mm, &parent->mm); memcpy(proc_current_scene(new_proc), proc_current_scene(parent), sizeof(ProcScene) - 4); // for last_scene proc_current_scene(new_proc)->regs[1] = 0; } else { mm_init_proc(&new_proc->mm); memset(proc_current_scene(new_proc), 0, sizeof(ProcScene)); } _proc_insert(&proc_tree, new_proc); _proc_insert_into_queues(new_proc); return new_proc; }
/* * Free a memory block owned by a given cookie. * Run some corruption checks. */ void olsr_cookie_free(struct olsr_cookie_info *ci, void *ptr) { struct olsr_cookie_mem_brand *branding; struct list_node *free_list_node; #ifdef OLSR_COOKIE_DEBUG bool reuse = false; #endif branding = (struct olsr_cookie_mem_brand *)ARM_NOWARN_ALIGN(((unsigned char *)ptr + ci->ci_size)); /* * Verify if there has been a memory overrun, or * the wrong owner is trying to free this. */ assert(!memcmp(&branding->cmb_sig, "cookie", 6) && branding->cmb_id == ci->ci_id); /* Kill the brand */ memset(branding, 0, sizeof(*branding)); /* * Rather than freeing the memory right away, try to reuse at a later * point. Keep at least ten percent of the active used blocks or at least * ten blocks on the free list. */ if ((ci->ci_free_list_usage < COOKIE_FREE_LIST_THRESHOLD) || (ci->ci_free_list_usage < ci->ci_usage / COOKIE_FREE_LIST_THRESHOLD)) { free_list_node = (struct list_node *)ptr; list_node_init(free_list_node); list_add_before(&ci->ci_free_list, free_list_node); ci->ci_free_list_usage++; #ifdef OLSR_COOKIE_DEBUG reuse = true; #endif } else { /* * No interest in reusing memory. */ free(ptr); } /* Stats keeping */ olsr_cookie_usage_decr(ci->ci_id); #ifdef OLSR_COOKIE_DEBUG OLSR_PRINTF(1, "MEMORY: free %s, %p, %u bytes%s\n", ci->ci_name, ptr, ci->ci_size, reuse ? ", reuse" : ""); #endif }
void list_insert(t_list *list, t_list_node *at, void *item) { t_list_node *next; t_list_node *prev; t_list_node *node; node = (t_list_node *)malloc(sizeof(*node)); if (node == NULL) exit_errorc("list_insert", ERRC_NOT_ENOUGH_MEMORY, 1, NULL); list_node_init(node, item); next = at; prev = at->prev; list_node_set_next(node, next); list_node_set_prev(node, prev); if (at == list->first) list->first = node; if (at == list->last) list->last = node; }
void addElement(list_t *list, void *element) { if (element==NULL) { // non sono ammessi valori nulli come elementi perror("tentato di aggiungere un valore NULL"); exit(-1); } //creo un nodo list_node_t* newNode=list_node_init(element); //lista vuota? if (list->head==NULL) { list->head=newNode; list->tail=newNode; } else { // lista non vuota list->tail->next=newNode; list->tail=newNode; } }
void* csv_entry_create(list_head_t* list, size_t entry_size) { csv_entry_chunk_t* entry_chunk; if(!list_empty(list)) { entry_chunk = list_last_entry(csv_entry_chunk_t, list, node); if(entry_chunk->count < csv_entries_per_chunk) return &entry_chunk->byte + (entry_chunk->count++ * entry_size); } entry_chunk = mp_malloc(sizeof(csv_entry_chunk_t) + entry_size * csv_entries_per_chunk); list_node_init(&entry_chunk->node); entry_chunk->count = 1; list_add_tail(&entry_chunk->node, list); return &entry_chunk->byte; }
/** * Add a socket and handler to the socketset * beeing used in the main select(2) loop * in listen_loop * *@param fd the socket *@param pf the processing function */ void add_olsr_socket(int fd, socket_handler_func pf_pr, socket_handler_func pf_imm, void *data, unsigned int flags) { struct olsr_socket_entry *new_entry; if (fd < 0 || (pf_pr == NULL && pf_imm == NULL)) { OLSR_PRINTF(1, "Bogus socket entry - not registering..."); return; } OLSR_PRINTF(3, "Adding OLSR socket entry %d\n", fd); new_entry = olsr_malloc(sizeof(*new_entry), "Socket entry"); new_entry->fd = fd; new_entry->process_immediate = pf_imm; new_entry->process_pollrate = pf_pr; new_entry->data = data; new_entry->flags = flags; /* Queue */ list_node_init(&new_entry->socket_node); list_add_before(&socket_head, &new_entry->socket_node); }