void * dump_proc(void * args) { struct dump_manager *manager = (struct dump_manager*) args; while (1) { wait_usb_plugin(manager); unmount_usb(manager); if (mount_usb(manager) == 0) { get_record_id(manager); change_led_mode(LED_DUMP); if (exe_update(manager) != 0) { get_config_info(manager); get_time(&(manager->time_export)); dump_status(manager); dump_serial(manager); dump_wave(manager); } unmount_usb(manager); change_led_mode(LED_DUMP_FINISHED); wait_usb_plugout(manager); change_led_mode(LED_NORMAL); } } return NULL; }
static int insertrecsbypointer(int max, void **tree, const enum insertorder order) { int indx = 0; for(indx = 0 ; indx < max ; ++indx) { int i = 0; int k = 0; char kbuf[40]; char dbuf[60]; struct example_tentry *mt = 0; struct example_tentry *retval = 0; i = get_record_id(order,indx); snprintf(kbuf,sizeof(kbuf),"%u",i); strcpy(dbuf," data for "); strcat(dbuf,kbuf); printf("insertrec %d\n",i); /* Do it twice so we have test the case where tsearch adds and one where it finds an existing record. */ for (k = 0; k < 2 ;++k) { mt = make_example_tentry(i,dbuf); errno = 0; /* tsearch adds an entry if its not present already. */ retval = dwarf_tsearch(mt,tree, mt_compare_func ); if(retval == 0) { printf("FAIL ENOMEM in search on %d, give up insertrecsbypointer\n",i); exit(1); } else { struct example_tentry *re = 0; re = *(struct example_tentry **)retval; if(re != mt) { if(!k) { printf("FAIL found existing an error %u\n",i); mt_free_func(mt); return 1; } else { printf("found existing ok %u\n",i); } /* Prevents data leak: mt was already present. */ mt_free_func(mt); } else { if(!k) { printf("insert new ok %u\n",i); } else { printf("FAIL new found but expected existing %u\n",i); } /* New entry mt was added. */ } } } } return 0; }
struct dump_manager* get_dump_manager() { if (gpdump_manager == NULL) { gpdump_manager = malloc(sizeof(struct dump_manager)); if (gpdump_manager != NULL) { memset(gpdump_manager, 0, sizeof(struct dump_manager)); add_block_filter(&(gpdump_manager->manager), NULL, sizeof(struct dump), 8); get_record_id(gpdump_manager); pthread_create(&(gpdump_manager->thread_dump), NULL, dump_proc, gpdump_manager); } } return gpdump_manager; }
static int findrecsbypointer(int max,int findexpected, const void **tree, const enum insertorder order) { int indx = 0; for(indx = 0 ; indx < max ; ++indx) { char kbuf[40]; char dbuf[60]; dbuf[0] = 0; struct example_tentry *mt = 0; struct example_tentry *retval = 0; int i = 0; i = get_record_id(order,indx); snprintf(kbuf,sizeof(kbuf),"%u",i); mt = make_example_tentry(i,dbuf); printf("findrec %d\n",i); retval = dwarf_tfind(mt,(void *const*)tree,mt_compare_func); if(!retval) { if(indx < findexpected) { mt_free_func(mt); printf("FAIL tfind on %s is FAILURE\n",kbuf); return 1; } else { printf("Not found with tfind on %s is ok\n",kbuf); } } else { printf("found ok %u\n",i); if(indx >= findexpected) { mt_free_func(mt); printf("FAIL: found with tfind on %s is FAILURE\n",kbuf); return 1; } else { printf("Found with tfind on %s is ok\n",kbuf); } } mt_free_func(mt); } return 0; }
/* The dodump flag is so we can distinguish binarysearch actions from the binarysearch with eppinger mods easily in the test output. The difference is slight and not significant, but the difference is what we look for when we look. */ static int delrecsbypointer(int max,int findexpected, void **tree,const enum insertorder order,int dodump) { int indx = 0; for (indx = 0; indx < max; indx++) { struct example_tentry *mt = 0; struct example_tentry *re3 = 0; void *r = 0; int i = 0; i = get_record_id(order,indx); printf("delrec %d\n",i); mt = make_example_tentry(i,0); r = dwarf_tfind(mt,(void *const*)tree,mt_compare_func); if (r) { /* This is what tdelete will delete. tdelete just removes the reference from the tree, it does not actually delete the memory for the entry itself. In fact there is no way to know for sure what was done just given the return from tdelete. You just just assume the delete worked and use the tfind result to delete your contents if you want to.*/ re3 = *(struct example_tentry **)r; if(indx < findexpected) { ; } else { mt_free_func(mt); printf("FAIL delrecsbypointer should not have found record to delete for %d\n",i); return 1; } r = dwarf_tdelete(mt,tree,mt_compare_func); if (! *tree) { printf("tree itself now empty\n"); } /* We don't want the 'test' node left around. */ if(r) { /* If the node deleted was root, r is really the new root, not the parent. Or r is non-null but bogus. (so don't print). */ printf("tdelete returned parent or something.\n"); } else { printf("tdelete returned NULL, tree now empty.\n"); #ifdef HASHSEARCH printf("Only really means some hash chain is now empty.\n"); #endif /* HASHSEARCH */ } mt_free_func(mt); mt_free_func(re3); } else { if(indx >= findexpected) { ; } else { mt_free_func(mt); printf("FAIL delrecsbypointer should have found record to delete for %d\n",i); return 1; } /* There is no node like this to delete. */ /* We don't want the 'test' node left around. */ mt_free_func(mt); } if (dodump) { dwarf_tdump( *tree,mt_keyprint,"In Delrecs"); } dwarf_twalk( *tree,walk_entry); } return 0; }