static void remove_shader_variant(struct llvmpipe_context *lp, struct lp_fragment_shader_variant *variant) { struct llvmpipe_screen *screen = llvmpipe_screen(lp->pipe.screen); unsigned i; if (gallivm_debug & GALLIVM_DEBUG_IR) { debug_printf("llvmpipe: del fs #%u var #%u v created #%u v cached #%u v total cached #%u\n", variant->shader->no, variant->no, variant->shader->variants_created, variant->shader->variants_cached, lp->nr_fs_variants); } for (i = 0; i < Elements(variant->function); i++) { if (variant->function[i]) { if (variant->jit_function[i]) LLVMFreeMachineCodeForFunction(screen->engine, variant->function[i]); LLVMDeleteFunction(variant->function[i]); } } remove_from_list(&variant->list_item_local); variant->shader->variants_cached--; remove_from_list(&variant->list_item_global); lp->nr_fs_variants--; FREE(variant); }
void free_mud_event(struct mud_event_data *pMudEvent) { struct descriptor_data * d; struct char_data * ch; switch (mud_event_index[pMudEvent->iId].iEvent_Type) { case EVENT_WORLD: remove_from_list(pMudEvent->pEvent, world_events); break; case EVENT_DESC: d = (struct descriptor_data *) pMudEvent->pStruct; remove_from_list(pMudEvent->pEvent, d->events); break; case EVENT_CHAR: ch = (struct char_data *) pMudEvent->pStruct; remove_from_list(pMudEvent->pEvent, ch->events); break; } if (pMudEvent->sVariables != NULL) free(pMudEvent->sVariables); pMudEvent->pEvent->event_obj = NULL; free(pMudEvent); }
/** * coalesce - Concatenate adjacent blocks to prevent fragmentation. * * Should upkeep the free list. Assumes that bp is a free block. * Also assumes that bp has not yet been added to a free list. */ static void *coalesce(void *bp) { size_t prev_alloc = GET_PREVALLOC(bp); size_t next_alloc = GET_NEXTALLOC(bp); size_t size = GET_THISSIZE(bp); char *next_block = GET_NEXTBLOCK(bp); char *prev_block = GET_PREVBLOCK(bp); TRACE(">>>Entering coalesce(bp=0x%X)\n", (unsigned int)bp); /* Case 1, Both blocks allocated, does not need its own if statement */ if (prev_alloc && !next_alloc) { /* Case 2: only next_block is free */ remove_from_list(next_block, calc_list_index(GET_THISSIZE(next_block))); /* Only need to update the size field */ size += GET_SIZE(GET_BLOCKHDR(next_block)); PUTW(GET_BLOCKHDR(bp), PACK(size, prev_alloc)); PUTW(GET_BLOCKFTR(bp), PACK(size, prev_alloc)); } else if (!prev_alloc && next_alloc) { /* Case 3: only prev_block is free */ remove_from_list(prev_block, calc_list_index(GET_THISSIZE(prev_block))); /* Need to update the size and prev_alloc field */ size += GET_THISSIZE(prev_block); prev_alloc = GET_PREVALLOC(prev_block); PUTW(GET_BLOCKFTR(bp), PACK(size, prev_alloc)); PUTW(GET_BLOCKHDR(prev_block), PACK(size, prev_alloc)); bp = prev_block; } else if (!prev_alloc && !next_alloc) { /* Case 4: Both blocks are free */ remove_from_list(next_block, calc_list_index(GET_THISSIZE(next_block))); remove_from_list(prev_block, calc_list_index(GET_THISSIZE(prev_block))); /* Need to update the size and prev_alloc field */ size += GET_THISSIZE(prev_block) + GET_THISSIZE(next_block); prev_alloc = GET_PREVALLOC(prev_block); PUTW(GET_BLOCKHDR(GET_PREVBLOCK(bp)), PACK(size, prev_alloc)); PUTW(GET_BLOCKFTR(GET_NEXTBLOCK(bp)), PACK(size, prev_alloc)); bp = GET_PREVBLOCK(bp); } /* coalesce() is always called after a block is marked free so it needs to add the block to the appropriate free list */ add_to_list(bp, calc_list_index(size)); TRACE("<<<---Leaving coalesce()\n"); return bp; }
int main() { printf("Testing lists...\n"); List *list = (List *) create_list(); assert(list != NULL); assert(list->data == NULL); assert(list->next == NULL); int w = 42; int x = 1; int y = 2; int z = 3; append_to_list(list, &x); assert(*(int *)(list->data) == 1); assert(list->next != NULL); append_to_list(list, &y); assert(*(int *)(list->next->data) == 2); assert(list->next->next != NULL); append_to_list(list, &z); assert(*(int *)(list->next->next->data) == 3); assert(list->next->next->next != NULL); assert(list->next->next->next->data == NULL); assert(list->next->next->next->next == NULL); list = (List *) push_to_list(list, &w); assert(*(int *)(list->data) == 42); assert(list->next != NULL); list = (List *) pop_from_list(list); assert(*(int *)(list->data) == 1); assert(list_length(list) == 3); assert(list_index(list, &y) == 1); assert(list_index(list, &w) == -1); list = remove_from_list(list, &x); assert(*(int *)(list->data) == 2); list = push_to_list(list, &x); list = remove_from_list(list, &y); assert(*(int *)(list->next->data) == 3); printf("List tests passed\n"); return 0; }
/* * Allocates a page off one of our lists. * * Parameters: * - uiFlags = Flags for the page allocation. * * Returns: * INVALID_PAGE if the page could not be allocated, otherwise the index of the allocated page. */ static UINT32 allocate_page(UINT32 uiFlags) { UINT32 rc; PPAGELIST ppgl = NULL; BOOL bZero = FALSE; if (uiFlags & PGALLOC_ZERO) { /* try zeroed list first, then free (but need to zero afterwards) */ if (g_pglZeroed.cpg > 0) ppgl = &g_pglZeroed; else if (g_pglFree.cpg > 0) { ppgl = &g_pglFree; bZero = TRUE; } } else { /* try free list first, then zeroed */ if (g_pglFree.cpg > 0) ppgl = &g_pglFree; else if (g_pglZeroed.cpg > 0) ppgl = &g_pglZeroed; } /* TODO: apply additional strategy if we don't yet have a page list */ if (!ppgl) return INVALID_PAGE; rc = g_pMasterPageDB[ppgl->ndxLast].d.next; /* take first page on list */ remove_from_list(ppgl, rc); if (bZero) zero_page(rc); return rc; }
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; } }
static void llvmpipe_resource_destroy(struct pipe_screen *pscreen, struct pipe_resource *pt) { struct llvmpipe_screen *screen = llvmpipe_screen(pscreen); struct llvmpipe_resource *lpr = llvmpipe_resource(pt); if (lpr->dt) { /* display target */ struct sw_winsys *winsys = screen->winsys; winsys->displaytarget_destroy(winsys, lpr->dt); } else if (llvmpipe_resource_is_texture(pt)) { /* free linear image data */ if (lpr->linear_img.data) { align_free(lpr->linear_img.data); lpr->linear_img.data = NULL; } } else if (!lpr->userBuffer) { assert(lpr->data); align_free(lpr->data); } #ifdef DEBUG if (lpr->next) remove_from_list(lpr); #endif FREE(lpr); }
void Free(void *ptr) #endif { if (ptr != NULL) { #ifdef MEMORY_DEBUG memory_block *block_ptr = NULL; block_ptr = (memory_block*)(void*)((unsigned char*)ptr - offset); #ifdef MEMORY_DEBUG_ADDRESS check_memory_address(block_ptr, 2); #endif check_magic_values(filename, line, block_ptr, 0); remove_from_list(block_ptr); allocated_size -= block_ptr->size; memset(ptr, 0xAA, block_ptr->size); #ifdef MEMORY_DEBUG_FREE add_to_free_list(block_ptr); #else free(block_ptr); #endif #else free(ptr); #endif free_count++; } }
char *sort_list(char *inlist, int inlist_size) { char *tmplist; char tmp[IFNAMSIZ]; if (!inlist_size) return NULL; if (!inlist) return NULL; tmplist = (char *) malloc(inlist_size); if (!tmplist) return NULL; memset(tmplist, 0, inlist_size); char *b; int len; while ((b = find_smallest_in_list(inlist)) != NULL) { len = strcspn(b, " "); snprintf(tmp, len + 1, "%s", b); add_to_list(tmp, tmplist, inlist_size); remove_from_list(tmp, inlist, inlist_size); } strncpy(inlist, tmplist, inlist_size); free(tmplist); return inlist; }
void clean_up_unknown() { if(verbose_lvl) cout << indent(2) << "Cleaning up invalid hosts." << endl; // create a list of all links from an unknown to a node, and a list of // links from a node to an unkown and store them in a map LinkMap to_u; LinkMap from_u; fill_maps(network, to_u, from_u); // give all members of an non-empty intersection, of two elements of both // maps, the same name for(LinkMap_iter to_iter = to_u.begin(); to_iter != to_u.end(); to_iter++) for(LinkMap_iter from_iter = from_u.begin(); from_iter != from_u.end(); from_iter++) if(to_iter->first->name() != from_iter->first->name()) { HostPList hl = intersect(to_iter->second, from_iter->second); if(!hl.empty()) equilize_names(network, hl); } // clean up trash remove_from_list(hostlist, trash); network.sort(); network.unique(); }
void leave_group(struct char_data *ch) { struct group_data *group; struct char_data *tch; struct iterator_data Iterator; bool found_pc = FALSE; if ((group = ch->group) == NULL) return; send_to_group(NULL, group, "%s has left the group.\r\n", GET_NAME(ch)); remove_from_list(ch, group->members); ch->group = NULL; if (group->members->iSize) { for (tch = (struct char_data *) merge_iterator(&Iterator, group->members); tch; tch = next_in_list(&Iterator)) if (!IS_NPC(tch)) found_pc = TRUE; remove_iterator(&Iterator); } if (!found_pc) SET_BIT(GROUP_FLAGS(group), GROUP_NPC); if (GROUP_LEADER(group) == ch && group->members->iSize) { group->leader = (struct char_data *) random_from_list(group->members); send_to_group(NULL, group, "%s has assumed leadership of the group.\r\n", GET_NAME(GROUP_LEADER(group))); } else if (group->members->iSize == 0) free_group(group); }
/** * allocate - Place block, i.e. write header and footer. */ static void allocate(void *bp, size_t adjusted_size) { size_t csize = GET_THISSIZE(bp); size_t is_prev_alloc = GET_PREVALLOC(bp); TRACE(">>>Entering allocate(bp=0x%X, adjusted_size=%u)\n", (unsigned int)bp, adjusted_size); /* We will always need to remove tshi block from the free list */ remove_from_list(bp, calc_list_index(csize)); /* See if there's room to split this block into two */ if ((csize - adjusted_size) >= (MIN_SIZE)) { PUTW(GET_BLOCKHDR(bp), PACK(adjusted_size, THISALLOC | is_prev_alloc)); PUTW(GET_BLOCKFTR(bp), PACK(adjusted_size, THISALLOC | is_prev_alloc)); /* Using the new header info, mark the newly created block as free */ bp = GET_NEXTBLOCK(bp); PUTW(GET_BLOCKHDR(bp), PACK(csize - adjusted_size, PREVALLOC)); PUTW(GET_BLOCKFTR(bp), PACK(csize - adjusted_size, PREVALLOC)); /* And add it to the appropriate free list */ coalesce(bp); } else {/* If there's not room to create split the block, just extend the amount to allocated */ PUTW(GET_BLOCKHDR(bp), PACK(csize, THISALLOC | is_prev_alloc)); PUTW(GET_BLOCKFTR(bp), PACK(csize, THISALLOC | is_prev_alloc)); /* Make sure the next block's header has the prevalloc field marked */ bp = GET_BLOCKHDR(GET_NEXTBLOCK(bp)); PUTW(bp, GETW(bp) | PREVALLOC); } TRACE("<<<---Leaving allocate()\n"); }
int main(int argc, const char *argv[]) { TContact_list contact_list = {contact_list.first = NULL, contact_list.last = NULL}; get_dir(); switch(get_mode(argc, argv)){ case DEL: get_data(&contact_list); remove_from_list(&contact_list, atoi(argv[2])); save_csv(&contact_list); generate_html(&contact_list); free_list(&contact_list); break; case ADD: get_data(&contact_list); add_to_list(argv, &contact_list); sort_list(&contact_list); save_csv(&contact_list); generate_html(&contact_list); free_list(&contact_list); break; case LIST: get_data(&contact_list); sort_list(&contact_list); print_list(&contact_list); save_csv(&contact_list); generate_html(&contact_list); free_list(&contact_list); break; case SIN: get_data(&contact_list); print_single(&contact_list, atoi(argv[2])); free_list(&contact_list); break; case FIND: get_data(&contact_list); find_in_list(&contact_list, (char *)argv[2]); generate_html(&contact_list); free_list(&contact_list); break; case PLIST: get_data(&contact_list); sort_list(&contact_list); generate_plist(&contact_list); free_list(&contact_list); break; case DELN: get_data(&contact_list); delete_by_name(&contact_list, (char *)argv[2], (char *)argv[3]); save_csv(&contact_list); generate_html(&contact_list); free_list(&contact_list); default: handle_errors(); return EXIT_FAILURE; } if(handle_errors() != EXIT_SUCCESS) return EXIT_FAILURE; else return EXIT_SUCCESS; }
static void free_funcs( struct _tnl_dynfn *l ) { struct _tnl_dynfn *f, *tmp; foreach_s (f, tmp, l) { remove_from_list( f ); ALIGN_FREE( f->code ); FREE( f ); }
/* This function is called when the virtual memory system unmaps a page from * the virtual address space. Remove the page from the list of resident * pages. */ void policy_page_unmapped(page_t page) { pageinfo_t *pginfo, *prev; pginfo = find_page(&pagelist, page, &prev); assert(pginfo != NULL); remove_from_list(&pagelist, pginfo, prev); }
static void free_funcs( struct dynfn *l ) { struct dynfn *f, *tmp; foreach_s (f, tmp, l) { remove_from_list( f ); _mesa_exec_free( f->code ); _mesa_free( f ); }
//创建UDP,接收设备的消息 void recvDevicemsg(void ) { short msgtype; char buf[300] ; int len, err; const int on = 1; memset(buf, 0, 300); while(1) { //阻塞在这里接受消息 len = recvfrom(bsockfd, buf, 300, 0, NULL, NULL); memcpy(&msgtype, buf, 2); int ip ; memcpy(&ip, buf+2, 4); char name[22]; memcpy(&name, buf+6, 22); name[21] = '\0'; char id[13]; memcpy(&id, buf+28, 13); id[12] = '\0'; printf("msgtype = %d\n", msgtype); printf("ip = %d\n", ip); printf("name = %s\n", name); printf("id = %s\n", id); //printf("id = %s\n", buf); int i; printf("UDP接收%s \n", strerror(errno)); printf("收到消息:%s\n", buf); //收到消息:smartlinkfind //msgtype = 0x0002; //如果msgtype == 0x0002 将消息当作设备消息处理 if (msgtype == 0x0002) { //申请空间创建节点 将设备信息存入到链表中 乘以2 倍以后free不会出错 pdevice_node pnode =(pdevice_node)malloc(sizeof(device_node)*2); pnode->pNext = NULL; //memcpy(pnode->device_id, "123456", 7); memcpy(pnode, buf+2, 284); //通过id查找链表中的此设备, 删除此设备,重新加入新的节点信息 printf("%s\n", pnode->device_id); printf("%s\n", pnode->name); int data; memcpy(&data, buf+66, 4); printf("参数的值data = %d\n", data); printf("参数的值buf[66] = %d\n", buf[66]); pnode->online = 'y'; printf("pnode->online:%c\n", pnode->online); remove_from_list(device_link, pnode->device_id); list_add(device_link, pnode); } } }
static void llvmpipe_resource_destroy(struct pipe_screen *pscreen, struct pipe_resource *pt) { struct llvmpipe_screen *screen = llvmpipe_screen(pscreen); struct llvmpipe_resource *lpr = llvmpipe_resource(pt); if (lpr->dt) { /* display target */ struct sw_winsys *winsys = screen->winsys; winsys->displaytarget_destroy(winsys, lpr->dt); if (lpr->tiled[0].data) { align_free(lpr->tiled[0].data); lpr->tiled[0].data = NULL; } FREE(lpr->layout[0]); } else if (resource_is_texture(pt)) { /* regular texture */ uint level; /* free linear image data */ for (level = 0; level < Elements(lpr->linear); level++) { if (lpr->linear[level].data) { align_free(lpr->linear[level].data); lpr->linear[level].data = NULL; } } /* free tiled image data */ for (level = 0; level < Elements(lpr->tiled); level++) { if (lpr->tiled[level].data) { align_free(lpr->tiled[level].data); lpr->tiled[level].data = NULL; } } /* free layout flag arrays */ for (level = 0; level < Elements(lpr->tiled); level++) { FREE(lpr->layout[level]); lpr->layout[level] = NULL; } } else if (!lpr->userBuffer) { assert(lpr->data); align_free(lpr->data); } #ifdef DEBUG if (lpr->next) remove_from_list(lpr); #endif FREE(lpr); }
static int nntpdriver_unsubscribe_folder(mailsession * session, const char * mb) { int r; r = remove_from_list(session, mb); if (r < 0) return MAIL_ERROR_UNSUBSCRIBE; return MAIL_NO_ERROR; }
/* add_to_list takes a cell and adds that cell the * the cache list. It locks the cache for writing so * that other threads cannot modify it. */ void add_to_list(struct cache_cell *cell) { /* locks the cache for writing */ Pthread_rwlock_wrlock(&cache_lock); /* if there is enough space in the cache, * no eviction is needed. */ if (cache_size + cell->size <= MAX_CACHE_SIZE) { cell->next = head; if (head != NULL) head->previous = cell; head = cell; cache_size += cell->size; cell->last_use = cache_time; Pthread_mutex_lock(&time_mutex); cache_time++; Pthread_mutex_unlock(&time_mutex); } /* if there is not enough space in the cache, * eviction is needed. */ else { struct cache_cell *tmp_cell, *ptr; int tmp_last_use; /* remove elements from cache so that there is enough * space in the cache. */ while (!(cache_size + cell->size <= MAX_CACHE_SIZE)) { tmp_last_use = cache_time + 1; for (ptr = head; ptr != NULL; ptr = ptr->next) if (ptr->last_use < tmp_last_use) { tmp_last_use = ptr->last_use; tmp_cell = ptr; } remove_from_list(tmp_cell); } /* add cell to cache */ cell->next = head; if (head != NULL) head->previous = cell; head = cell; cache_size += cell->size; cell->last_use = cache_time; Pthread_mutex_lock(&time_mutex); cache_time++; Pthread_mutex_unlock(&time_mutex); } Pthread_rwlock_unlock(&cache_lock); return; }
/* * list_lookup: this routine just consolidates remove_from_list and * find_in_list. I did this cause it fit better with some alread existing * code */ List *list_lookup (List **list, const char *name, int wild, int rem) { List *tmp; if (rem) tmp = remove_from_list(list, name); else tmp = find_in_list(list, name, wild); return (tmp); }
static int parse_unlist (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) { do { mutt_extract_token (buf, s, 0); remove_from_list ((LIST **) data, buf->data); } while (MoreArgs (s)); return 0; }
static Logfile * logfile_remove (Logfile *log, char **args) { char *arg = next_arg(*args, args); char *ptr; WNickList *new_nl; int i; if (!log) { say("REMOVE: You need to specify a logfile first"); return NULL; } if (!arg) say("Remove: Remove nicknames/channels logged to this file"); else while (arg) { if ((ptr = strchr(arg, ',')) != NULL) *ptr++ = 0; if (log->type == LOG_TARGETS) { if ((new_nl = (WNickList *)remove_from_list((List **)&(log->targets), arg))) { say("Removed %s from log target list", new_nl->nick); new_free(&new_nl->nick); new_free((char **)&new_nl); } else say("%s is not on the list for this log!", arg); } else if (log->type == LOG_SERVERS || log->type == LOG_WINDOWS) { int refnum = my_atol(ptr); for (i = 0; i < MAX_TARGETS; i++) { if (log->refnums[i] == refnum) { say("Removed %d to log refnum list", refnum); log->refnums[i] = -1; break; } } if (i >= MAX_TARGETS) say("%s is not on the refnum list for this log!", arg); } arg = ptr; } return log; }
static PyObject* condition_notify(ConditionObject *self, int num) { PyObject *res, *waiters; PyObject *iter, *item; DEBUG("self:%p", self); res = call_method((PyObject*)self, "_is_owned"); if (res == NULL) { return NULL; } if (PyObject_Not(res)) { Py_DECREF(res); PyErr_SetString(PyExc_RuntimeError, "cannot release un-acquired lock"); return NULL; } Py_DECREF(res); waiters = PyList_GetSlice(self->waiters, 0, num); if (waiters == NULL) { return NULL; } if (PyObject_Not(waiters)) { Py_RETURN_NONE; } iter = PyObject_GetIter(waiters); if (PyErr_Occurred()) { return NULL; } while ((item = PyIter_Next(iter))) { res = semaphore_release((SemaphoreObject*)item); Py_XDECREF(res); if (res == NULL) { Py_DECREF(item); goto err; } if (remove_from_list((PyListObject*)self->waiters, item) == -1) { Py_DECREF(item); goto err; } Py_DECREF(item); /* DEBUG("self->waiters len:%d", PyList_Size(self->waiters)); */ } Py_DECREF(waiters); Py_DECREF(iter); Py_RETURN_NONE; err: Py_DECREF(waiters); Py_DECREF(iter); return NULL; }
/* dispose of a menu */ VOID StMObDispose P1C(LVAL, menu) { LVAL menu_list; if (StMObAllocated(menu)) StMObDisposeMach(menu); standard_hardware_clobber(menu); menu_list = GetMenuList(); menu_list = remove_from_list(menu, menu_list); SetMenuList(menu_list); }
/* delete item from the list */ static VOID delete_menu_item P2C(LVAL, menu, LVAL, item) { LVAL item_list; StMObDeleteItem(menu, item); item_list = slot_value(menu, s_items); item_list = remove_from_list(item, item_list); set_slot_value(menu, s_items,item_list); set_slot_value(item, s_menu, NIL); }
static int parse_ignore (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) { do { mutt_extract_token (buf, s, 0); remove_from_list (&UnIgnore, buf->data); add_to_list (&Ignore, buf->data); } while (MoreArgs (s)); return 0; }
void free_mud_event(struct mud_event_data *pMudEvent) { struct descriptor_data * d; struct char_data * ch; struct room_data * room; switch (mud_event_index[pMudEvent->iId].iEvent_Type) { case EVENT_WORLD: remove_from_list(pMudEvent->pEvent, world_events); break; case EVENT_DESC: d = (struct descriptor_data *) pMudEvent->pStruct; remove_from_list(pMudEvent->pEvent, d->events); break; case EVENT_CHAR: ch = (struct char_data *) pMudEvent->pStruct; remove_from_list(pMudEvent->pEvent, ch->events); if (ch->events->iSize == 0) { free_list(ch->events); ch->events = NULL; } break; case EVENT_ROOM: room = (struct room_data *) pMudEvent->pStruct; remove_from_list(pMudEvent->pEvent, room->events); if (room->events && (room->events->iSize == 0)) { free_list(room->events); room->events = NULL; } break; } if (pMudEvent->sVariables != NULL) free(pMudEvent->sVariables); pMudEvent->pEvent->event_obj = NULL; free(pMudEvent); }
// This function is called when a /dev/osprdX file is finally closed. // (If the file descriptor was dup2ed, this function is called only when the // last copy is closed.) static int osprd_close_last(struct inode *inode, struct file *filp) { if (filp) { osprd_info_t *d = file2osprd(filp); int filp_writable = filp->f_mode & FMODE_WRITE; // EXERCISE: If the user closes a ramdisk file that holds // a lock, release the lock. Also wake up blocked processes // as appropriate. // Your code here. osp_spin_lock(&d->mutex); // When the file is closed; if ((filp->f_flags & F_OSPRD_LOCKED) != 0) { filp->f_flags &= ~F_OSPRD_LOCKED; if (filp_writable) { remove_from_list(d->write_locking_pids, current->pid); // eprintk("Write done!\n"); // print_list(d->write_locking_pids); } else { remove_from_list(d->read_locking_pids, current->pid); // eprintk("Read done!\n"); // print_list(d->read_locking_pids); } // eprintk("Locking command release!\n"); wake_up_all(&d->blockq); } osp_spin_unlock(&d->mutex); // This line avoids compiler warnings; you may remove it. (void) filp_writable, (void) d; } return 0; }
/** * See header. */ int load_authorities_cfg(vici_conn_t *conn, command_format_options_t format, settings_t *cfg) { u_int found = 0, loaded = 0, unloaded = 0; char *section; enumerator_t *enumerator; linked_list_t *authorities; authorities = list_authorities(conn, format); enumerator = cfg->create_section_enumerator(cfg, "authorities"); while (enumerator->enumerate(enumerator, §ion)) { remove_from_list(authorities, section); found++; if (load_authority(conn, cfg, section, format)) { loaded++; } } enumerator->destroy(enumerator); /* unload all authorities in daemon, but not in file */ while (authorities->remove_first(authorities, (void**)§ion) == SUCCESS) { if (unload_authority(conn, section, format)) { unloaded++; } free(section); } authorities->destroy(authorities); if (format & COMMAND_FORMAT_RAW) { return 0; } if (found == 0) { fprintf(stderr, "no authorities found, %u unloaded\n", unloaded); return 0; } if (loaded == found) { printf("successfully loaded %u authorities, %u unloaded\n", loaded, unloaded); return 0; } fprintf(stderr, "loaded %u of %u authorities, %u failed to load, " "%u unloaded\n", loaded, found, found - loaded, unloaded); return EINVAL; }