int main(int argc, char *argv[]) { int error __unused, i, r, s; FILE *pidf; int ch = 0; while ((ch = getopt(argc, argv, "d")) != -1) { switch(ch) { case 'd': debugopt = 1; break; default: usage(); /* NOT REACHED */ } } argc -= optind; argv += optind; TAILQ_INIT(&pdev_array_list); TAILQ_INIT(&udev_monitor_list); r = ignore_signal(SIGPIPE); if (r != 0) err(1, "could not ignore_signal SIGPIPE"); r = pthread_mutex_init(&(monitor_lock), NULL); if (r != 0) err(1, "could not allocate a pthread_mutex"); if ((udevfd = open(UDEV_DEVICE_PATH, O_RDWR | O_NONBLOCK)) == -1) err(1, "%s", UDEV_DEVICE_PATH); unblock_descriptor(udevfd); s = init_local_server(LISTEN_SOCKET_FILE, SOCK_STREAM, 0); if (s < 0) err(1, "init_local_server"); pidf = fopen("/var/run/udevd.pid", "w"); #if 0 if (pidf == NULL) err(1, "pidfile"); #endif set_signal(SIGTERM, killed); set_signal(SIGHUP, hangup); if (debugopt == 0) if (daemon(0, 0) == -1) err(1, "daemon"); if (pidf != NULL) { fprintf(pidf, "%ld\n", (long)getpid()); fclose(pidf); } syslog(LOG_ERR, "udevd started"); pdev_array_entry_insert(udev_getdevs(udevfd)); memset(fds, 0 , sizeof(fds)); fds[UDEV_DEVICE_FD_IDX].fd = udevfd; fds[UDEV_DEVICE_FD_IDX].events = POLLIN; fds[UDEV_SOCKET_FD_IDX].fd = s; fds[UDEV_SOCKET_FD_IDX].events = POLLIN | POLLPRI; for (;;) { r = poll(fds, NFDS, -1); if (r < 0) { if (hangup_ongoing == 0) { if (errno == EINTR) { usleep(5000); continue; } else { err(1, "polling..."); } } else { usleep(20000); /* 20 ms */ continue; } } for (i = 0; (i < NFDS) && (r > 0); i++) { if (fds[i].revents == 0) continue; --r; switch (i) { case UDEV_DEVICE_FD_IDX: udev_read_event(udevfd); break; case UDEV_SOCKET_FD_IDX: handle_new_connection(s); break; default: break; } } } syslog(LOG_ERR, "udevd is exiting normally"); return 0; }
/* See Porting Layer Definition - p. 20 */ Bool winFinishScreenInitFB (int index, ScreenPtr pScreen, int argc, char **argv) { winScreenPriv(pScreen); winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo; VisualPtr pVisual = NULL; char *pbits = NULL; #if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW) int iReturn; #endif /* Create framebuffer */ if (!(*pScreenPriv->pwinAllocateFB) (pScreen)) { ErrorF ("winFinishScreenInitFB - Could not allocate framebuffer\n"); return FALSE; } /* * Grab the number of bits that are used to represent color in each pixel. */ if (pScreenInfo->dwBPP == 8) pScreenInfo->dwDepth = 8; else pScreenInfo->dwDepth = winCountBits (pScreenPriv->dwRedMask) + winCountBits (pScreenPriv->dwGreenMask) + winCountBits (pScreenPriv->dwBlueMask); winErrorFVerb (2, "winFinishScreenInitFB - Masks: %08x %08x %08x\n", (unsigned int) pScreenPriv->dwRedMask, (unsigned int) pScreenPriv->dwGreenMask, (unsigned int) pScreenPriv->dwBlueMask); /* Init visuals */ if (!(*pScreenPriv->pwinInitVisuals) (pScreen)) { ErrorF ("winFinishScreenInitFB - winInitVisuals failed\n"); return FALSE; } /* Setup a local variable to point to the framebuffer */ pbits = pScreenInfo->pfb; /* Apparently we need this for the render extension */ miSetPixmapDepths (); /* Start fb initialization */ if (!fbSetupScreen (pScreen, pScreenInfo->pfb, pScreenInfo->dwWidth, pScreenInfo->dwHeight, monitorResolution, monitorResolution, pScreenInfo->dwStride, pScreenInfo->dwBPP)) { ErrorF ("winFinishScreenInitFB - fbSetupScreen failed\n"); return FALSE; } /* Override default colormap routines if visual class is dynamic */ if (pScreenInfo->dwDepth == 8 && (pScreenInfo->dwEngine == WIN_SERVER_SHADOW_GDI || (pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DDNL && pScreenInfo->fFullScreen) || (pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DD && pScreenInfo->fFullScreen))) { winSetColormapFunctions (pScreen); /* * NOTE: Setting whitePixel to 255 causes Magic 7.1 to allocate its * own colormap, as it cannot allocate 7 planes in the default * colormap. Setting whitePixel to 1 allows Magic to get 7 * planes in the default colormap, so it doesn't create its * own colormap. This latter situation is highly desireable, * as it keeps the Magic window viewable when switching to * other X clients that use the default colormap. */ pScreen->blackPixel = 0; pScreen->whitePixel = 1; } /* Place our save screen function */ pScreen->SaveScreen = winSaveScreen; /* Finish fb initialization */ if (!fbFinishScreenInit (pScreen, pScreenInfo->pfb, pScreenInfo->dwWidth, pScreenInfo->dwHeight, monitorResolution, monitorResolution, pScreenInfo->dwStride, pScreenInfo->dwBPP)) { ErrorF ("winFinishScreenInitFB - fbFinishScreenInit failed\n"); return FALSE; } /* Save a pointer to the root visual */ for (pVisual = pScreen->visuals; pVisual->vid != pScreen->rootVisual; pVisual++); pScreenPriv->pRootVisual = pVisual; /* * Setup points to the block and wakeup handlers. Pass a pointer * to the current screen as pWakeupdata. */ pScreen->BlockHandler = winBlockHandler; pScreen->WakeupHandler = winWakeupHandler; pScreen->blockData = pScreen; pScreen->wakeupData = pScreen; #ifdef XWIN_MULTIWINDOWEXTWM /* * Setup acceleration for multi-window external window manager mode. * To be compatible with the Damage extension, this must be done * before calling miDCInitialize, which calls DamageSetup. */ if (pScreenInfo->fMWExtWM) { if (!RootlessAccelInit (pScreen)) { ErrorF ("winFinishScreenInitFB - RootlessAccelInit () failed\n"); return FALSE; } } #endif #ifdef RENDER /* Render extension initialization, calls miPictureInit */ if (!fbPictureInit (pScreen, NULL, 0)) { ErrorF ("winFinishScreenInitFB - fbPictureInit () failed\n"); return FALSE; } #endif #ifdef RANDR /* Initialize resize and rotate support */ if (!winRandRInit (pScreen)) { ErrorF ("winFinishScreenInitFB - winRandRInit () failed\n"); return FALSE; } #endif /* * Backing store support should reduce network traffic and increase * performance. */ miInitializeBackingStore (pScreen); /* KDrive does miDCInitialize right after miInitializeBackingStore */ /* Setup the cursor routines */ #if CYGDEBUG winDebug ("winFinishScreenInitFB - Calling miDCInitialize ()\n"); #endif miDCInitialize (pScreen, &g_winPointerCursorFuncs); /* KDrive does winCreateDefColormap right after miDCInitialize */ /* Create a default colormap */ #if CYGDEBUG winDebug ("winFinishScreenInitFB - Calling winCreateDefColormap ()\n"); #endif if (!winCreateDefColormap (pScreen)) { ErrorF ("winFinishScreenInitFB - Could not create colormap\n"); return FALSE; } /* Initialize the shadow framebuffer layer */ if ((pScreenInfo->dwEngine == WIN_SERVER_SHADOW_GDI || pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DD || pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DDNL) #ifdef XWIN_MULTIWINDOWEXTWM && !pScreenInfo->fMWExtWM #endif ) { #if CYGDEBUG winDebug ("winFinishScreenInitFB - Calling shadowInit ()\n"); #endif if (!shadowInit (pScreen, pScreenPriv->pwinShadowUpdate, NULL)) { ErrorF ("winFinishScreenInitFB - shadowInit () failed\n"); return FALSE; } } #ifdef XWIN_MULTIWINDOWEXTWM /* Handle multi-window external window manager mode */ if (pScreenInfo->fMWExtWM) { winDebug ("winScreenInit - MultiWindowExtWM - Calling RootlessInit\n"); RootlessInit(pScreen, &winMWExtWMProcs); winDebug ("winScreenInit - MultiWindowExtWM - RootlessInit returned\n"); rootless_CopyBytes_threshold = 0; rootless_FillBytes_threshold = 0; rootless_CompositePixels_threshold = 0; /* FIXME: How many? Profiling needed? */ rootless_CopyWindow_threshold = 1; winWindowsWMExtensionInit (); } #endif /* Handle rootless mode */ if (pScreenInfo->fRootless) { /* Define the WRAP macro temporarily for local use */ #define WRAP(a) \ if (pScreen->a) { \ pScreenPriv->a = pScreen->a; \ } else { \ ErrorF("null screen fn " #a "\n"); \ pScreenPriv->a = NULL; \ } /* Save a pointer to each lower-level window procedure */ WRAP(CreateWindow); WRAP(DestroyWindow); WRAP(RealizeWindow); WRAP(UnrealizeWindow); WRAP(PositionWindow); WRAP(ChangeWindowAttributes); WRAP(SetShape); /* Assign rootless window procedures to be top level procedures */ pScreen->CreateWindow = winCreateWindowRootless; pScreen->DestroyWindow = winDestroyWindowRootless; pScreen->PositionWindow = winPositionWindowRootless; /*pScreen->ChangeWindowAttributes = winChangeWindowAttributesRootless;*/ pScreen->RealizeWindow = winMapWindowRootless; pScreen->UnrealizeWindow = winUnmapWindowRootless; pScreen->SetShape = winSetShapeRootless; /* Undefine the WRAP macro, as it is not needed elsewhere */ #undef WRAP } #ifdef XWIN_MULTIWINDOW /* Handle multi window mode */ else if (pScreenInfo->fMultiWindow) { /* Define the WRAP macro temporarily for local use */ #define WRAP(a) \ if (pScreen->a) { \ pScreenPriv->a = pScreen->a; \ } else { \ ErrorF("null screen fn " #a "\n"); \ pScreenPriv->a = NULL; \ } /* Save a pointer to each lower-level window procedure */ WRAP(CreateWindow); WRAP(DestroyWindow); WRAP(RealizeWindow); WRAP(UnrealizeWindow); WRAP(PositionWindow); WRAP(ChangeWindowAttributes); WRAP(ReparentWindow); WRAP(RestackWindow); WRAP(ResizeWindow); WRAP(MoveWindow); WRAP(CopyWindow); WRAP(SetShape); /* Assign multi-window window procedures to be top level procedures */ pScreen->CreateWindow = winCreateWindowMultiWindow; pScreen->DestroyWindow = winDestroyWindowMultiWindow; pScreen->PositionWindow = winPositionWindowMultiWindow; /*pScreen->ChangeWindowAttributes = winChangeWindowAttributesMultiWindow;*/ pScreen->RealizeWindow = winMapWindowMultiWindow; pScreen->UnrealizeWindow = winUnmapWindowMultiWindow; pScreen->ReparentWindow = winReparentWindowMultiWindow; pScreen->RestackWindow = winRestackWindowMultiWindow; pScreen->ResizeWindow = winResizeWindowMultiWindow; pScreen->MoveWindow = winMoveWindowMultiWindow; pScreen->CopyWindow = winCopyWindowMultiWindow; pScreen->SetShape = winSetShapeMultiWindow; /* Undefine the WRAP macro, as it is not needed elsewhere */ #undef WRAP } #endif /* Wrap either fb's or shadow's CloseScreen with our CloseScreen */ pScreenPriv->CloseScreen = pScreen->CloseScreen; pScreen->CloseScreen = pScreenPriv->pwinCloseScreen; #if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW) /* Create a mutex for modules in separate threads to wait for */ iReturn = pthread_mutex_init (&pScreenPriv->pmServerStarted, NULL); if (iReturn != 0) { ErrorF ("winFinishScreenInitFB - pthread_mutex_init () failed: %d\n", iReturn); return FALSE; } /* Own the mutex for modules in separate threads */ iReturn = pthread_mutex_lock (&pScreenPriv->pmServerStarted); if (iReturn != 0) { ErrorF ("winFinishScreenInitFB - pthread_mutex_lock () failed: %d\n", iReturn); return FALSE; } /* Set the ServerStarted flag to false */ pScreenPriv->fServerStarted = FALSE; #endif #ifdef XWIN_MULTIWINDOWEXTWM pScreenPriv->fRestacking = FALSE; #endif #if defined(XWIN_MULTIWINDOW) || defined(XWIN_MULTIWINDOWEXTWM) if (FALSE #ifdef XWIN_MULTIWINDOW || pScreenInfo->fMultiWindow #endif #ifdef XWIN_MULTIWINDOWEXTWM || pScreenInfo->fInternalWM #endif ) { #if CYGDEBUG || YES winDebug ("winFinishScreenInitFB - Calling winInitWM.\n"); #endif /* Initialize multi window mode */ if (!winInitWM (&pScreenPriv->pWMInfo, &pScreenPriv->ptWMProc, &pScreenPriv->ptXMsgProc, &pScreenPriv->pmServerStarted, pScreenInfo->dwScreen, (HWND)&pScreenPriv->hwndScreen, #ifdef XWIN_MULTIWINDOWEXTWM pScreenInfo->fInternalWM || #endif FALSE)) { ErrorF ("winFinishScreenInitFB - winInitWM () failed.\n"); return FALSE; } } #endif /* Tell the server that we are enabled */ pScreenPriv->fEnabled = TRUE; /* Tell the server that we have a valid depth */ pScreenPriv->fBadDepth = FALSE; #if CYGDEBUG || YES winDebug ("winFinishScreenInitFB - returning\n"); #endif return TRUE; }
main(int argc, char *argv[]) { pthread_mutex_init(&lock, NULL); pthread_mutex_init(&atomic_lock, NULL); int i, j; struct timeval btv, etv; double delta, d1, d2; read_options(argc, argv); grp = (struct group *)malloc(sizeof(struct group) * ngroups); if(!grp) { perror("malloc"); exit(1); } for(i = 0; i < ngroups; i++) { grp[i].tids = (struct thread *)malloc(sizeof(struct thread)*group_size); if (!grp[i].tids) { perror("malloc"); exit(1); } memset(grp[i].tids, 0, sizeof(struct thread)*group_size); pthread_mutex_init(&grp[i].data_lock, NULL); grp[i].data = (unsigned int *)malloc(sizeof(unsigned int) * shared_data_size / sizeof(int)); if(!grp[i].data) { perror("malloc"); exit(1); } } pthread_t first_child; pthread_create(&first_child, NULL, boo, NULL); usleep(2*duration); pthread_join(first_child, NULL); for (i=0; i < ngroups; i++) for(j = 0; j < group_size; j++) pthread_join(grp[i].tids[j].tid, NULL); long int grp_count, tot_count; tot_count = 0; for(i = 0; i < ngroups; i++) { printf("group %d\n", i); grp_count = 0; for(j = 0; j < group_size; j++) { grp_count += grp[i].tids[j].loop_count; printf("thread %d: %ld\n", j, grp[i].tids[j].loop_count); } printf("total: %ld\n", grp_count); tot_count += grp_count; printf("\n"); } printf("Total count: %ld\n", tot_count); pthread_exit(NULL); /*d1 = etv.tv_sec + etv.tv_usec*1e-6; d2 = btv.tv_sec + btv.tv_usec*1e-6; delta = d1 - d2; printf ("Time taken = %f seconds \n", delta); */ }
static __attribute__((constructor)) void atomic_init(void) { pthread_mutex_init(&atomic_mtx, NULL); }
static void * seq_response(void * arg) { prctl(PR_SET_NAME, "ccnfd_seq", 0, 0, 0); int sock; memcpy(&sock, (int * )arg, sizeof(int)); free(arg); uint32_t payload_size; uint32_t name_len; char str[MAX_NAME_LENGTH]; struct content_name * name = NULL; int chunks; int file_len; int rv = -1; struct segment seg; if (recv(sock, &payload_size, sizeof(uint32_t), 0) == -1) { log_error(g_log, "recv: %s.", strerror(errno)); send(sock, &rv, sizeof(uint32_t), 0); goto END_SEQ_RESP; } if (recv(sock, &name_len, sizeof(uint32_t), 0) == -1) { log_error(g_log, "recv: %s.", strerror(errno)); send(sock, &rv, sizeof(uint32_t), 0); goto END_SEQ_RESP; } if (name_len > MAX_NAME_LENGTH) name_len = MAX_NAME_LENGTH - 1; if (recv(sock, str, name_len, 0) == -1) { log_error(g_log, "recv: %s.", strerror(errno)); send(sock, &rv, sizeof(uint32_t), 0); goto END_SEQ_RESP; } str[name_len] = '\0'; if (recv(sock, &chunks, sizeof(uint32_t), 0) == -1) { log_error(g_log, "recv: %s.", strerror(errno)); send(sock, &rv, sizeof(uint32_t), 0); goto END_SEQ_RESP; } if (recv(sock, &file_len, sizeof(uint32_t), 0) == -1) { log_error(g_log, "recv: %s.", strerror(errno)); send(sock, &rv, sizeof(uint32_t), 0); goto END_SEQ_RESP; } name = content_name_create(str); /* if ((seg.obj = CS_getSegment(name)) != NULL) { log_error(g_log, "seq_response: found segment %s in CS", name->full_name); rv = 0; goto RETURN_CONTENT; } */ log_print(g_log, "seq_response: retrieving %d chunks with base: %s", chunks, name->full_name); /* tell the broadcaster not to query the strategy layer to lower overhead */ ccnfdnb_opt_t opts; opts.mode = 0; /* we add a dummy component of maximum length to make sure all the segment * names willl be valid. */ snprintf(str, MAX_NAME_LENGTH - name->len - 1, "%d", chunks); if (content_name_appendComponent(name, str) != 0) { log_error(g_log, "could not append component to name (too long?)"); send(sock, &rv, sizeof(uint32_t), 0); goto END_SEQ_RESP; } int chunk_size = (chunks > 1) ? ccnf_max_payload_size(name) : file_len; content_name_removeComponent(name, name->num_components - 1); completed_jobs_t dld_segments; pthread_mutex_init(&dld_segments.mutex, NULL); pthread_cond_init(&dld_segments.cond, NULL); dld_segments.completed = linked_list_init(free); seg.name = name; seg.num_chunks = chunks; seg.opts = &opts; seg.chunk_size = chunk_size - 1; seg.obj = malloc(sizeof(struct content_obj)); seg.obj->name = name; seg.obj->data = malloc(file_len); if (!seg.obj->data) { log_error(g_log, "retrieve_segment: failed to allocated %d bytes!", file_len); send(sock, &rv, sizeof(uint32_t), 0); goto END_SEQ_RESP; } seg.obj->size = file_len; if ((rv = retrieve_segment(&seg)) < 0) { log_error(g_log, "retrieve_segment: failed to get %s!", name->full_name); send(sock, &rv, sizeof(uint32_t), 0); goto END_SEQ_RESP; } /* return the content */ if (send(sock, &rv, sizeof(uint32_t), 0) == -1) { log_error(g_log, "send: %s.", strerror(errno)); goto END_SEQ_RESP; } if (send(sock, &seg.obj->publisher, sizeof(uint32_t), 0) == -1) { log_error(g_log, "send: %s.", strerror(errno)); goto END_SEQ_RESP; } if (send(sock, &name->len, sizeof(uint32_t), 0) == -1) { log_error(g_log, "send: %s.", strerror(errno)); goto END_SEQ_RESP; } if (send(sock, name->full_name, name_len, 0) == -1) { log_error(g_log, "send: %s.", strerror(errno)); goto END_SEQ_RESP; } if (send(sock, &seg.obj->timestamp, sizeof(uint32_t), 0) == -1) { log_error(g_log, "send: %s.", strerror(errno)); goto END_SEQ_RESP; } if (send(sock, &seg.obj->size, sizeof(uint32_t), 0) == -1) { log_error(g_log, "send: %s.", strerror(errno)); goto END_SEQ_RESP; } int total = 0; int left = seg.obj->size; int n = -1; while (total < seg.obj->size) { log_debug(g_log, "total = %d", total); n = send(sock, seg.obj->data+total, left, 0); if (n == -1) break; total += n; left -= n; log_debug(g_log, "seq_response: sent %d bytes, %d bytes to go", n, left); } if (n == -1 || left != 0 || total != seg.obj->size) { log_error(g_log, "encountered error, sending segment, sent %d bytes!", total); } else { log_debug(g_log, "seq_response: returned %d bytes", total); } content_obj_destroy(seg.obj); END_SEQ_RESP: close(sock); return NULL; }
int DissectInit(void) { char tmp_dir[256]; unsigned short i; NDPI_PROTOCOL_BITMASK all; /* part of file name */ incr = 0; incr_dig = 0; /* info id */ ppp_id = ProtId("ppp"); eth_id = ProtId("eth"); ip_id = ProtId("ip"); ipv6_id = ProtId("ipv6"); tcp_id = ProtId("tcp"); if (ip_id != -1) { ip_dst_id = ProtAttrId(ip_id, "ip.dst"); ip_src_id = ProtAttrId(ip_id, "ip.src"); ip_offset_id = ProtAttrId(ip_id, "ip.offset"); } if (ipv6_id != -1) { ipv6_dst_id = ProtAttrId(ipv6_id, "ipv6.dst"); ipv6_src_id = ProtAttrId(ipv6_id, "ipv6.src"); ipv6_offset_id = ProtAttrId(ipv6_id, "ipv6.offset"); } if (tcp_id != -1) { port_dst_id = ProtAttrId(tcp_id, "tcp.dstport"); port_src_id = ProtAttrId(tcp_id, "tcp.srcport"); lost_id = ProtAttrId(tcp_id, "tcp.lost"); } tcp_grb_id = ProtId("tcp-grb"); /* pei id */ pei_l7protocol_id = ProtPeiComptId(tcp_grb_id, "l7prot"); pei_txt_id = ProtPeiComptId(tcp_grb_id, "txt"); pei_size_id = ProtPeiComptId(tcp_grb_id, "size"); pei_file_id = ProtPeiComptId(tcp_grb_id, "file"); pei_file_type_id = ProtPeiComptId(tcp_grb_id, "ftype"); /* tmp directory */ sprintf(tmp_dir, "%s/%s", ProtTmpDir(), TCP_GRB_TMP_DIR); mkdir(tmp_dir, 0x01FF); /* init dig */ if (enable_dig) { for (i=0; i!=dig_type_dim; i++) { if (!dig_tbl[i].sreg && dig_tbl[i].starttxt != NULL) { dig_tbl[i].start = strdup(dig_tbl[i].starttxt); if (dig_tbl[i].start == NULL) { LogPrintf(LV_FATAL, "No memory!"); return -1; } dig_tbl[i].slen = TcpGrbDigConvert(dig_tbl[i].start); } if (!dig_tbl[i].ereg && dig_tbl[i].endtxt != NULL) { dig_tbl[i].end = strdup(dig_tbl[i].endtxt); if (dig_tbl[i].end == NULL) { LogPrintf(LV_FATAL, "No memory!"); return -1; } dig_tbl[i].elen = TcpGrbDigConvert(dig_tbl[i].end); } //printf("File %s slen:%i elen: %i\n", dig_tbl[i].ename, dig_tbl[i].slen, dig_tbl[i].elen); } } /* ndpi */ pthread_mutex_init(&ndpi_mux, NULL); ndpi = ndpi_init_detection_module(NDPI_TICK_RES, nDPImalloc, nDPIfree, nDPIPrintf); if (ndpi == NULL) { LogPrintf(LV_ERROR, "nDPi initializzation failed"); return -1; } /* enable all protocols */ NDPI_BITMASK_SET_ALL(all); ndpi_set_protocol_detection_bitmask2(ndpi, &all); ndpi_proto_size = ndpi_detection_get_sizeof_ndpi_id_struct(); ndpi_flow_struct_size = ndpi_detection_get_sizeof_ndpi_flow_struct(); return 0; }
/******** Threads function *********/ void * threaded (void * arg) { int me=(int)arg; pthread_mutex_t mtx; pthread_mutex_t * pmtx; pthread_mutexattr_t ma; pthread_mutexattr_t * pma; int ret; #ifndef WITHOUT_XOPEN int sz = 2 + (sizeof(types) / sizeof(int)); #else int sz = 2; #endif /* We will use mutex from the stack or from malloc'ed memory */ char loc = ((me % 5) %2); if (loc) { pmtx = &mtx; } else { pmtx = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t)); if (pmtx == NULL) { UNRESOLVED(errno, "Memory allocation for mutex failed"); } } me %= sz; switch (me) { case 0: /* We will initialize the mutex with NULL pointer */ pma = NULL; break; default: /* We will initialize the mutex with an attribute object */ if ((ret = pthread_mutexattr_init(&ma))) { UNRESOLVED(ret, "Mutex attribute init failed"); } pma = &ma; if (me == 1) break; if ((ret = pthread_mutexattr_settype(&ma, types[me-2]))) { UNRESOLVED(ret, "Mutex attribute settype failed"); } } while (do_it) { ret = pthread_mutex_init(pmtx, pma); if (ret != 0) { FAILED("Mutex init failed"); } /* We use the mutex to check everything is OK */ ret = pthread_mutex_lock(pmtx); if (ret != 0) { FAILED("Mutex lock failed"); } ret = pthread_mutex_unlock(pmtx); if (ret != 0) { FAILED("Mutex unlock failed"); } ret = pthread_mutex_destroy(pmtx); if (ret != 0) { FAILED("Mutex destroy failed"); } } if (!loc) /* mutex was malloc'ed */ free(pmtx); if (me) if ((ret = pthread_mutexattr_destroy(pma))) { FAILED("Mutex attribute destroy failed at the end"); } return NULL; }
/* * Initializes the thread subsystem, creating various worker threads. * * nthreads Number of worker event handler threads to spawn * main_base Event base for main thread */ void thread_init(int nthreads, struct event_base *main_base, void *(*join_request_listener_thread_routine)(void *), void *(*joining_thread_routine)(void *), void *(*node_removal_listener_thread_routine)(void *),void *(*node_propagation_thread_routine)(void *)) { int i; int power; pthread_mutex_init(&cache_lock, NULL); pthread_mutex_init(&stats_lock, NULL); pthread_mutex_init(&init_lock, NULL); pthread_cond_init(&init_cond, NULL); pthread_mutex_init(&cqi_freelist_lock, NULL); cqi_freelist = NULL; /* Want a wide lock table, but don't waste memory */ if (nthreads < 3) { power = 10; } else if (nthreads < 4) { power = 11; } else if (nthreads < 5) { power = 12; } else { /* 8192 buckets, and central locks don't scale much past 5 threads */ power = 13; } item_lock_count = hashsize(power); item_locks = calloc(item_lock_count, sizeof(pthread_mutex_t)); if (! item_locks) { perror("Can't allocate item locks"); exit(1); } for (i = 0; i < item_lock_count; i++) { pthread_mutex_init(&item_locks[i], NULL); } pthread_key_create(&item_lock_type_key, NULL); pthread_mutex_init(&item_global_lock, NULL); threads = calloc(nthreads, sizeof(LIBEVENT_THREAD)); if (! threads) { perror("Can't allocate thread descriptors"); exit(1); } dispatcher_thread.base = main_base; dispatcher_thread.thread_id = pthread_self(); for (i = 0; i < nthreads; i++) { int fds[2]; if (pipe(fds)) { perror("Can't create notify pipe"); exit(1); } threads[i].notify_receive_fd = fds[0]; threads[i].notify_send_fd = fds[1]; setup_thread(&threads[i]); /* Reserve three fds for the libevent base, and two for the pipe */ stats.reserved_fds += 5; } /* Create threads after we've done all the libevent setup. */ for (i = 0; i < nthreads; i++) { create_worker(worker_libevent, &threads[i]); } /* Wait for all the threads to set themselves up before returning. */ pthread_mutex_lock(&init_lock); wait_for_thread_registration(nthreads); pthread_mutex_unlock(&init_lock); if(joining_thread_routine != NULL) connect_to_join_server(joining_thread_routine); else start_listening_on_join_port(join_request_listener_thread_routine); usleep(1000); start_listening_on_node_propagation_port(node_propagation_thread_routine); usleep(1000); start_listening_on_node_removal_port(node_removal_listener_thread_routine); ///we may want to comment this pthread_join(connect_and_split_thread,NULL); }
/* * setup_session * * Create a new session for the given handler */ void setup_session(struct handler_args* hargs, xmlHashTablePtr sessions, struct qz_config* conf){ struct session * this_session; // session_id is a number here, a string in the session struct, // and the encrypted contents of the session key, same value for each. uint64_t session_id; this_session = calloc(1, sizeof(struct session)); // Assign a random number that has no zero octets // as the session identifier, then test it. session_id = qzrandom64ch(this_session->session_id); // There is a risk of session id collisions that // is larger than might be hoped from the // birthday paradox. // With around 200 users, the chance of a hash key // collission is around 10^-15. This is on the order // of random bit errors and cosmic ray bit flipping. // With around 6000 users, the chance goes up to // around 10^-6, or once in a million. // Or it could be the NSA is messing with your PRNG, // or it could be your PRNG is setup wrong. // In any case, it is bad and wrong to continue. struct session* test_for_session; test_for_session = xmlHashLookup(sessions, this_session->session_id); if (test_for_session != NULL){ fprintf(hargs->log, "%f %d %s:%d collision in session identifiers - %s\n", gettime(), hargs->request_id, __func__, __LINE__, "terminating application now"); FCGX_FPrintF(hargs->err, "collision in session identifiers - ending program now\n"); exit(49); } if (pthread_mutex_init( &(this_session->session_lock), NULL) != 0){ fprintf(hargs->log, "%f %d %s:%d mutex_init failed\n", gettime(), hargs->request_id, __func__, __LINE__); fflush(hargs->log); free(this_session); return; } make_etag(hargs->session_key, conf->tagger_socket_path, session_id); snprintf(this_session->tagger_socket_path, MAXPATHLEN, "%s", conf->tagger_socket_path); this_session->zero = 0; this_session->is_logged_in = false; this_session->logged_in_time = 0; this_session->logged_out_time = 0; this_session->last_activity_time = time(NULL); this_session->conn = NULL; // 197 is just an arbritrary value. // It is prime, hashes should be a prime size. // These should be in the config file. XXXXXXXXXXXXX this_session->opentables = xmlHashCreate(197); this_session->pgtype_datum = xmlHashCreate(197); this_session->form_tags = xmlHashCreate(197); this_session->form_sets = xmlHashCreate(197); this_session->integrity_token = conf->integrity_token; // index on session_id for crypto etag xmlHashAddEntry(sessions, this_session->session_id, this_session); // cookie path is /qz/ or whatever is used as the base path char* uri_parts[] = {hargs->uri_parts[0],"",NULL}; char* path = build_path(uri_parts); make_cookie(hargs, "session_key", hargs->session_key, path, NULL, 0, false, true); free(path); hargs->session = this_session; fprintf(hargs->log, "%f %d %s:%d setup_session complete\n", gettime(), hargs->request_id, __func__, __LINE__); return; }
void sna_vertex_init(struct sna *sna) { pthread_mutex_init(&sna->render.lock, NULL); pthread_cond_init(&sna->render.wait, NULL); sna->render.active = 0; }
/* * Initializes a connection queue. */ static void cq_init(CQ *cq) { pthread_mutex_init(&cq->lock, NULL); pthread_cond_init(&cq->cond, NULL); cq->head = NULL; cq->tail = NULL; }
int adaptor_init(zhandle_t *zh) { pthread_mutexattr_t recursive_mx_attr; struct adaptor_threads *adaptor_threads = calloc(1, sizeof(*adaptor_threads)); if (!adaptor_threads) { LOG_ERROR(("Out of memory")); return -1; } /* We use a pipe for interrupting select() in unix/sol and socketpair in windows. */ #ifdef WIN32 if (create_socket_pair(adaptor_threads->self_pipe) == -1){ LOG_ERROR(("Can't make a socket.")); #else if(pipe(adaptor_threads->self_pipe)==-1) { LOG_ERROR(("Can't make a pipe %d",errno)); #endif free(adaptor_threads); return -1; } set_nonblock(adaptor_threads->self_pipe[1]); set_nonblock(adaptor_threads->self_pipe[0]); pthread_mutex_init(&zh->auth_h.lock,0); zh->adaptor_priv = adaptor_threads; pthread_mutex_init(&zh->to_process.lock,0); pthread_mutex_init(&adaptor_threads->zh_lock,0); // to_send must be recursive mutex pthread_mutexattr_init(&recursive_mx_attr); pthread_mutexattr_settype(&recursive_mx_attr, PTHREAD_MUTEX_RECURSIVE); pthread_mutex_init(&zh->to_send.lock,&recursive_mx_attr); pthread_mutexattr_destroy(&recursive_mx_attr); pthread_mutex_init(&zh->sent_requests.lock,0); pthread_cond_init(&zh->sent_requests.cond,0); pthread_mutex_init(&zh->completions_to_process.lock,0); pthread_cond_init(&zh->completions_to_process.cond,0); start_threads(zh); return 0; } void adaptor_finish(zhandle_t *zh) { struct adaptor_threads *adaptor_threads; // make sure zh doesn't get destroyed until after we're done here api_prolog(zh); adaptor_threads = zh->adaptor_priv; if(adaptor_threads==0) { api_epilog(zh,0); return; } if(!pthread_equal(adaptor_threads->io,pthread_self())){ wakeup_io_thread(zh); pthread_join(adaptor_threads->io, 0); }else pthread_detach(adaptor_threads->io); if(!pthread_equal(adaptor_threads->completion,pthread_self())){ pthread_mutex_lock(&zh->completions_to_process.lock); pthread_cond_broadcast(&zh->completions_to_process.cond); pthread_mutex_unlock(&zh->completions_to_process.lock); pthread_join(adaptor_threads->completion, 0); }else pthread_detach(adaptor_threads->completion); api_epilog(zh,0); } void adaptor_destroy(zhandle_t *zh) { struct adaptor_threads *adaptor = zh->adaptor_priv; if(adaptor==0) return; pthread_cond_destroy(&adaptor->cond); pthread_mutex_destroy(&adaptor->lock); pthread_mutex_destroy(&zh->to_process.lock); pthread_mutex_destroy(&zh->to_send.lock); pthread_mutex_destroy(&zh->sent_requests.lock); pthread_cond_destroy(&zh->sent_requests.cond); pthread_mutex_destroy(&zh->completions_to_process.lock); pthread_cond_destroy(&zh->completions_to_process.cond); pthread_mutex_destroy(&adaptor->zh_lock); pthread_mutex_destroy(&zh->auth_h.lock); close(adaptor->self_pipe[0]); close(adaptor->self_pipe[1]); free(adaptor); zh->adaptor_priv=0; } int wakeup_io_thread(zhandle_t *zh) { struct adaptor_threads *adaptor_threads = zh->adaptor_priv; char c=0; #ifndef WIN32 return write(adaptor_threads->self_pipe[1],&c,1)==1? ZOK: ZSYSTEMERROR; #else return send(adaptor_threads->self_pipe[1], &c, 1, 0)==1? ZOK: ZSYSTEMERROR; #endif } int adaptor_send_queue(zhandle_t *zh, int timeout) { if(!zh->close_requested) return wakeup_io_thread(zh); // don't rely on the IO thread to send the messages if the app has // requested to close return flush_send_queue(zh, timeout); } /* These two are declared here because we will run the event loop * and not the client */ #ifdef WIN32 int zookeeper_interest(zhandle_t *zh, SOCKET *fd, int *interest, struct timeval *tv); #else int zookeeper_interest(zhandle_t *zh, int *fd, int *interest, struct timeval *tv); #endif int zookeeper_process(zhandle_t *zh, int events); #ifdef WIN32 unsigned __stdcall do_io( void * v) #else void *do_io(void *v) #endif { zhandle_t *zh = (zhandle_t*)v; #ifndef WIN32 struct pollfd fds[2]; struct adaptor_threads *adaptor_threads = zh->adaptor_priv; api_prolog(zh); notify_thread_ready(zh); LOG_DEBUG(("started IO thread")); fds[0].fd=adaptor_threads->self_pipe[0]; fds[0].events=POLLIN; while(!zh->close_requested) { struct timeval tv; int fd; int interest; int timeout; int maxfd=1; int rc; zookeeper_interest(zh, &fd, &interest, &tv); if (fd != -1) { fds[1].fd=fd; fds[1].events=(interest&ZOOKEEPER_READ)?POLLIN:0; fds[1].events|=(interest&ZOOKEEPER_WRITE)?POLLOUT:0; maxfd=2; } timeout=tv.tv_sec * 1000 + (tv.tv_usec/1000); poll(fds,maxfd,timeout); if (fd != -1) { interest=(fds[1].revents&POLLIN)?ZOOKEEPER_READ:0; interest|=((fds[1].revents&POLLOUT)||(fds[1].revents&POLLHUP))?ZOOKEEPER_WRITE:0; } if(fds[0].revents&POLLIN){ // flush the pipe char b[128]; while(read(adaptor_threads->self_pipe[0],b,sizeof(b))==sizeof(b)){} } #else fd_set rfds, wfds, efds; struct adaptor_threads *adaptor_threads = zh->adaptor_priv; api_prolog(zh); notify_thread_ready(zh); LOG_DEBUG(("started IO thread")); FD_ZERO(&rfds); FD_ZERO(&wfds); FD_ZERO(&efds); while(!zh->close_requested) { struct timeval tv; SOCKET fd; SOCKET maxfd=adaptor_threads->self_pipe[0]; int interest; int rc; zookeeper_interest(zh, &fd, &interest, &tv); if (fd != -1) { if (interest&ZOOKEEPER_READ) { FD_SET(fd, &rfds); } else { FD_CLR(fd, &rfds); } if (interest&ZOOKEEPER_WRITE) { FD_SET(fd, &wfds); } else { FD_CLR(fd, &wfds); } } FD_SET( adaptor_threads->self_pipe[0] ,&rfds ); rc = select((int)maxfd, &rfds, &wfds, &efds, &tv); if (fd != -1) { interest = (FD_ISSET(fd, &rfds))? ZOOKEEPER_READ:0; interest|= (FD_ISSET(fd, &wfds))? ZOOKEEPER_WRITE:0; } if (FD_ISSET(adaptor_threads->self_pipe[0], &rfds)){ // flush the pipe/socket char b[128]; while(recv(adaptor_threads->self_pipe[0],b,sizeof(b), 0)==sizeof(b)){} } #endif // dispatch zookeeper events rc = zookeeper_process(zh, interest); // check the current state of the zhandle and terminate // if it is_unrecoverable() if(is_unrecoverable(zh)) break; } api_epilog(zh, 0); LOG_DEBUG(("IO thread terminated")); return 0; } #ifdef WIN32 unsigned __stdcall do_completion( void * v) #else void *do_completion(void *v) #endif { zhandle_t *zh = v; api_prolog(zh); notify_thread_ready(zh); LOG_DEBUG(("started completion thread")); while(!zh->close_requested) { pthread_mutex_lock(&zh->completions_to_process.lock); while(!zh->completions_to_process.head && !zh->close_requested) { pthread_cond_wait(&zh->completions_to_process.cond, &zh->completions_to_process.lock); } pthread_mutex_unlock(&zh->completions_to_process.lock); process_completions(zh); } api_epilog(zh, 0); LOG_DEBUG(("completion thread terminated")); return 0; }
/** * \brief Initialize verse client context */ int vc_init_ctx(struct VC_CTX *vc_ctx) { int i; /* Allocate memory for session slots and make session slots NULL */ vc_ctx->vsessions = (struct VSession**)malloc(sizeof(struct VSession*)*vc_ctx->max_sessions); vc_ctx->session_counter = 0; for(i=0; i<vc_ctx->max_sessions; i++) { vc_ctx->vsessions[i] = NULL; } /* Initialize callback function */ vc_init_func_storage(&vc_ctx->vfs); #ifdef WITH_OPENSSL /* Set up the library */ SSL_library_init(); ERR_load_BIO_strings(); SSL_load_error_strings(); OpenSSL_add_all_algorithms(); /* Set up SSL context for TLS */ if( (vc_ctx->tls_ctx = SSL_CTX_new(TLSv1_client_method())) == NULL ) { v_print_log(VRS_PRINT_ERROR, "Setting up SSL_CTX for TLS failed.\n"); ERR_print_errors_fp(v_log_file()); return 0; } /* Load the trust store for TLS */ if(SSL_CTX_load_verify_locations(vc_ctx->tls_ctx, NULL, vc_ctx->ca_path) != 1) { v_print_log(VRS_PRINT_ERROR, "Loading path with CA certificates failed.\n"); ERR_print_errors_fp(v_log_file()); } else { v_print_log(VRS_PRINT_DEBUG_MSG, "Path %s with CA certificates loaded successfully.\n", vc_ctx->ca_path); } #endif #if (defined WITH_OPENSSL) && OPENSSL_VERSION_NUMBER>=0x10000000 /* Set up SSL context for DTSL */ if( (vc_ctx->dtls_ctx = SSL_CTX_new(DTLSv1_client_method())) == NULL ) { v_print_log(VRS_PRINT_ERROR, "Setting up SSL_CTX for DTLS failed.\n"); ERR_print_errors_fp(v_log_file()); return 0; } /* Load the trust store for DTLS */ if(SSL_CTX_load_verify_locations(vc_ctx->dtls_ctx, NULL, vc_ctx->ca_path) != 1) { v_print_log(VRS_PRINT_ERROR, "Loading path with CA certificates failed.\n"); ERR_print_errors_fp(v_log_file()); } else { v_print_log(VRS_PRINT_DEBUG_MSG, "Path %s with CA certificates loaded successfully.\n", vc_ctx->ca_path); } /* Negotiate ciphers with server * For testing: (encryption:none, mac:sha) eNULL:!MDP5 * For real use: ALL:ALL */ if( SSL_CTX_set_cipher_list(vc_ctx->dtls_ctx, "eNULL:!MD5") == 0) { v_print_log(VRS_PRINT_ERROR, "Setting ciphers for DTLS failed.\n"); ERR_print_errors_fp(v_log_file()); return 0; } /* This is necessary for DTLS */ SSL_CTX_set_read_ahead(vc_ctx->dtls_ctx, 1); #else vc_ctx->dtls_ctx = NULL; #endif /* Default name and version */ vc_ctx->client_name = NULL; vc_ctx->client_version = NULL; pthread_mutex_init(&vc_ctx->mutex, NULL); return 1; }
void _thread_mutex_init(pthread_mutex_t* down_mutex) { pthread_mutex_init(down_mutex, NULL); }
/** Initializes a read file structure. * Clears a new read file structure, copies the file path, sets the record * size, and sets up its thread mutex. * * @param[in] file The file structure. * @param[in] records_per_block The number of records per block. * @param[in] start Start string. * @param[in] end End string. * @param[in] alphabet Alphabet string to use. */ int brute_force_init(file_st *file, int records_per_block, char *start, char *end, char *alphabet) { brute_force_data_st *bf_st; size_t start_len; size_t end_len; size_t alp_len; int i; start_len = strlen(start); end_len = strlen(end); alp_len = strlen(alphabet); /* Start can not be longer than end */ if (start_len > end_len) { errno = EINVAL; return E_ATTK_SYSTEM; } /* Every character in start must be in the alphabet */ for (i = 0; i < start_len; i++) { if (char_index(alphabet, alp_len, start + i) == NULL) { errno = EINVAL; return E_ATTK_SYSTEM; } } /* Every character in end must be in the alphabet */ for (i = 0; i < end_len; i++) { if (char_index(alphabet, alp_len, end + i) == NULL) { errno = EINVAL; return E_ATTK_SYSTEM; } } /* If they are the same size, start can not be greater than end */ if (start_len == end_len) { for (i = 0; i < start_len; i++) { if (char_index(alphabet, alp_len, start + i) > char_index(alphabet, alp_len, end + i)) { errno = EINVAL; return E_ATTK_SYSTEM; } if (char_index(alphabet, alp_len, start + i) < char_index(alphabet, alp_len, end + i)) { break; } } } /* Clear the structure */ memset(file, 0, sizeof(file_st)); /* Set defaults */ file->record_size = strlen(end) + 1; file->records_per_block = records_per_block; /* Initialize pthread objects */ pthread_mutex_init(&(file->mut), NULL); /* Create brute_force_data_st */ bf_st = malloc(sizeof(brute_force_data_st)); file->file_data = bf_st; /* Create buffers */ bf_st->start = malloc(strlen(start) + 1); bf_st->end = malloc(strlen(end) + 1); bf_st->alphabet = malloc(strlen(alphabet) + 1); bf_st->last = malloc(strlen(end) + 1); memset(bf_st->start, 0, strlen(start) + 1); memset(bf_st->end, 0, strlen(end) + 1); memset(bf_st->alphabet, 0, strlen(alphabet) + 1); memset(bf_st->last, 0, strlen(end) + 1); /* Fill buffers */ memcpy(bf_st->start, start, strlen(start)); memcpy(bf_st->end, end, strlen(end)); memcpy(bf_st->alphabet, alphabet, strlen(alphabet)); /* Setup class methods */ file->open_file = bf_open_file; file->next_block = bf_next_block; file->free_block = bf_free_block; file->close_file = bf_close_file; return 0; }
/**************************************************************************** * * Subroutine main * *****************************************************************************/ int main(int argc, char *argv[]) { int tlkilled,tlpid, rc,status; /*tlpid=trace logger pid */ struct traceparser_state * tp_state; char message[200]; pthread_t cur_thread; /* * Start the tests. */ teststart(argv[0]); /* Get rid of tracelogger if it is running */ tlkilled=kill_tl(); /* Setup a channel for the MsgSend Events */ chid=ChannelCreate(0); assert(chid!=-1); mypid=getpid(); /* Setup the barrier used to syncronize */ pthread_barrier_init(&global_barrier, NULL, 2); /* Setup the mutex for the mutex/condvar state test */ rc=pthread_mutex_init(&mymutex,NULL); assert(rc==EOK); /* Setup the condvar for the condvar state test */ rc=pthread_cond_init(&mycondvar,NULL); assert(rc==EOK); /* setup the sem tfor the sem state test */ rc=sem_init(&mysem, 0,0); assert(rc==0); /* Get io-privity */ rc=ThreadCtl( _NTO_TCTL_IO, 0 ); assert(rc!=-1); /* Setup the needed child */ child_pid=fork(); assert(child_pid!=-1); if (child_pid==0) { /* This child is used only in the stopped state test. * it will just sit and loop */ while (1) { delay(10); } exit(0); } /* and create a thread to go into various states */ rc=pthread_create(&cur_thread, NULL, state_thread, NULL); assert(rc==EOK); for (cur_state=STATE_DEAD;cur_state<=STATE_SEM;cur_state++) { /* these states can not be reliably and or safely triggered. */ if ((cur_state==STATE_STACK) || (cur_state==STATE_WAITPAGE) || cur_state==STATE_INTR) continue; /***********************************************************************/ /***********************************************************************/ /* * Make sure that if we trigger a thread state, that it gets logged * properly (all the information in the tracelogger is correct) * This tests the information provided in wide mode. */ snprintf(message, sizeof(message),"%s in wide mode", state_str[cur_state]); testpntbegin(message); correct_values_eh=0; exp_thread=cur_thread; /* We need to start up the tracelogger in daemon mode, 1 itteration. * we will filter out everything other then thread states, then * start logging. * We then will trigger a thread state change, and flush the trace buffer. * This should create a VERY minimal trace buffer that will be easily parsed */ tlpid=start_logger(); sleep(1); /* Set the logger to wide emmiting mode */ rc=TraceEvent(_NTO_TRACE_SETALLCLASSESWIDE); assert(rc!=-1); fast_mode=WIDE; /* Add the given thread event in the thread class back in */ rc=TraceEvent(_NTO_TRACE_ADDEVENT, _NTO_TRACE_THREAD,(1<<cur_state)); assert(rc!=-1); /* Filter out all tids other then the state_thread */ if (cur_state==STATE_STOPPED) { rc=TraceEvent(_NTO_TRACE_SETCLASSTID, _NTO_TRACE_THREAD, child_pid, 1); } else { rc=TraceEvent(_NTO_TRACE_SETCLASSTID, _NTO_TRACE_THREAD, getpid(),cur_thread); } assert(rc!=-1); /* Setup the event handler */ memset(&my_event_data, 0, sizeof(my_event_data)); memset(data_array, 0, sizeof(data_array)); my_event_data.data_array=data_array; rc=TraceEvent(_NTO_TRACE_ADDEVENTHANDLER, _NTO_TRACE_THREAD,(1<<cur_state), event_handler, &my_event_data); assert(rc!=-1); /* then trigger an event. Logging is started inside the state thread * right before it tries to trigger the given state. * the two barrier waits are to * 1) Tell the state thread that everything is setup so it should trigger the event * 2) Wait for the state thread to tell us it has finished. */ pthread_barrier_wait(&global_barrier); if ((cur_state==STATE_SEND)|| (cur_state==STATE_REPLY)) { /* If the thread is going into the send state, we should receive and reply */ sleep(1); status=MsgReceive(chid, message, sizeof(message), NULL); MsgReply(status, EOK, "ok", 3); } else if (cur_state==STATE_RECEIVE) { /* If the thread is going to call reveive, we should send it a message */ sleep(1); status=ConnectAttach(0, getpid(), chid, _NTO_SIDE_CHANNEL, 0); MsgSend(status, message, 10, message,10); } else if (cur_state==STATE_MUTEX) { pthread_mutex_lock(&mymutex); sleep(2); pthread_mutex_unlock(&mymutex); } else if (cur_state==STATE_CONDVAR) { sleep(2); pthread_cond_signal(&mycondvar); } else if (cur_state==STATE_SEM) { sleep(2); sem_post(&mysem); } /* If the state thread is going to try to trigger the dead state, it will have to * exit, so we can not expect it to call barrier_wait to tell us it's done. */ if ((1<<cur_state)!=_NTO_TRACE_THDEAD) { pthread_barrier_wait(&global_barrier); } else { /* If the state thread is going to exit, then we should just * give it time to exit, then restart it. */ sleep(2); rc=pthread_join(cur_thread, (void **)&status); assert(rc==EOK); rc=pthread_create(&cur_thread, NULL, state_thread, NULL); } delay(100); /* flush the trace buffer and wait for the tracelogger to exit*/ rc=TraceEvent(_NTO_TRACE_FLUSHBUFFER); assert(rc!=-1); rc=waitpid(tlpid, &status, 0); assert(tlpid==rc); /* Now, setup the traceparser lib to pull out the thread state events, * and make sure our event shows up */ tp_state=traceparser_init(NULL); assert(tp_state!=NULL); traceparser_cs(tp_state, NULL, parse_cb, _NTO_TRACE_THREAD, (1<<cur_state)); /* Since we don't want a bunch of output being displayed in the * middle of the tests, turn off verbose output. */ traceparser_debug(tp_state, stdout, _TRACEPARSER_DEBUG_NONE); /* Set correct_values to 0, so we can see if the callback actually * got called. */ correct_values=0; /* And parse the tracebuffer */ traceparser(tp_state, NULL, "/dev/shmem/tracebuffer"); if (correct_values==0) testpntfail("Our callback never got called, no events?"); else if (correct_values==-1) testpntfail("Got the wrong thread state"); else if (correct_values==-2) testpntfail("Got the wrong pid"); else if (correct_values==-3) testpntfail("Got the wrong tid"); else if (correct_values_eh<-1) testpntfail("Got bad values in the event handler"); else if (correct_values_eh==0) testpntfail("Event handler not called"); else if (correct_values_eh==1) testpntpass("Good"); else { snprintf(message,sizeof(message),"correct_values_eh : %d",correct_values_eh); testnote(message); snprintf(message,sizeof(message),"correct_values : %d",correct_values); testnote(message); testpntfail("This should not happen"); } traceparser_destroy(&tp_state); testpntend(); /***********************************************************************/ /***********************************************************************/ /* * Make sure that if we trigger a thread state, that it gets logged * properly (all the information in the tracelogger is correct) * This tests the information provided in fast mode. */ snprintf(message, sizeof(message),"%s in fast mode", state_str[cur_state]); testpntbegin(message); correct_values_eh=0; exp_thread=cur_thread; /* We need to start up the tracelogger in daemon mode, 1 itteration. * we will filter out everything other then thread states, then * start logging. * We then will trigger a thread state change, and flush the trace buffer. * This should create a VERY minimal trace buffer that will be easily parsed */ tlpid=start_logger(); sleep(1); /* Set the logger to fast emmiting mode */ rc=TraceEvent(_NTO_TRACE_SETALLCLASSESFAST); assert(rc!=-1); fast_mode=FAST; /* Add the given thread event in the thread class back in */ rc=TraceEvent(_NTO_TRACE_ADDEVENT, _NTO_TRACE_THREAD,(1<<cur_state)); assert(rc!=-1); /* Filter out all tids other then the state_thread */ if (cur_state==STATE_STOPPED) { rc=TraceEvent(_NTO_TRACE_SETCLASSTID, _NTO_TRACE_THREAD, child_pid, 1); } else { rc=TraceEvent(_NTO_TRACE_SETCLASSTID, _NTO_TRACE_THREAD, getpid(),cur_thread); } assert(rc!=-1); /* Setup the event handler */ memset(&my_event_data, 0, sizeof(my_event_data)); memset(data_array, 0, sizeof(data_array)); my_event_data.data_array=data_array; rc=TraceEvent(_NTO_TRACE_ADDEVENTHANDLER, _NTO_TRACE_THREAD,(1<<cur_state), event_handler, &my_event_data); assert(rc!=-1); /* then trigger an event. Logging is started inside the state thread * right before it tries to trigger the given state. * the two barrier waits are to * 1) Tell the state thread that everything is setup so it should trigger the event * 2) Wait for the state thread to tell us it has finished. */ pthread_barrier_wait(&global_barrier); if ((cur_state==STATE_SEND)|| (cur_state==STATE_REPLY)) { /* If the thread is going into the send state, we should receive and reply */ sleep(1); status=MsgReceive(chid, message, sizeof(message), NULL); MsgReply(status, EOK, "ok", 3); } else if (cur_state==STATE_RECEIVE) { /* If the thread is going to call reveive, we should send it a message */ sleep(1); status=ConnectAttach(0, getpid(), chid, _NTO_SIDE_CHANNEL, 0); MsgSend(status, message, 10, message,10); } else if (cur_state==STATE_MUTEX) { pthread_mutex_lock(&mymutex); sleep(2); pthread_mutex_unlock(&mymutex); } else if (cur_state==STATE_CONDVAR) { sleep(2); pthread_cond_signal(&mycondvar); } else if (cur_state==STATE_SEM) { sleep(2); sem_post(&mysem); } /* If the state thread is going to try to trigger the dead state, it will have to * exit, so we can not expect it to call barrier_wait to tell us it's done. */ if ((1<<cur_state)!=_NTO_TRACE_THDEAD) { pthread_barrier_wait(&global_barrier); } else { /* If the state thread is going to exit, then we should just * give it time to exit, then restart it. */ sleep(2); rc=pthread_join(cur_thread, (void **)&status); assert(rc==EOK); rc=pthread_create(&cur_thread, NULL, state_thread, NULL); } delay(100); /* flush the trace buffer and wait for the tracelogger to exit*/ rc=TraceEvent(_NTO_TRACE_FLUSHBUFFER); assert(rc!=-1); rc=waitpid(tlpid, &status, 0); assert(tlpid==rc); /* Now, setup the traceparser lib to pull out the thread state events, * and make sure our event shows up */ tp_state=traceparser_init(NULL); assert(tp_state!=NULL); traceparser_cs(tp_state, NULL, parse_cb, _NTO_TRACE_THREAD, (1<<cur_state)); /* Since we don't want a bunch of output being displayed in the * middle of the tests, turn off verbose output. */ traceparser_debug(tp_state, stdout, _TRACEPARSER_DEBUG_NONE); /* Set correct_values to 0, so we can see if the callback actually * got called. */ correct_values=0; /* And parse the tracebuffer */ traceparser(tp_state, NULL, "/dev/shmem/tracebuffer"); if (correct_values==0) testpntfail("Our callback never got called, no events?"); else if (correct_values==-1) testpntfail("Got the wrong thread state"); else if (correct_values==-2) testpntfail("Got the wrong pid"); else if (correct_values==-3) testpntfail("Got the wrong tid"); else if (correct_values_eh<-1) testpntfail("Got bad values in the event handler"); else if (correct_values_eh==0) testpntfail("Event handler not called"); else if (correct_values_eh==1) testpntpass("Good"); else testpntfail("This should not happen"); traceparser_destroy(&tp_state); testpntend(); /***********************************************************************/ } /* If the tracelogger was running when we started, we should restart it again */ if (tlkilled==1) system("reopen /dev/null ; tracelogger -n 0 -f /dev/null &"); /* Kill off the child we had forked earler */ kill (child_pid, SIGKILL); teststop(argv[0]); return 0; }
/* * Allocate the thread pool, and seed it with an initial number * of threads. * * FIXME: What to do on a SIGHUP??? */ int thread_pool_init(CONF_SECTION *cs, int *spawn_flag) { #ifndef WITH_GCD int i, rcode; CONF_SECTION *pool_cf; #endif time_t now; cs = cs; /* -Wunused */ now = time(NULL); rad_assert(spawn_flag != NULL); rad_assert(*spawn_flag == TRUE); rad_assert(pool_initialized == FALSE); /* not called on HUP */ #ifndef WITH_GCD pool_cf = cf_subsection_find_next(cs, NULL, "thread"); if (!pool_cf) *spawn_flag = FALSE; #endif /* * Initialize the thread pool to some reasonable values. */ memset(&thread_pool, 0, sizeof(THREAD_POOL)); #ifndef WITH_GCD thread_pool.head = NULL; thread_pool.tail = NULL; thread_pool.total_threads = 0; thread_pool.max_thread_num = 1; thread_pool.cleanup_delay = 5; #endif thread_pool.spawn_flag = *spawn_flag; /* * Don't bother initializing the mutexes or * creating the hash tables. They won't be used. */ if (!*spawn_flag) return 0; #ifdef WNOHANG if ((pthread_mutex_init(&thread_pool.wait_mutex,NULL) != 0)) { radlog(L_ERR, "FATAL: Failed to initialize wait mutex: %s", strerror(errno)); return -1; } /* * Create the hash table of child PID's */ thread_pool.waiters = fr_hash_table_create(pid_hash, pid_cmp, free); if (!thread_pool.waiters) { radlog(L_ERR, "FATAL: Failed to set up wait hash"); return -1; } #endif #ifndef WITH_GCD if (cf_section_parse(pool_cf, NULL, thread_config) < 0) { return -1; } /* * Catch corner cases. */ if (thread_pool.min_spare_threads < 1) thread_pool.min_spare_threads = 1; if (thread_pool.max_spare_threads < 1) thread_pool.max_spare_threads = 1; if (thread_pool.max_spare_threads < thread_pool.min_spare_threads) thread_pool.max_spare_threads = thread_pool.min_spare_threads; if (thread_pool.max_threads == 0) thread_pool.max_threads = 256; #endif /* WITH_GCD */ /* * The pool has already been initialized. Don't spawn * new threads, and don't forget about forked children, */ if (pool_initialized) { return 0; } #ifndef WITH_GCD /* * Initialize the queue of requests. */ memset(&thread_pool.semaphore, 0, sizeof(thread_pool.semaphore)); rcode = sem_init(&thread_pool.semaphore, 0, SEMAPHORE_LOCKED); if (rcode != 0) { radlog(L_ERR, "FATAL: Failed to initialize semaphore: %s", strerror(errno)); return -1; } rcode = pthread_mutex_init(&thread_pool.queue_mutex,NULL); if (rcode != 0) { radlog(L_ERR, "FATAL: Failed to initialize queue mutex: %s", strerror(errno)); return -1; } /* * Allocate multiple fifos. */ for (i = 0; i < RAD_LISTEN_MAX; i++) { int num = mainconfig.max_requests; if (!num || (num > 65536)) num = 65536; thread_pool.fifo[i] = fr_fifo_create(num, NULL); if (!thread_pool.fifo[i]) { radlog(L_ERR, "FATAL: Failed to set up request fifo"); return -1; } } #endif #ifdef HAVE_OPENSSL_CRYPTO_H /* * If we're linking with OpenSSL too, then we need * to set up the mutexes and enable the thread callbacks. */ if (!setup_ssl_mutexes()) { radlog(L_ERR, "FATAL: Failed to set up SSL mutexes"); return -1; } #endif #ifndef WITH_GCD /* * Create a number of waiting threads. * * If we fail while creating them, do something intelligent. */ for (i = 0; i < thread_pool.start_threads; i++) { if (spawn_thread(now, 0) == NULL) { return -1; } } #else thread_pool.queue = dispatch_queue_create("org.freeradius.threads", NULL); if (!thread_pool.queue) { radlog(L_ERR, "Failed creating dispatch queue: %s\n", strerror(errno)); exit(1); } #endif DEBUG2("Thread pool initialized"); pool_initialized = TRUE; return 0; }
//int main(int argc, const char * argv[]) { void VoxelServer::run() { const char VOXEL_SERVER_LOGGING_TARGET_NAME[] = "voxel-server"; // change the logging target name while this is running Logging::setTargetName(VOXEL_SERVER_LOGGING_TARGET_NAME); // Now would be a good time to parse our arguments, if we got them as assignment if (getNumPayloadBytes() > 0) { parsePayload(); } pthread_mutex_init(&_treeLock, NULL); qInstallMessageHandler(Logging::verboseMessageHandler); const char* JURISDICTION_FILE = "--jurisdictionFile"; const char* jurisdictionFile = getCmdOption(_argc, _argv, JURISDICTION_FILE); if (jurisdictionFile) { qDebug("jurisdictionFile=%s\n", jurisdictionFile); qDebug("about to readFromFile().... jurisdictionFile=%s\n", jurisdictionFile); _jurisdiction = new JurisdictionMap(jurisdictionFile); qDebug("after readFromFile().... jurisdictionFile=%s\n", jurisdictionFile); } else { const char* JURISDICTION_ROOT = "--jurisdictionRoot"; const char* jurisdictionRoot = getCmdOption(_argc, _argv, JURISDICTION_ROOT); if (jurisdictionRoot) { qDebug("jurisdictionRoot=%s\n", jurisdictionRoot); } const char* JURISDICTION_ENDNODES = "--jurisdictionEndNodes"; const char* jurisdictionEndNodes = getCmdOption(_argc, _argv, JURISDICTION_ENDNODES); if (jurisdictionEndNodes) { qDebug("jurisdictionEndNodes=%s\n", jurisdictionEndNodes); } if (jurisdictionRoot || jurisdictionEndNodes) { _jurisdiction = new JurisdictionMap(jurisdictionRoot, jurisdictionEndNodes); } } // should we send environments? Default is yes, but this command line suppresses sending const char* DUMP_VOXELS_ON_MOVE = "--dumpVoxelsOnMove"; _dumpVoxelsOnMove = cmdOptionExists(_argc, _argv, DUMP_VOXELS_ON_MOVE); qDebug("dumpVoxelsOnMove=%s\n", debug::valueOf(_dumpVoxelsOnMove)); // should we send environments? Default is yes, but this command line suppresses sending const char* DONT_SEND_ENVIRONMENTS = "--dontSendEnvironments"; bool dontSendEnvironments = getCmdOption(_argc, _argv, DONT_SEND_ENVIRONMENTS); if (dontSendEnvironments) { qDebug("Sending environments suppressed...\n"); _sendEnvironments = false; } else { // should we send environments? Default is yes, but this command line suppresses sending const char* MINIMAL_ENVIRONMENT = "--MinimalEnvironment"; _sendMinimalEnvironment = getCmdOption(_argc, _argv, MINIMAL_ENVIRONMENT); qDebug("Using Minimal Environment=%s\n", debug::valueOf(_sendMinimalEnvironment)); } qDebug("Sending environments=%s\n", debug::valueOf(_sendEnvironments)); NodeList* nodeList = NodeList::getInstance(); nodeList->setOwnerType(NODE_TYPE_VOXEL_SERVER); setvbuf(stdout, NULL, _IOLBF, 0); // tell our NodeList about our desire to get notifications nodeList->addHook(&_nodeWatcher); nodeList->linkedDataCreateCallback = &attachVoxelNodeDataToNode; nodeList->startSilentNodeRemovalThread(); srand((unsigned)time(0)); const char* DISPLAY_VOXEL_STATS = "--displayVoxelStats"; _displayVoxelStats = getCmdOption(_argc, _argv, DISPLAY_VOXEL_STATS); qDebug("displayVoxelStats=%s\n", debug::valueOf(_displayVoxelStats)); const char* DEBUG_VOXEL_SENDING = "--debugVoxelSending"; _debugVoxelSending = getCmdOption(_argc, _argv, DEBUG_VOXEL_SENDING); qDebug("debugVoxelSending=%s\n", debug::valueOf(_debugVoxelSending)); const char* DEBUG_VOXEL_RECEIVING = "--debugVoxelReceiving"; _debugVoxelReceiving = getCmdOption(_argc, _argv, DEBUG_VOXEL_RECEIVING); qDebug("debugVoxelReceiving=%s\n", debug::valueOf(_debugVoxelReceiving)); const char* WANT_ANIMATION_DEBUG = "--shouldShowAnimationDebug"; _shouldShowAnimationDebug = getCmdOption(_argc, _argv, WANT_ANIMATION_DEBUG); qDebug("shouldShowAnimationDebug=%s\n", debug::valueOf(_shouldShowAnimationDebug)); // By default we will voxel persist, if you want to disable this, then pass in this parameter const char* NO_VOXEL_PERSIST = "--NoVoxelPersist"; if (getCmdOption(_argc, _argv, NO_VOXEL_PERSIST)) { _wantVoxelPersist = false; } qDebug("wantVoxelPersist=%s\n", debug::valueOf(_wantVoxelPersist)); // if we want Voxel Persistence, load the local file now... bool persistantFileRead = false; if (_wantVoxelPersist) { // Check to see if the user passed in a command line option for setting packet send rate const char* VOXELS_PERSIST_FILENAME = "--voxelsPersistFilename"; const char* voxelsPersistFilenameParameter = getCmdOption(_argc, _argv, VOXELS_PERSIST_FILENAME); if (voxelsPersistFilenameParameter) { strcpy(_voxelPersistFilename, voxelsPersistFilenameParameter); } else { //strcpy(voxelPersistFilename, _wantLocalDomain ? LOCAL_VOXELS_PERSIST_FILE : VOXELS_PERSIST_FILE); strcpy(_voxelPersistFilename, LOCAL_VOXELS_PERSIST_FILE); } qDebug("loading voxels from file: %s...\n", _voxelPersistFilename); persistantFileRead = _serverTree.readFromSVOFile(_voxelPersistFilename); if (persistantFileRead) { PerformanceWarning warn(_shouldShowAnimationDebug, "persistVoxelsWhenDirty() - reaverageVoxelColors()", _shouldShowAnimationDebug); // after done inserting all these voxels, then reaverage colors _serverTree.reaverageVoxelColors(_serverTree.rootNode); qDebug("Voxels reAveraged\n"); } _serverTree.clearDirtyBit(); // the tree is clean since we just loaded it qDebug("DONE loading voxels from file... fileRead=%s\n", debug::valueOf(persistantFileRead)); unsigned long nodeCount = _serverTree.rootNode->getSubTreeNodeCount(); unsigned long internalNodeCount = _serverTree.rootNode->getSubTreeInternalNodeCount(); unsigned long leafNodeCount = _serverTree.rootNode->getSubTreeLeafNodeCount(); qDebug("Nodes after loading scene %lu nodes %lu internal %lu leaves\n", nodeCount, internalNodeCount, leafNodeCount); // now set up VoxelPersistThread _voxelPersistThread = new VoxelPersistThread(&_serverTree, _voxelPersistFilename); if (_voxelPersistThread) { _voxelPersistThread->initialize(true); } } // Check to see if the user passed in a command line option for loading an old style local // Voxel File. If so, load it now. This is not the same as a voxel persist file const char* INPUT_FILE = "-i"; const char* voxelsFilename = getCmdOption(_argc, _argv, INPUT_FILE); if (voxelsFilename) { _serverTree.readFromSVOFile(voxelsFilename); } // Check to see if the user passed in a command line option for setting packet send rate const char* PACKETS_PER_SECOND = "--packetsPerSecond"; const char* packetsPerSecond = getCmdOption(_argc, _argv, PACKETS_PER_SECOND); if (packetsPerSecond) { _packetsPerClientPerInterval = atoi(packetsPerSecond) / INTERVALS_PER_SECOND; if (_packetsPerClientPerInterval < 1) { _packetsPerClientPerInterval = 1; } qDebug("packetsPerSecond=%s PACKETS_PER_CLIENT_PER_INTERVAL=%d\n", packetsPerSecond, _packetsPerClientPerInterval); } // for now, initialize the environments with fixed values _environmentData[1].setID(1); _environmentData[1].setGravity(1.0f); _environmentData[1].setAtmosphereCenter(glm::vec3(0.5, 0.5, (0.25 - 0.06125)) * (float)TREE_SCALE); _environmentData[1].setAtmosphereInnerRadius(0.030625f * TREE_SCALE); _environmentData[1].setAtmosphereOuterRadius(0.030625f * TREE_SCALE * 1.05f); _environmentData[2].setID(2); _environmentData[2].setGravity(1.0f); _environmentData[2].setAtmosphereCenter(glm::vec3(0.5f, 0.5f, 0.5f) * (float)TREE_SCALE); _environmentData[2].setAtmosphereInnerRadius(0.1875f * TREE_SCALE); _environmentData[2].setAtmosphereOuterRadius(0.1875f * TREE_SCALE * 1.05f); _environmentData[2].setScatteringWavelengths(glm::vec3(0.475f, 0.570f, 0.650f)); // swaps red and blue sockaddr senderAddress; unsigned char* packetData = new unsigned char[MAX_PACKET_SIZE]; ssize_t packetLength; timeval lastDomainServerCheckIn = {}; // set up our jurisdiction broadcaster... _jurisdictionSender = new JurisdictionSender(_jurisdiction); if (_jurisdictionSender) { _jurisdictionSender->initialize(true); } // set up our VoxelServerPacketProcessor _voxelServerPacketProcessor = new VoxelServerPacketProcessor(this); if (_voxelServerPacketProcessor) { _voxelServerPacketProcessor->initialize(true); } // loop to send to nodes requesting data while (true) { if (NodeList::getInstance()->getNumNoReplyDomainCheckIns() == MAX_SILENT_DOMAIN_SERVER_CHECK_INS) { break; } // send a check in packet to the domain server if DOMAIN_SERVER_CHECK_IN_USECS has elapsed if (usecTimestampNow() - usecTimestamp(&lastDomainServerCheckIn) >= DOMAIN_SERVER_CHECK_IN_USECS) { gettimeofday(&lastDomainServerCheckIn, NULL); NodeList::getInstance()->sendDomainServerCheckIn(_uuid.toRfc4122().constData()); } if (nodeList->getNodeSocket()->receive(&senderAddress, packetData, &packetLength) && packetVersionMatch(packetData)) { int numBytesPacketHeader = numBytesForPacketHeader(packetData); if (packetData[0] == PACKET_TYPE_HEAD_DATA) { // If we got a PACKET_TYPE_HEAD_DATA, then we're talking to an NODE_TYPE_AVATAR, and we // need to make sure we have it in our nodeList. uint16_t nodeID = 0; unpackNodeId(packetData + numBytesPacketHeader, &nodeID); Node* node = NodeList::getInstance()->addOrUpdateNode(&senderAddress, &senderAddress, NODE_TYPE_AGENT, nodeID); NodeList::getInstance()->updateNodeWithData(node, packetData, packetLength); VoxelNodeData* nodeData = (VoxelNodeData*) node->getLinkedData(); if (nodeData && !nodeData->isVoxelSendThreadInitalized()) { nodeData->initializeVoxelSendThread(this); } } else if (packetData[0] == PACKET_TYPE_PING) { // If the packet is a ping, let processNodeData handle it. NodeList::getInstance()->processNodeData(&senderAddress, packetData, packetLength); } else if (packetData[0] == PACKET_TYPE_DOMAIN) { NodeList::getInstance()->processNodeData(&senderAddress, packetData, packetLength); } else if (packetData[0] == PACKET_TYPE_VOXEL_JURISDICTION_REQUEST) { if (_jurisdictionSender) { _jurisdictionSender->queueReceivedPacket(senderAddress, packetData, packetLength); } } else if (_voxelServerPacketProcessor) { _voxelServerPacketProcessor->queueReceivedPacket(senderAddress, packetData, packetLength); } else { qDebug("unknown packet ignored... packetData[0]=%c\n", packetData[0]); } } } delete _jurisdiction; if (_jurisdictionSender) { _jurisdictionSender->terminate(); delete _jurisdictionSender; } if (_voxelServerPacketProcessor) { _voxelServerPacketProcessor->terminate(); delete _voxelServerPacketProcessor; } if (_voxelPersistThread) { _voxelPersistThread->terminate(); delete _voxelPersistThread; } // tell our NodeList we're done with notifications nodeList->removeHook(&_nodeWatcher); pthread_mutex_destroy(&_treeLock); }
bg_shm_t * bg_shm_alloc_write(int size) { int shm_fd = -1; void * addr; bg_shm_t * ret = NULL; char name[SHM_NAME_MAX]; int id = 0; pthread_mutexattr_t attr; int real_size = get_real_size(size); while(1) { id++; gen_name(id, name); if((shm_fd = shm_open(name, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) < 0) { if(errno != EEXIST) { bg_log(BG_LOG_ERROR, LOG_DOMAIN, "shm_open of %s failed: %s", name, strerror(errno)); return NULL; } } else break; } if(ftruncate(shm_fd, real_size)) { bg_log(BG_LOG_ERROR, LOG_DOMAIN, "ftruncate failed: %s", strerror(errno)); goto fail; } if((addr = mmap(0, real_size, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0)) == MAP_FAILED) { bg_log(BG_LOG_ERROR, LOG_DOMAIN, "mmap failed: %s", strerror(errno)); return NULL; } ret = calloc(1, sizeof(*ret)); ret->addr = addr; ret->size = size; ret->id = id; ret->wr = 1; ret->rc = (refcounter_t*)(ret->addr + align_size(size)); /* Initialize process shared mutex */ pthread_mutexattr_init(&attr); if(pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED)) { bg_log(BG_LOG_ERROR, LOG_DOMAIN, "cannot create process shared mutex: %s", strerror(errno)); goto fail; } pthread_mutex_init(&ret->rc->mutex, &attr); bg_log(BG_LOG_DEBUG, LOG_DOMAIN, "created shm segment (write) %s", name); ret->rc->refcount = 0; fail: close(shm_fd); return ret; }
/* * Initialize the Interprocess Communication system and its * associated shared memory structure. It first creates a * temporary file using either the mkstemp() function or the * tempnam() and open() functions. If the process model is in * use,it than sets the file large enough to hold the * filebench_shm and an additional Megabyte. The file is then * memory mapped. If the process model is not in use, it simply * mallocs a region of sizeof (filebench_shm_t). * * Once the shared memory region / file is created, ipc_init * initializes various locks pointers, and variables in the * shared memory. It also uses ftok() to get a shared memory * semaphore key for later use in allocating shared semaphores. */ void ipc_init(void) { filebench_shm_t *buf = malloc(MB); key_t key; caddr_t c1; caddr_t c2; int semid; #ifdef HAVE_MKSTEMP shmpath = (char *)malloc(128); (void) strcpy(shmpath, "/var/tmp/fbenchXXXXXX"); shmfd = mkstemp(shmpath); #else shmfd = open(shmpath, O_CREAT | O_RDWR | O_TRUNC, 0666); shmpath = tempnam("/var/tmp", "fbench"); #endif /* HAVE_MKSTEMP */ #ifdef USE_PROCESS_MODEL if (shmfd < 0) { filebench_log(LOG_FATAL, "Cannot open shm %s: %s", shmpath, strerror(errno)); exit(1); } (void) lseek(shmfd, sizeof (filebench_shm_t), SEEK_SET); if (write(shmfd, buf, MB) != MB) { filebench_log(LOG_FATAL, "Cannot allocate shm: %s", strerror(errno)); exit(1); } /* LINTED E_BAD_PTR_CAST_ALIGN */ if ((filebench_shm = (filebench_shm_t *)mmap((caddr_t)0, sizeof (filebench_shm_t), PROT_READ | PROT_WRITE, MAP_SHARED, shmfd, 0)) == NULL) { filebench_log(LOG_FATAL, "Cannot mmap shm"); exit(1); } #else if ((filebench_shm = (filebench_shm_t *)malloc(sizeof (filebench_shm_t))) == NULL) { filebench_log(LOG_FATAL, "Cannot malloc shm"); exit(1); } #endif /* USE_PROCESS_MODEL */ c1 = (caddr_t)filebench_shm; c2 = (caddr_t)&filebench_shm->marker; (void) memset(filebench_shm, 0, c2 - c1); filebench_shm->epoch = gethrtime(); filebench_shm->debug_level = 2; filebench_shm->string_ptr = &filebench_shm->strings[0]; filebench_shm->shm_ptr = (char *)filebench_shm->shm_addr; filebench_shm->path_ptr = &filebench_shm->filesetpaths[0]; /* Setup mutexes for object lists */ (void) pthread_mutex_init(&filebench_shm->fileset_lock, ipc_mutexattr()); (void) pthread_mutex_init(&filebench_shm->procflow_lock, ipc_mutexattr()); (void) pthread_mutex_init(&filebench_shm->threadflow_lock, ipc_mutexattr()); (void) pthread_mutex_init(&filebench_shm->flowop_lock, ipc_mutexattr()); (void) pthread_mutex_init(&filebench_shm->msg_lock, ipc_mutexattr()); (void) pthread_mutex_init(&filebench_shm->eventgen_lock, ipc_mutexattr()); (void) pthread_mutex_init(&filebench_shm->malloc_lock, ipc_mutexattr()); (void) pthread_mutex_init(&filebench_shm->ism_lock, ipc_mutexattr()); (void) pthread_cond_init(&filebench_shm->eventgen_cv, ipc_condattr()); (void) pthread_rwlock_init(&filebench_shm->flowop_find_lock, ipc_rwlockattr()); (void) pthread_rwlock_init(&filebench_shm->run_lock, ipc_rwlockattr()); (void) pthread_rwlock_rdlock(&filebench_shm->run_lock); (void) ipc_mutex_lock(&filebench_shm->ism_lock); /* Create semaphore */ if ((key = ftok(shmpath, 1)) < 0) { filebench_log(LOG_ERROR, "cannot create sem: %s", strerror(errno)); exit(1); } if ((semid = semget(key, 0, 0)) != -1) (void) semctl(semid, 0, IPC_RMID); filebench_shm->semkey = key; filebench_shm->log_fd = -1; filebench_shm->dump_fd = -1; filebench_shm->eventgen_hz = 0; filebench_shm->shm_id = -1; free(buf); }
int32_t dt_camera_capture_job_run(dt_job_t *job) { dt_camera_capture_t *t=(dt_camera_capture_t*)job->param; int total; char message[512]= {0}; double fraction=0; total = t->total = t->brackets ? t->count * t->brackets : t->count; snprintf(message, 512, ngettext ("capturing %d image", "capturing %d images", total), total ); pthread_mutex_init(&t->mutex, NULL); pthread_cond_init(&t->done, NULL); // register listener dt_camctl_listener_t *listener; listener = g_malloc(sizeof(dt_camctl_listener_t)); memset(listener, 0, sizeof(dt_camctl_listener_t)); listener->data=t; listener->image_downloaded=_camera_capture_image_downloaded; listener->request_image_path=_camera_request_image_path; listener->request_image_filename=_camera_request_image_filename; dt_camctl_register_listener(darktable.camctl, listener); /* try to get exp program mode for nikon */ char *expprogram = (char *)dt_camctl_camera_get_property(darktable.camctl, NULL, "expprogram"); /* if fail, lets try fetching mode for cannon */ if(!expprogram) expprogram = (char *)dt_camctl_camera_get_property(darktable.camctl, NULL, "autoexposuremode"); /* Fetch all values for shutterspeed and initialize current value */ GList *values=NULL; gconstpointer original_value=NULL; const char *cvalue = dt_camctl_camera_get_property(darktable.camctl, NULL, "shutterspeed"); const char *value = dt_camctl_camera_property_get_first_choice(darktable.camctl, NULL, "shutterspeed"); /* get values for bracketing */ if (t->brackets && expprogram && expprogram[0]=='M' && value && cvalue) { do { // Add value to list values = g_list_append(values, g_strdup(value)); // Check if current values is the same as original value, then lets store item ptr if (strcmp(value,cvalue) == 0) original_value = g_list_last(values)->data; } while ((value = dt_camctl_camera_property_get_next_choice(darktable.camctl, NULL, "shutterspeed")) != NULL); } else { /* if this was an intended bracket capture bail out */ if(t->brackets) { dt_control_log(_("please set your camera to manual mode first!")); return 1; } } /* create the bgjob plate */ const guint *jid = dt_control_backgroundjobs_create(darktable.control, 0, message); GList *current_value = g_list_find(values,original_value); for(uint32_t i=0; i<t->count; i++) { // Delay if active if(t->delay) g_usleep(t->delay*G_USEC_PER_SEC); for(uint32_t b=0; b<(t->brackets*2)+1; b++) { // If bracket capture, lets set change shutterspeed if (t->brackets) { if (b == 0) { // First bracket, step down time with (steps*brackets), also check so we never set the longest shuttertime which would be bulb mode for(uint32_t s=0; s<(t->steps*t->brackets); s++) if (g_list_next(current_value) && g_list_next(g_list_next(current_value))) current_value = g_list_next(current_value); } else { // Step up with (steps) for(uint32_t s=0; s<t->steps; s++) if(g_list_previous(current_value)) current_value = g_list_previous(current_value); } } // set the time property for bracket capture if (t->brackets && current_value) dt_camctl_camera_set_property_string(darktable.camctl, NULL, "shutterspeed", current_value->data); // Capture image dt_camctl_camera_capture(darktable.camctl,NULL); fraction += 1.0/total; dt_control_backgroundjobs_progress(darktable.control, jid, fraction); } // lets reset to original value before continue if (t->brackets) { current_value = g_list_find(values,original_value); dt_camctl_camera_set_property_string(darktable.camctl, NULL, "shutterspeed", current_value->data); } } /* wait for last image capture before exiting job */ pthread_mutex_lock(&t->mutex); pthread_cond_wait(&t->done, &t->mutex); pthread_mutex_unlock(&t->mutex); pthread_mutex_destroy(&t->mutex); pthread_cond_destroy(&t->done); /* cleanup */ dt_control_backgroundjobs_destroy(darktable.control, jid); dt_import_session_destroy(t->shared.session); dt_camctl_unregister_listener(darktable.camctl, listener); g_free(listener); // free values if(values) { g_list_free_full(values, g_free); } return 0; }
void sem_init(struct pthread_semaphore * semaphore, int init_count) { semaphore->counter = init_count; pthread_cond_init(&semaphore->waiting, NULL); pthread_mutex_init(&semaphore->crit, NULL); }
static int retrieve_segment(struct segment * seg) { char proc[256]; snprintf(proc, 256, "rsg%u", g_nodeId); prctl(PR_SET_NAME, proc, 0, 0, 0); int rv = -1; log_print(g_log, "retrieve_segment: trying to retrieve segment %s[%d - %d].", seg->name->full_name, 0, seg->num_chunks-1); pthread_mutex_lock(&g_lock); int retries = g_interest_attempts; int timeout_ms = g_timeout_ms; pthread_mutex_unlock(&g_lock); int ttl = MAX_TTL; if ((seg->opts->mode & CCNFDNB_USE_RETRIES) == CCNFDNB_USE_RETRIES) { retries = seg->opts->retries; } if ((seg->opts->mode & CCNFDNB_USE_TIMEOUT) == CCNFDNB_USE_TIMEOUT) { timeout_ms = seg->opts->timeout_ms; } if ((seg->opts->mode & CCNFDNB_USE_TTL) == CCNFDNB_USE_TTL) { ttl = seg->opts->ttl; } struct chunk chunk_window[MAX_INTEREST_PIPELINE]; PENTRY _pit_handles[MAX_INTEREST_PIPELINE]; int pit_to_chunk[PIT_SIZE]; memset(&pit_to_chunk, 0, sizeof(pit_to_chunk)); struct bitmap * window = bit_create(MAX_INTEREST_PIPELINE); struct bitmap * missing = bit_create(seg->num_chunks); char str[MAX_NAME_LENGTH], comp[MAX_NAME_LENGTH]; strncpy(str, seg->name->full_name, seg->name->len); int rtt_est = timeout_ms; int cwnd = 1; int ssthresh = DEFAULT_INTEREST_PIPELINE; int fullfilled = 0; int min_rtt_est = 10; int current_chunk = 0; cc_state state = SLOW_START; int tx; _segment_q_t seg_q; pthread_mutex_init(&seg_q.mutex, NULL); pthread_cond_init(&seg_q.cond, NULL); seg_q.rcv_window = 0; seg_q.max_window = &cwnd; seg_q.rcv_chunks = linked_list_init(NULL); seg_q.base = seg->name; ccnfdnl_reg_segment(&seg_q); int i; window->num_bits = cwnd; while (!bit_allSet(missing)) { tx = cwnd; window->num_bits = cwnd; log_debug(g_log, "state = %d, cwnd = %d, ssthresh = %d rtt_est = %d", state, cwnd, ssthresh, rtt_est); while (tx && (current_chunk < seg->num_chunks)) { snprintf(comp, MAX_NAME_LENGTH - seg->name->len, "/%d", current_chunk); strncpy(str + seg->name->len, comp, seg->name->len); i = bit_find(window); if (i < 0 || i >= MAX_INTEREST_PIPELINE) { /* we must still be waiting for data */ break; } chunk_window[i].intr.name = content_name_create(str); chunk_window[i].intr.ttl = ttl; chunk_window[i].seq_no = current_chunk; chunk_window[i].retries = retries; _pit_handles[i] = PIT_get_handle(chunk_window[i].intr.name); if (!_pit_handles[i]) { bit_clear(window, i); break; } pit_to_chunk[_pit_handles[i]->index] = i; pthread_mutex_unlock(_pit_handles[i]->mutex); struct content_obj * co = CS_get(chunk_window[i].intr.name); if (!co) { log_debug(g_log, "expressing new interest: %s", chunk_window[i].intr.name->full_name); ccnfdnb_fwd_interest(&chunk_window[i].intr); tx--; } else { log_debug(g_log, "retrieved %s from CS", co->name->full_name); PENTRY pe = PIT_exact_match(chunk_window[i].intr.name); *pe->obj = co; pthread_mutex_unlock(pe->mutex); pthread_mutex_lock(&seg_q.mutex); linked_list_append(seg_q.rcv_chunks, pe); seg_q.rcv_window++; pthread_mutex_unlock(&seg_q.mutex); } current_chunk++; } log_debug(g_log, "tx window full"); pthread_mutex_lock(&seg_q.mutex); if (seg_q.rcv_chunks->len == 0) { struct timespec wait; ts_fromnow(&wait); ts_addms(&wait, 2 * rtt_est); rv = pthread_cond_timedwait(&seg_q.cond, &seg_q.mutex, &wait); if ((rv == ETIMEDOUT) && !seg_q.rcv_chunks->len) { /* we timed out, we need to rtx */ rtt_est += rtt_est / 2; if (rtt_est > PIT_LIFETIME_MS) rtt_est = PIT_LIFETIME_MS / 2; } } else { int pit_ages = 0; int pits_fulfilled = 0; while (seg_q.rcv_chunks->len > 0) { PENTRY pe = linked_list_remove(seg_q.rcv_chunks, 0); log_assert(g_log, pe != NULL, "invalid pit entry"); pthread_mutex_lock(pe->mutex); log_debug(g_log, "pit entry %s fulfilled", (*pe->obj)->name->full_name); int chunk_id = pit_to_chunk[pe->index]; log_assert(g_log, chunk_id >= 0, "invalid chunk id"); if (chunk_window[chunk_id].seq_no == 0) { seg->obj->publisher = (*pe->obj)->publisher; seg->obj->timestamp = (*pe->obj)->timestamp; seg->chunk_size = (*pe->obj)->size; } int offset = chunk_window[chunk_id].seq_no * seg->chunk_size; memcpy(&seg->obj->data[offset], (*pe->obj)->data, (*pe->obj)->size); content_obj_destroy(*pe->obj); struct timespec now; ts_fromnow(&now); ts_addms(&now, PIT_LIFETIME_MS); pit_ages += PIT_age(pe); pits_fulfilled++; pit_to_chunk[pe->index] = -1; PIT_release(pe); free(_pit_handles[chunk_id]); _pit_handles[chunk_id] = NULL; bit_clear(window, chunk_id); bit_set(missing, chunk_window[chunk_id].seq_no); log_debug(g_log, "retrieved chunk %s", chunk_window[chunk_id].intr.name->full_name); content_name_delete(chunk_window[chunk_id].intr.name); chunk_window[chunk_id].intr.name = NULL; cwnd++; if (state == CONG_AVOID) fullfilled++; } rtt_est -= floor(pit_ages / pits_fulfilled); if (rtt_est < min_rtt_est) rtt_est = min_rtt_est; } pthread_mutex_unlock(&seg_q.mutex); for (i = 0; i < MAX_INTEREST_PIPELINE; i++) { if (bit_test(window, i)) { if (!_pit_handles[i]) { continue; } pthread_mutex_lock(_pit_handles[i]->mutex); if (PIT_age(_pit_handles[i]) > (2 * rtt_est)) { PIT_refresh(_pit_handles[i]); chunk_window[i].retries--; ccnfdnb_fwd_interest(&chunk_window[i].intr); log_debug(g_log, "rtx interest: %s (rtt = %d)", chunk_window[i].intr.name->full_name, rtt_est); ssthresh = cwnd / 2 + 1; cwnd = 1; state = SLOW_START; } pthread_mutex_unlock(_pit_handles[i]->mutex); } } if ((cwnd >= ssthresh) && (state == SLOW_START)) state = CONG_AVOID; if (state == SLOW_START) fullfilled = 0; if ((fullfilled == cwnd) && (state == CONG_AVOID)) { cwnd++; fullfilled = 0; } if (cwnd > MAX_INTEREST_PIPELINE) cwnd = MAX_INTEREST_PIPELINE; /*log_debug(g_log, "cwnd = %d, ssthresh = %d", cwnd, ssthresh);*/ } log_debug(g_log, "retrieve_segment: finished for %s[%d-%d]", seg->name->full_name, 0, seg->num_chunks-1); rv = 0; PIT_print(); ccnfdnl_unreg_segment(&seg_q); pthread_mutex_destroy(&seg_q.mutex); pthread_cond_destroy(&seg_q.cond); while (seg_q.rcv_chunks->len) { PENTRY pe = linked_list_remove(seg_q.rcv_chunks, 0); content_obj_destroy(*pe->obj); PIT_release(pe); } bit_destroy(window); bit_destroy(missing); return rv; }
mlt_slices mlt_slices_init( int threads, int policy, int priority ) { pthread_attr_t tattr; struct sched_param param; mlt_slices ctx = (mlt_slices)calloc( 1, sizeof( struct mlt_slices_s ) ); char *env = getenv( ENV_SLICES ); #ifdef _WIN32 int cpus = GetCurrentProcessorNumber( ); #else int cpus = sysconf( _SC_NPROCESSORS_ONLN ); #endif int i, env_val = env ? atoi(env) : 0; /* check given threads count */ if ( !env || !env_val ) { if ( threads < 0 ) threads = -threads * cpus; else if ( !threads ) threads = cpus; } else if ( env_val < 0 ) { if ( threads < 0 ) threads = env_val * threads * cpus; else if ( !threads ) threads = -env_val * cpus; else threads = -env_val * threads; } else // env_val > 0 { if ( threads < 0 ) threads = env_val * threads; else if ( !threads ) threads = env_val; else threads = threads; } if ( threads > MAX_SLICES ) threads = MAX_SLICES; ctx->count = threads; /* init attributes */ pthread_mutex_init ( &ctx->cond_mutex, NULL ); pthread_cond_init ( &ctx->cond_var_job, NULL ); pthread_cond_init ( &ctx->cond_var_ready, NULL ); pthread_attr_init( &tattr ); pthread_attr_setschedpolicy( &tattr, policy ); param.sched_priority = priority; pthread_attr_setschedparam( &tattr, ¶m ); /* run worker threads */ for ( i = 0; i < ctx->count; i++ ) { pthread_create( &ctx->threads[i], &tattr, mlt_slices_worker, ctx ); pthread_setschedparam( ctx->threads[i], policy, ¶m); } pthread_attr_destroy( &tattr ); /* ready wait workers */ pthread_mutex_lock( &ctx->cond_mutex ); while ( ctx->readys != ctx->count ) pthread_cond_wait( &ctx->cond_var_ready, &ctx->cond_mutex ); pthread_mutex_unlock( &ctx->cond_mutex ); /* return context */ return ctx; }
int main( int argc , char *argv[]) { signal(SIGINT, ctrlHandler); n_linhas = linhas("localdns.txt"); #ifdef DEBUG printf("Verificacao dos ficheiros presentes.\n"); #endif if(verifica_ficheiros("localdns.txt") == 0) { printf("Ficheiro localdns.txt inexistente!\n"); exit(1); } if(verifica_ficheiros("config.txt") == 0) { printf("Ficheiro config.txt inexistente!\n"); exit(1); } #ifdef DEBUG printf("Inicializacoes.\n"); #endif unsigned char buf[65536], *reader, *reader2, qname; int sockfd, stop; struct DNS_HEADER *dns = NULL; struct stats stat; struct sockaddr_in servaddr, dest; socklen_t len; int i, np, r; cfg_process = 1; stats_process = 1; pthread_mutex_init(&mutex, NULL); pthread_cond_init(&cond, NULL); #ifdef DEBUG printf("Criacao das Filas Normal e Prioridade e da lista de Domains locais.\n"); #endif Fila fila_normal = cria_fila(); Fila fila_prioridade = cria_fila(); Local l_domains = cria_lista(); // Hora de arranque do Servidor time_t clk = time(NULL); strcpy(stat.data_hora_arranque, ctime(&clk)); // Inicializaco Memoria Partilhada init_shm(); ptr_config->flag = 0; printf("[PAI - MAIN] PID Main = %d PID DO MEU PAI = %d\n", getpid(), getppid()); char* data; #ifdef DEBUG printf("Criacao processo de configuracoes.\n"); #endif if ((cfg_process = fork()) == 0) { signal(SIGUSR1, handler_CFG); #ifdef DEBUG printf("RELEASE CFG.\n"); printf("Mapeamento de localdns.txt.\n"); #endif mapear("localdns.txt"); #ifdef DEBUG printf("Leitura de config.txt para estrutura em memoria partilhada.\n"); #endif file2memory("config.txt"); if(signal(SIGALRM, SIG_IGN) == SIG_ERR) { perror("SIGALRM Ignore error"); exit(1); } } else { usleep(200000); if(signal(SIGUSR1, SIG_IGN) == SIG_ERR) { perror("Signal ignore error"); exit(1); } #ifdef DEBUG printf("RELEASE MAIN.\n"); #endif #ifdef DEBUG printf("Extrair enderecos e ip's locais do mmap\n"); #endif token_mmap(l_domains, ptr_config->data); // Check arguments if(argc <= 1) { printf("Usage: %s <port>\n", argv[0]); exit(1); } // Get server UDP port number int port = atoi(argv[1]); if(port <= 0) { printf("Usage: %s <port>\n", argv[0]); exit(1); } // **************************************** // Create socket & bind // **************************************** // Create UDP socket sockfd = socket(AF_INET , SOCK_DGRAM , IPPROTO_UDP); //UDP packet for DNS queries if (sockfd < 0) { printf("ERROR opening socket.\n"); exit(1); } // Prepare UDP to bind port bzero(&servaddr,sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr=htonl(INADDR_ANY); servaddr.sin_port=htons(port); // **************************************** // Receive questions // **************************************** // Bind application to UDP port int res = bind(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr)); if(res < 0) { printf("Error binding to port %d.\n", servaddr.sin_port); if(servaddr.sin_port <= 1024) { printf("To use ports below 1024 you may need additional permitions. Try to use a port higher than 1024.\n"); } else { printf("Please make sure this UDP port is not being used.\n"); } exit(1); } #ifdef DEBUG printf("Criacao named pipe para as estatisticas\n."); #endif char* n_pipe = ptr_config->Named_pipe; if(verifica_ficheiros(n_pipe) == 1) { printf("Named pipe ja existente! A eliminar...\n"); unlink(n_pipe); } if(((np = mkfifo(n_pipe, O_CREAT|O_EXCL|0600)<0)) && (errno != EEXIST)) { perror("mkfifo"); exit(1); } if (np != 0) { fprintf(stderr, "Impossivel criar fifo %s\n", n_pipe); return 1; } if((np = open(n_pipe, O_RDWR)) < 0) { perror("Opening Named Pipe"); exit(1); } } #ifdef DEBUG printf("A sair = %d\n", getpid()); #endif #ifdef DEBUG printf("Criacao Processo de estatisticas\n"); #endif if(cfg_process != 0) { stats_process = fork(); if(stats_process == 0) { if(signal(SIGUSR1, SIG_IGN) == SIG_ERR) { perror("Signal ignore error"); exit(1); } #ifdef DEBUG printf("RELEASE STATS.\n"); #endif } else { usleep(200000); if(signal(SIGALRM, SIG_IGN) == SIG_ERR) { perror("SIGALRM Ignore error"); exit(1); } } } #ifdef DEBUG printf("Quem chega primeiro = %d\n", getpid()); #endif if(cfg_process != 0 && stats_process != 0) { #ifdef DEBUG printf("A preencher struct para argumento da funcao do thread.\n"); #endif struct thread_data t_data; t_data.normal = fila_normal; t_data.prioridade = fila_prioridade; t_data.domains = l_domains; int N_THREADS = ptr_config->N_threads; p_threads = malloc(sizeof(*p_threads) * N_THREADS); #ifdef DEBUG printf("A criar a pool de threads.\n"); #endif for(i=0;i < N_THREADS;i++) { pthread_create(p_threads+i, NULL, requester, (void*)&t_data); } usleep(50000); printf("\n\n-- Waiting for DNS message --\n\n"); } while(1) { if((cfg_process == 0) && (ptr_config->saida == 1)) { // MODO MANUNTENCAO file2memory("config.txt"); ptr_config->saida = 0; usleep(100000); printf("\n-- Waiting for DNS message --\n"); } if(cfg_process != 0 && stats_process != 0) { // GESTOR PEDIDOS usleep(200000); len = sizeof(dest); // Thread blocking! if(recvfrom (sockfd, (unsigned char*)buf, 65536 , 0 , (struct sockaddr*)&dest , &len) < 0) { perror("Error in recvfrom"); exit(1); } printf("DNS message received\n"); // Process received message dns = (struct DNS_HEADER*) buf; qname = (unsigned char)buf[sizeof(struct DNS_HEADER)]; reader = &buf[sizeof(struct DNS_HEADER)]; // We only need to process the questions // We only process DNS messages with one question // Get the query fields according to the RFC specification struct QUERY query; if(ntohs(dns->q_count) == 1) { // Get NAME query.name = convertRFC2Name(reader,buf,&stop); reader = reader + stop; // Get QUESTION structure query.ques = (struct QUESTION*)(reader); reader = reader + sizeof(struct QUESTION); // Check question type. We only need to process A records. if(ntohs(query.ques->qtype) == 1) { printf("A record request.\n\n"); } else { printf("NOT A record request!! Ignoring DNS message!\n"); continue; } } else { printf("\n\nDNS message must contain one question!! Ignoring DNS message!\n\n"); continue; } #ifdef DEBUG printf("ID PEDIDO = %d\n", dns->id); #endif /***** VALIDAR PEDIDO *****/ valido = 0; // 1. Verificar se e' localDomain (Se for, vai para a lista prioritaria) // TRABALHO DOS THREADS... if(strstr(query.name, ptr_config->localDomain) != NULL) { valido = 1; stat.pedidos_local += 1; insere_pedido(fila_prioridade, receber_info(query.name, &dest, dns->id, sockfd)); } else if(ptr_config->flag % 2 == 0) { // 2. Verificar se é um dos dominios autorizados (ptr_config->domains[]) for(i=0; i < ptr_config->n_domains; i++) { if(strstr(query.name, ptr_config->domains[i]) != NULL) { valido = 1; stat.pedidos_externos += 1; insere_pedido(fila_normal, receber_info(query.name, &dest, dns->id, sockfd)); break; } } } #ifdef DEBUG imprimir_fila(fila_normal); imprimir_fila(fila_prioridade); #endif if(valido == 1) { #ifdef DEBUG printf("A ENVIAR SINAL PARA A THREAD...\n"); #endif pthread_cond_signal(&cond); } else { if(ptr_config->flag % 2 != 0) { printf("Durante o modo de manuntencao apenas pedidos locais sao aceites!\n"); printf("A enviar 0.0.0.0...\n"); } else { printf("Pedido negado!\nDe momento os dominios aceites sao:\n"); for(i=0;i<ptr_config->n_domains;i++) { printf("-> Dominio %d = %s\n",i,ptr_config->domains[i]); } } sendReply(dns->id, query.name, inet_addr("0.0.0.0"), sockfd, dest); printf("\n\n-- Waiting for DNS message --\n\n"); } if(valido == 0) { stat.pedidos_negados += 1; } stat.total_pedidos += 1; // Enviar dados das ESTATISTICAS para o named pipe aqui #ifdef DEBUG printf("A escrever estatisticas para o named pipe\n."); #endif write(np, &stat, sizeof(struct stats)); } if (stats_process == 0 && cfg_process != 0) { // STATS Process signal(SIGALRM, handler_alarm); Config* ptr; if ((ptr = shmat(shmID, NULL, 0)) == (Config *) -1) { perror("error in shmat"); exit(1); } struct stats st; char* n_pipe = ptr_config->Named_pipe; if((r = open(n_pipe, O_RDONLY)) < 0) { perror("Child open Named pipe"); exit(1); } read(r, &st, sizeof(struct stats)); linha(st.data_hora_arranque); time_t clk2 = time(NULL); strcpy(st.data_info, ctime(&clk2)); linha(st.data_info); t_p = st.total_pedidos; p_n = st.pedidos_negados; p_l = st.pedidos_local; p_e = st.pedidos_externos; strcpy(d_a, st.data_hora_arranque); strcpy(u_i, st.data_info); alarm(FREQ); } } return 0; }
int main(int argc, char **argv) { if (argc <= 1) { usage(argv[0]); exit(-1); } char ch; while ((ch = getopt(argc, argv, "t:b:d:s:l:w:o:rh")) != -1) { switch (ch) { // case 't': num_threads = atoi(optarg); break; case 't': num_threads = 1; break; //case 'b': num_mget = atoi(optarg); break; case 'd': duration = atof(optarg); break; case 's': serverip = optarg; break; case 'l': inputfile = optarg; break; case 'o': outputfolder = optarg; break; case 'w': workingset = optarg; break; case 'r': isreverse = true; break; case 'h': usage(argv[0]); exit(0); break; default: usage(argv[0]); exit(-1); } } if (serverip == NULL || inputfile == NULL || workingset == NULL) { usage(argv[0]); exit(-1); } request *requests = requests_init(inputfile); pthread_t threads[num_threads]; pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);; pthread_mutex_init(&printmutex, NULL); size_t t; thread_param tp[num_threads]; for (t = 0; t < num_threads; t++) { tp[t].requests = requests + t * (num_requests / num_threads); tp[t].tid = t; tp[t].num_ops = num_requests / num_threads; tp[t].num_puts = tp[t].num_gets = tp[t].num_miss = tp[t].num_hits = 0; tp[t].time = tp[t].tput = 0.0; int rc = pthread_create(&threads[t], &attr, requests_exec, (void *) &tp[t]); if (rc) { perror("failed: pthread_create\n"); exit(-1); } } result_t result; result.total_time = 0.0;; result.total_tput = 0.0; result.total_hits = 0; result.total_miss = 0; result.total_gets = 0; result.total_puts = 0; result.num_threads = num_threads; for (t = 0; t < num_threads; t++) { void *status; int rc = pthread_join(threads[t], &status); if (rc) { perror("error, pthread_join\n"); exit(-1); } result.total_time = (result.total_time > tp[t].time) ? result.total_time : tp[t].time; result.total_tput += tp[t].tput; result.total_hits += tp[t].num_hits; result.total_miss += tp[t].num_miss; result.total_gets += tp[t].num_gets; result.total_puts += tp[t].num_puts; } printf("total_time = %.2f\n", result.total_time); printf("total_tput = %.2f\n", result.total_tput); printf("total_hitratio = %.4f\n", (float) result.total_hits / result.total_gets); pthread_attr_destroy(&attr); printf("bye\n"); return 0; }
/** * Default Constructor **/ mutex_t() { pthread_mutex_init(&m_mutex, NULL); }
int psmx2_cntr_open(struct fid_domain *domain, struct fi_cntr_attr *attr, struct fid_cntr **cntr, void *context) { struct psmx2_fid_domain *domain_priv; struct psmx2_fid_cntr *cntr_priv; struct psmx2_fid_wait *wait = NULL; struct fi_wait_attr wait_attr; int wait_is_local = 0; int events; uint64_t flags; int err; events = FI_CNTR_EVENTS_COMP; flags = 0; domain_priv = container_of(domain, struct psmx2_fid_domain, domain); switch (attr->events) { case FI_CNTR_EVENTS_COMP: events = attr->events; break; default: FI_INFO(&psmx2_prov, FI_LOG_CQ, "attr->events=%d, supported=%d\n", attr->events, FI_CNTR_EVENTS_COMP); return -FI_EINVAL; } switch (attr->wait_obj) { case FI_WAIT_NONE: case FI_WAIT_UNSPEC: break; case FI_WAIT_SET: if (!attr->wait_set) { FI_INFO(&psmx2_prov, FI_LOG_CQ, "FI_WAIT_SET is specified but attr->wait_set is NULL\n"); return -FI_EINVAL; } wait = (struct psmx2_fid_wait *)attr->wait_set; break; case FI_WAIT_FD: case FI_WAIT_MUTEX_COND: wait_attr.wait_obj = attr->wait_obj; wait_attr.flags = 0; err = psmx2_wait_open(&domain_priv->fabric->fabric, &wait_attr, (struct fid_wait **)&wait); if (err) return err; wait_is_local = 1; break; default: FI_INFO(&psmx2_prov, FI_LOG_CQ, "attr->wait_obj=%d, supported=%d...%d\n", attr->wait_obj, FI_WAIT_NONE, FI_WAIT_MUTEX_COND); return -FI_EINVAL; } cntr_priv = (struct psmx2_fid_cntr *) calloc(1, sizeof *cntr_priv); if (!cntr_priv) { err = -FI_ENOMEM; goto fail; } psmx2_domain_acquire(domain_priv); cntr_priv->domain = domain_priv; cntr_priv->events = events; cntr_priv->wait = wait; cntr_priv->wait_is_local = wait_is_local; cntr_priv->flags = flags; cntr_priv->cntr.fid.fclass = FI_CLASS_CNTR; cntr_priv->cntr.fid.context = context; cntr_priv->cntr.fid.ops = &psmx2_fi_ops; cntr_priv->cntr.ops = &psmx2_cntr_ops; pthread_mutex_init(&cntr_priv->trigger_lock, NULL); *cntr = &cntr_priv->cntr; return 0; fail: if (wait && wait_is_local) fi_close(&wait->wait.fid); return err; }
/* ************************************** * initialize the list * ************************************** */ void list_init(list_t *list) { list->head = NULL; pthread_mutex_init(&list->lock,NULL); }
int coreaudio_player_alloc(struct auplay_st **stp, struct auplay *ap, struct auplay_prm *prm, const char *device, auplay_write_h *wh, void *arg) { AudioStreamBasicDescription fmt; struct auplay_st *st; uint32_t sampc, bytc, i; OSStatus status; int err; (void)device; st = mem_zalloc(sizeof(*st), auplay_destructor); if (!st) return ENOMEM; st->ap = mem_ref(ap); st->wh = wh; st->arg = arg; err = pthread_mutex_init(&st->mutex, NULL); if (err) goto out; err = audio_session_enable(); if (err) goto out; fmt.mSampleRate = (Float64)prm->srate; fmt.mFormatID = audio_fmt(prm->fmt); fmt.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked; #ifdef __BIG_ENDIAN__ fmt.mFormatFlags |= kAudioFormatFlagIsBigEndian; #endif fmt.mFramesPerPacket = 1; fmt.mBytesPerFrame = prm->ch * bytesps(prm->fmt); fmt.mBytesPerPacket = prm->ch * bytesps(prm->fmt); fmt.mChannelsPerFrame = prm->ch; fmt.mBitsPerChannel = 8*bytesps(prm->fmt); status = AudioQueueNewOutput(&fmt, play_handler, st, NULL, kCFRunLoopCommonModes, 0, &st->queue); if (status) { warning("coreaudio: AudioQueueNewOutput error: %i\n", status); err = ENODEV; goto out; } sampc = prm->srate * prm->ch * prm->ptime / 1000; bytc = sampc * bytesps(prm->fmt); for (i=0; i<ARRAY_SIZE(st->buf); i++) { status = AudioQueueAllocateBuffer(st->queue, bytc, &st->buf[i]); if (status) { err = ENOMEM; goto out; } st->buf[i]->mAudioDataByteSize = bytc; memset(st->buf[i]->mAudioData, 0, st->buf[i]->mAudioDataByteSize); (void)AudioQueueEnqueueBuffer(st->queue, st->buf[i], 0, NULL); } status = AudioQueueStart(st->queue, NULL); if (status) { warning("coreaudio: AudioQueueStart error %i\n", status); err = ENODEV; goto out; } out: if (err) mem_deref(st); else *stp = st; return err; }