/* * The buffers used for file data are allocated as a single big * malloc, and then each thread and operation takes a piece and uses * that for file data. This lets us do a large shm or bigpages alloc * and without trying to find a special place in each thread to map the * buffers to */ int setup_shared_mem(int num_threads, int num_files, int depth, int reclen, int max_io_submit) { char *p = NULL; size_t total_ram; padded_reclen = (reclen + page_size_mask) / (page_size_mask + 1); padded_reclen = padded_reclen * (page_size_mask + 1); total_ram = num_files * depth * padded_reclen + num_threads; if (verify) total_ram += padded_reclen; /* for aligning buffer after the allocation */ total_ram += page_size_mask; if (use_shm == USE_MALLOC) { p = malloc(total_ram); } else if (use_shm == USE_SHM) { shm_id = shmget(IPC_PRIVATE, total_ram, IPC_CREAT | 0700); if (shm_id < 0) { perror("shmget"); drop_shm(); goto free_buffers; } p = shmat(shm_id, (char *)0x50000000, 0); if ((long)p == -1) { perror("shmat"); goto free_buffers; } /* won't really be dropped until we shmdt */ drop_shm(); } else if (use_shm == USE_SHMFS) { char mmap_name[16]; /* /dev/shm/ + null + XXXXXX */ int fd; strcpy(mmap_name, "/dev/shm/XXXXXX"); fd = mkstemp(mmap_name); if (fd < 0) { perror("mkstemp"); goto free_buffers; } unlink(mmap_name); ftruncate(fd, total_ram); shm_id = fd; p = mmap((char *)0x50000000, total_ram, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if (p == MAP_FAILED) { perror("mmap"); goto free_buffers; } } if (!p) { fprintf(stderr, "unable to allocate buffers\n"); goto free_buffers; } unaligned_buffer = p; p = (char *)((intptr_t) (p + page_size_mask) & ~page_size_mask); aligned_buffer = p; return 0; free_buffers: drop_shm(); if (unaligned_buffer) free(unaligned_buffer); return -1; }
/** * Write udhcpd.conf * @ipforward : NULL if we want a simple config, otherwise include dns info etc... */ static int write_udhcpd_conf(struct ipforward_data *ipforward, struct mode_list_elem *data) { FILE *conffile; char *ip, *interface; char *ipstart, *ipend; int dot = 0, i = 0, test; struct stat st; /* /tmp is often tmpfs, so we avoid writing to flash */ conffile = fopen("/tmp/udhcpd.conf", "w"); if(conffile == NULL) { log_debug("Error creating /etc/udhcpd.conf!\n"); return(1); } /* generate start and end ip based on the setting */ ip = get_network_ip(); if(ip == NULL) { ip = strdup("192.168.2.15"); } ipstart = malloc(sizeof(char)*15); ipend = malloc(sizeof(char)*15); while(i < 15) { if(dot < 3) { if(ip[i] == '.') dot ++; ipstart[i] = ip[i]; ipend[i] = ip[i]; } else { ipstart[i] = '\0'; ipend[i] = '\0'; break; } i++; } strcat(ipstart,"1"); strcat(ipend, "10"); interface = get_interface(data); /* print all data in the file */ fprintf(conffile, "start\t%s\n", ipstart); fprintf(conffile, "end\t%s\n", ipend); fprintf(conffile, "interface\t%s\n", interface); fprintf(conffile, "option\tsubnet\t255.255.255.0\n"); if(ipforward != NULL) { if(!ipforward->dns1 || !ipforward->dns2) { log_debug("No dns info!"); } else fprintf(conffile, "opt\tdns\t%s %s\n", ipforward->dns1, ipforward->dns2); fprintf(conffile, "opt\trouter\t%s\n", ip); } free(ipstart); free(ipend); free(ip); free(interface); fclose(conffile); log_debug("/etc/udhcpd.conf written.\n"); /* check if it is a symlink, if not remove and link, create the link if missing */ test = stat("/etc/udhcpd.conf", &st); /* if stat fails there is no file or link */ if(test == -1) goto link; /* if it is not a link we remove it, else we expect the right link to be there */ if((st.st_mode & S_IFMT) != S_IFLNK) { unlink("/etc/udhcpd.conf"); } else goto end; link: symlink("/tmp/udhcpd.conf", "/etc/udhcpd.conf"); end: return(0); }
/* Main Function */ int main(int argc, char** argv) { /* Variables definitons*/ FILEPTR fPtrInput,fPtrOutput; pid_t pidtIsParent; char* chPtrWord; int iWordCount; int linesArray[MAXLINESIZE]; int* lines = &linesArray[0]; int i,j,totalFilesNum,totalTextFilesNum,tempLine; int lineOccur=0; CHPTR dirName; char chPtrFileName[LINESIZE]; FILEPTR fPtrFile; pid_t pidParent = getpid(); char filesFound[MAXLINESIZE][LINESIZE]; int txtFilesIndex[LINESIZE]; int stat; char tempChar[LINESIZE],ch,tch; char printLineStr[100]; int len; int printLineCount; struct sigaction act; int fd; char * myfifo = "/tmp/myfifo"; char fifoBuffer[4096]; /* Check Usage exclude print count */ if(!myUsage(argc, argv)) return 1; /* * Assignment directory name and print count * Check print count is vaild */ dirName = argv[1]; printLineCount=atoi(argv[5]); if(printLineCount<=0){ myUsage(printLineCount,argv); return 1; } act.sa_handler = setdoneflag; /* set up signal handler */ act.sa_flags = 0; if ((sigemptyset(&act.sa_mask) == -1) || (sigaction(SIGINT, &act, NULL) == -1)) { perror("Failed to set SIGINT handler"); return 1; } puts("Parent"); printf("%-8s %s\n","PID", "FILE NAME"); puts("=================================================================="); /* Find and record files,directories */ recDirWithFork(dirName,1,getpid()); /* Parent will print the contents of its own file and remove it */ if(getpid() == pidParent) { getFileName(chPtrFileName, dirName); fPtrFile = fopen(chPtrFileName, "r"); /* Assign loop total founded files and directories */ for(j=0,stat=fscanf(fPtrFile,"%s",filesFound[j]);stat!=EOF;++j,stat=fscanf(fPtrFile,"%s",filesFound[j])){} totalFilesNum=j; /* Assign loop total founded text files */ totalTextFilesNum=0; for(j=0;j<totalFilesNum;++j){ len=strlen(filesFound[j]); if (len > 4 && strcmp(filesFound[j] + len - 4, ".txt") == 0){ txtFilesIndex[totalTextFilesNum]=j; totalTextFilesNum++; } } /* Printing total founded text files to stdin */ puts("Total text files found:"); for(j=0;j<totalTextFilesNum;++j){ strcpy(tempChar,argv[1]); strcat(tempChar,filesFound[txtFilesIndex[j]]); strcpy(filesFound[txtFilesIndex[j]],tempChar); printf("%s\n",filesFound[txtFilesIndex[j]]); } /* * Close filepointer and delete total founded files * and directories file */ fclose(fPtrFile); unlink(chPtrFileName); /* * Record loop for word counts and lines * to the linesOutput.txt file */ for(j=0;j<totalTextFilesNum;++j){ /* Creating child process */ pidtIsParent = fork(); /* Setting the current process' argument. */ chPtrWord = argv[3]; /* If child process*/ if (!pidtIsParent) { /* Opening files */ fPtrInput = fopen(filesFound[txtFilesIndex[j]], "r"); fPtrOutput = fopen("fifoOutput.txt","a+"); /* Checking whether the files was opened */ if (fPtrInput == NULL) { fprintf(stderr, "Cannot open input file.\n"); return 2; } if(fPtrOutput==NULL){ fprintf(stderr, "Child process can not update the output file.\n"); return 2; } /* Getting the number of occurrences in files*/ iWordCount = findOccurrenceNum(fPtrInput, chPtrWord , lines); /* Printing to file the child processes information */ fprintf(fPtrOutput,"Word: %-20s Count: #%-5d pId: %-6d ppId:%-6d \n", chPtrWord, iWordCount, getpid(), getppid()); /* Member initilization before the loop */ tempLine=0; lineOccur=0; fprintf(fPtrOutput,"File:%s\n",filesFound[txtFilesIndex[j]]); /* Loop for record lines informations to the linesOutput.txt*/ for(i=0;i<iWordCount;++i){ if(i==0 && iWordCount!=1){ fprintf(fPtrOutput,"Lines are:\n"); tempLine=lines[0]; ++lineOccur; } else if(i==0 && iWordCount==1) fprintf(fPtrOutput,"Line Number %d Number of occurrences %d\n",lines[i],lineOccur+1); else if(i==iWordCount-1) fprintf(fPtrOutput,"Line Number %d Number of occurrences %d\n",lines[i],lineOccur+1); else{ if(tempLine==lines[i]){ ++lineOccur; } else{ fprintf(fPtrOutput,"Line Number %d Number of occurrences %d\n",lines[i-1],lineOccur); lineOccur=1; tempLine=lines[i]; } } } /* Safely closing the file pointers */ fclose(fPtrInput); fclose(fPtrOutput); /* Child processes ends */ return 0; } /* Waiting for the current child process */ while (childWait(NULL ) > 0); } /* Open linesOutput.txt files */ fPtrInput=fopen("fifoOutput.txt","r"); /* Checking whether the file was opened */ if(fPtrInput==NULL){ fprintf(stderr, "Parent process can not open the fifoOutput file.\n"); return 2; } /* * For separate founded text files list and * lines of word in the file */ puts("\n\n"); /* Make fifo */ if (mkfifo(myfifo, 0666) < 0) { if (errno != EEXIST) { perror("mkfifo"); exit(EXIT_FAILURE); } } /* Open fifo with read and write mode */ fd = open(myfifo, O_RDWR); /* Fifo read and write loop */ while(fgets(printLineStr,100,fPtrInput)!=NULL){ /* Child processes are read file line by line */ /* Write to the fifo */ int fifoStat; fifoStat = fork(); if(fifoStat<0){ perror("Fork "); exit(EXIT_FAILURE); } else if(!fifoStat){ write(fd, printLineStr, sizeof(printLineStr)); return 0; } else{ /* Child wait */ while (childWait(NULL) > 0); fPtrOutput=fopen("linesOutput.txt","a+"); /* Checking whether the file was opened */ if(fPtrOutput==NULL){ fprintf(stderr, "Parent process can not open the output file.\n"); return 2; } /* Parent Process read from fifo */ /* Write to the output file */ read(fd, fifoBuffer, 4096); fprintf(fPtrOutput,"%s",fifoBuffer); } } /* Safely close and unlink files,pointers and fifo */ unlink("fifoOutput.txt"); fclose(fPtrInput); fclose(fPtrOutput); unlink(myfifo); close(fd); /* Open linesOutput.txt files */ fPtrOutput=fopen("linesOutput.txt","r"); /* Checking whether the file was opened */ if(fPtrOutput==NULL){ fprintf(stderr, "Parent process can not open the output file.\n"); return 2; } /* Do-while loop print like less command in UNIX */ do{ /* Print lines loop*/ for(i=1;i<=printLineCount;++i){ if(fgets(printLineStr,100,fPtrOutput)!=NULL){ printf("%s",printLineStr); } /* If file is over */ else{ puts("FILE IS OVER...\n"); fclose(fPtrOutput); unlink("linesOutput.txt"); /* Printing the parent processes information */ printf("%s pId: %d \n", "\n\nDone parent.", getpid()); return 0; } } /* Like less command */ printf("MORE?"); ch=getchar(); if(ch!='\n') tch=getchar(); }while(ch!='q' && ch!='Q' && !doneflag); /* If q or Q pressed in do-while loop prints all file*/ while(fgets(printLineStr,100,fPtrOutput)!=NULL) printf("%s",printLineStr); /* File is over,safely close file pointer and */ /* delete linesOutput.txt file */ puts("FILE IS OVER...\n"); fclose(fPtrOutput); unlink("linesOutput.txt"); /* Printing the parent processes information */ printf("%s pId: %d \n", "\n\nDone parent.", getpid()); if(!doneflag) printf("Program is finished without CTRL + C signal\n"); else printf("Program is finished with CTRL + C signal\n"); } /* Program ends */ return 0; }
//move. void move_file() { //mv src dest //pathname = src //parameter = dest. //create a local copy of the file. char src[128]; char dest[128]; strcpy(src, pathname); strcpy(dest, parameter); //1.Verify that src exist and get the inode in. //Open the src file for read mode. strcpy(pathname, src); strcpy(parameter, "0"); int fd = open_file(); //check if the file is valid or not, if (fd == -1) { //File error printf("File error!\n"); exit(-1); } //if file is valid, get the INODE in. OFT* oftp_src = running->fd[fd]; MINODE* mip_src = oftp_src->minodeptr; /* //create a file at the destination location strcpy(pathname, dest); creat_file(); //open the file at the destination for write mode. strcpy(parameter, "1"); int gd = open_file(); //get the inode. OFT* oftp_dest = running->fd[fd]; MINODE* mip_dest = oftp_dest->minodeptr; */ //check if src and dest has the same dev.??? if (running->cwd->dev == mip_src->dev) { //Hard link dst with src. strcpy(pathname, src); strcpy(parameter, dest); link(); //unlink src //WARNING: syntax check unlink(); } else { //not the same dev, use copy strcpy(pathname, src); strcpy(parameter, dest); copy_file(); //unlink the src //WARNING: syntax check. unlink(); } }
int main (int argc, char **argv) { const char *filename = "test-fgetc.txt"; /* We don't have an fgetc() function that installs an invalid parameter handler so far. So install that handler here, explicitly. */ #if HAVE_MSVC_INVALID_PARAMETER_HANDLER \ && MSVC_INVALID_PARAMETER_HANDLING == DEFAULT_HANDLING gl_msvc_inval_ensure_handler (); #endif /* Prepare a file. */ { const char text[] = "hello world"; int fd = open (filename, O_RDWR | O_CREAT | O_TRUNC, 0600); ASSERT (fd >= 0); ASSERT (write (fd, text, sizeof (text)) == sizeof (text)); ASSERT (close (fd) == 0); } /* Test that fgetc() sets errno if someone else closes the stream fd behind the back of stdio. */ { FILE *fp = fopen (filename, "r"); ASSERT (fp != NULL); ASSERT (close (fileno (fp)) == 0); errno = 0; ASSERT (fgetc (fp) == EOF); ASSERT (errno == EBADF); ASSERT (ferror (fp)); fclose (fp); } /* Test that fgetc() sets errno if the stream was constructed with an invalid file descriptor. */ { FILE *fp = fdopen (-1, "r"); if (fp != NULL) { errno = 0; ASSERT (fgetc (fp) == EOF); ASSERT (errno == EBADF); ASSERT (ferror (fp)); fclose (fp); } } { FILE *fp; close (99); fp = fdopen (99, "r"); if (fp != NULL) { errno = 0; ASSERT (fgetc (fp) == EOF); ASSERT (errno == EBADF); ASSERT (ferror (fp)); fclose (fp); } } /* Clean up. */ unlink (filename); return 0; }
int main(int argc, char **argv) { int ctlfd, timerfd, alarm_nr, ret, srvfd; char buf[20]; char path[32]; struct event_queue *ev_q; printf("Starting alarm test\n"); /* standard 9ns stuff: clone and read it to get our path, ending up with the * ctlfd and timerfd for #A/aN/{ctl,timer}. if you plan to fork, you can * open CLOEXEC. */ ctlfd = open("#A/clone", O_RDWR | O_CLOEXEC); if (ctlfd < 0) { perror("Can't clone an alarm"); exit(-1); } ret = read(ctlfd, buf, sizeof(buf) - 1); if (ret <= 0) { if (!ret) printf("Got early EOF from ctl\n"); else perror("Can't read ctl"); exit(-1); } buf[ret] = 0; snprintf(path, sizeof(path), "#A/a%s/timer", buf); /* Don't open CLOEXEC if you want to post it to srv later */ timerfd = open(path, O_RDWR); if (timerfd < 0) { perror("Can't open timer"); exit(-1); } /* Since we're doing SPAM_PUBLIC later, we actually don't need a big ev_q. * But someone might copy/paste this and change a flag. */ register_ev_handler(EV_ALARM, handle_alarm, 0); if (!(ev_q = get_big_event_q())) { perror("Failed ev_q"); /* it'll actually PF if malloc fails */ exit(-1); } ev_q->ev_vcore = 0; /* I think this is all the flags we need; gotta write that dissertation * chapter (and event how-to)! We may get more than one event per alarm, if * we have concurrent preempts/yields. */ ev_q->ev_flags = EVENT_IPI | EVENT_SPAM_PUBLIC; /* Register the ev_q for our alarm */ ret = snprintf(path, sizeof(path), "evq %llx", ev_q); ret = write(ctlfd, path, ret); if (ret <= 0) { perror("Failed to write ev_q"); exit(-1); } /* Try to set, then cancel before it should go off */ ret = snprintf(buf, sizeof(buf), "%llx", read_tsc() + sec2tsc(1)); ret = write(timerfd, buf, ret); if (ret <= 0) { perror("Failed to set timer"); exit(-1); } ret = snprintf(buf, sizeof(buf), "cancel"); ret = write(ctlfd, buf, ret); if (ret <= 0) { perror("Failed to cancel timer"); exit(-1); } uthread_sleep(2); printf("No alarm should have fired yet\n"); /* Try to set and receive */ ret = snprintf(buf, sizeof(buf), "%llx", read_tsc() + sec2tsc(1)); ret = write(timerfd, buf, ret); if (ret <= 0) { perror("Failed to set timer"); exit(-1); } uthread_sleep(2); close(ctlfd); /* get crazy: post the timerfd to #s, then sleep (or even try to exit), and * then echo into it remotely! A few limitations: * - if the process is DYING, you won't be able to send an event to it. * - the process won't leave DYING til the srv file is removed. */ srvfd = open("#s/alarmtest", O_WRONLY | O_CREAT | O_EXCL, 0666); if (srvfd < 0) { perror("Failed to open srv file"); exit(-1); } ret = snprintf(buf, sizeof(buf), "%d", timerfd); ret = write(srvfd, buf, ret); if (ret <= 0) { perror("Failed to post timerfd"); exit(-1); } printf("Sleeping for 10 sec, try to echo 111 > '#s/alarmtest' now!\n"); uthread_sleep(10); ret = unlink("#s/alarmtest"); if (ret < 0) { perror("Failed to remove timerfd from #s, proc will never be freed"); exit(-1); } printf("Done\n"); return 0; }
/* * filter a buffer through an external DOS program * Bound to ^X # */ int filter_buffer(int f, int n) { int s; /* return status from CLI */ struct buffer *bp; /* pointer to buffer to zot */ char line[NLINE]; /* command line send to shell */ char tmpnam[NFILEN]; /* place to store real file name */ static char bname1[] = "fltinp"; static char filnam1[] = "fltinp"; static char filnam2[] = "fltout"; /* don't allow this command if restricted */ if (restflag) return resterr(); if (curbp->b_mode & MDVIEW) /* don't allow this command if */ return rdonly(); /* we are in read only mode */ #if VMS mlwrite("Not available under VMS"); return FALSE; #endif /* get the filter name and its args */ if ((s = mlreply("#", line, NLINE)) != TRUE) return s; /* setup the proper file names */ bp = curbp; xstrcpy(tmpnam, bp->b_fname); /* save the original name */ xstrcpy(bp->b_fname, bname1); /* set it to our new one */ /* write it out, checking for errors */ if (writeout(filnam1) != TRUE) { mlwrite("(Cannot write filter file)"); xstrcpy(bp->b_fname, tmpnam); return FALSE; } #if MSDOS strcat(line, " <fltinp >fltout"); movecursor(term.t_nrow - 1, 0); TTkclose(); shellprog(line); TTkopen(); sgarbf = TRUE; s = TRUE; #endif #if V7 | USG | BSD TTputc('\n'); /* Already have '\r' */ TTflush(); TTclose(); /* stty to old modes */ TTkclose(); strcat(line, " <fltinp >fltout"); system(line); TTopen(); TTkopen(); TTflush(); sgarbf = TRUE; s = TRUE; #endif /* on failure, escape gracefully */ if (s != TRUE || (readin(filnam2, FALSE) == FALSE)) { mlwrite("(Execution failed)"); xstrcpy(bp->b_fname, tmpnam); unlink(filnam1); unlink(filnam2); return s; } /* reset file name */ xstrcpy(bp->b_fname, tmpnam); /* restore name */ bp->b_flag |= BFCHG; /* flag it as changed */ /* and get rid of the temporary file */ unlink(filnam1); unlink(filnam2); return TRUE; }
// Called when the stream of observations has finished to allow the implementor to perform clean-up tasks. // This method is optional. void externalTraceProcessor_File::obsFinished() { //cout << "externalTraceProcessor_File::obsFinished() finished="<<finished<<endl; // Only perform finishing code if we haven't already finished if(finished) return; finished = true; // We're done writing the trace file, so close the stream traceFile.close(); // Execute the processing application ostringstream s; s << processorFName; for(list<string>::iterator b=beforeParams.begin(); b!=beforeParams.end(); b++) s << " \""<<*b<<"\""; s << " \""<<obsFName<<"\""; for(list<string>::iterator a=afterParams.begin(); a!=afterParams.end(); a++) s << " \""<<*a<<"\""; //cout << "Command = "<<s.str()<<endl; // In case the processor executable is linked with Sight, unset the mutex environment variables from // LoadTimeRegistry to make sure that they don't leak to the layout process common::LoadTimeRegistry::liftMutexes(); FILE* out = popen(s.str().c_str(), "r"); if(out == NULL) { cerr << "Failed to run command \""<<s.str()<<"\"!"<<endl; assert(0); } // Restore the LoadTimeRegistry mutexes common::LoadTimeRegistry::restoreMutexes(); // Read out the trace produced by the processor char line[10000]; while(fgets(line, 10000, out)) { //cout << "line=\""<<line<<"\""<<endl; // Split the line into its individual terms sight::common::escapedStr es(string(line), " ", sight::common::escapedStr::escaped); vector<string> terms = es.unescapeSplit(" "); map<string, string> ctxt, obs; map<string, anchor> obsAnchor; // Iterate over each term of this observation, adding each one into this observation's context, trace observation or anchors for(vector<string>::iterator t=terms.begin(); t!=terms.end(); t++) { //cout << "t=\""<<*t<<"\""<<endl; // Split the term into the key and the value sight::common::escapedStr es(string(*t), ":", sight::common::escapedStr::escaped); vector<string> kv = es.unescapeSplit(":"); assert(kv.size()==3); string type=kv[0]; string key =kv[1]; string val =kv[2]; // Identify the type of this term if(type == "ctxt") ctxt[key] = val; else if(type=="obs") obs[key] = val; else obsAnchor[key] = anchor(attrValue::parseInt(val)); } // Emit the observation /*cout << "ctxt="<<endl; for(map<string, string>::iterator c=ctxt.begin(); c!=ctxt.end(); c++) cout << " "<<c->first<<" => "<<c->second<<endl;*/ emitObservation(-1, ctxt, obs, obsAnchor); } //cout << "done"<<endl; pclose(out); // Delete the file that was provided as input to the command since it is no longer needed unlink(obsFName.c_str()); // Inform this trace's observers that it has finished traceObserver::obsFinished(); }
int main(void) { size_t num_bytes = sysconf(_SC_PAGESIZE); int fd = open("temp", O_CREAT | O_EXCL | O_RDWR); int* rpage; unlink("temp"); test_assert(fd >= 0); int magic = 0x5a5a5a5a; size_t i; for (i = 0; i < 3 * num_bytes / sizeof(magic); ++i) { pwrite64(fd, &magic, sizeof(magic), i * sizeof(magic)); } rpage = mmap(NULL, num_bytes, PROT_READ, MAP_SHARED, fd, 0); atomic_printf("rpage:%p\n", rpage); test_assert(rpage != MAP_FAILED); magic = 0xa5a5a5a5; for (i = 0; i < num_bytes / sizeof(magic); ++i) { pwrite64(fd, &magic, sizeof(magic), i * sizeof(magic)); } check_mapping(rpage, 0xa5a5a5a5, num_bytes / sizeof(*rpage)); magic = 0x5a5a5a5a; for (i = 0; i < num_bytes / sizeof(magic); ++i) { pwrite64(fd, &magic, sizeof(magic), i * sizeof(magic)); } check_mapping(rpage, 0x5a5a5a5a, num_bytes / sizeof(*rpage)); magic = 0xa5a5a5a5; for (i = 0; i < num_bytes / sizeof(magic); ++i) { pwrite64(fd, &magic, sizeof(magic), num_bytes + i * sizeof(magic)); } check_mapping(rpage, 0x5a5a5a5a, num_bytes / sizeof(*rpage)); magic = 0xdeadbeef; pwrite64(fd, &magic, sizeof(magic), num_bytes / 2); test_assert(rpage[num_bytes / (sizeof(magic) * 2)] == magic); test_assert(rpage[0] != magic); pwrite64(fd, &magic, sizeof(magic), num_bytes - 2); test_assert(rpage[num_bytes / sizeof(magic) - 1] == (int)0xbeef5a5a); rpage = mremap(rpage, num_bytes, 5 * num_bytes, MREMAP_MAYMOVE); for (i = 3 * num_bytes / sizeof(magic); i < 5 * num_bytes / sizeof(magic); ++i) { pwrite64(fd, &magic, sizeof(magic), i * sizeof(magic)); } check_mapping(&rpage[(3 * num_bytes) / sizeof(magic)], 0xdeadbeef, 2 * num_bytes / sizeof(*rpage)); munmap(rpage, 5 * num_bytes); // The case when all pages have been unmapped is special in the // implementation - make sure it gets sufficient coverage write(fd, &magic, sizeof(magic)); write(fd, &magic, sizeof(magic)); rpage = mmap(NULL, num_bytes, PROT_READ, MAP_SHARED, fd, 0); atomic_printf("rpage:%p\n", rpage); test_assert(rpage != MAP_FAILED); // This tests both that the monitor gets activated again if the page is // remapped and that `write` works on a monitored page. lseek(fd, 0, SEEK_SET); magic = 0xb6b6b6b6; for (i = 0; i < num_bytes / sizeof(magic); ++i) { write(fd, &magic, sizeof(magic)); } check_mapping(rpage, magic, num_bytes / sizeof(*rpage)); atomic_puts("EXIT-SUCCESS"); return 0; }
int main(int argc, char **argv) { int i; sigset_t set; #if ENABLE_LINUXDVB uint32_t adapter_mask; #endif int log_level = LOG_INFO; int log_options = TVHLOG_OPT_MILLIS | TVHLOG_OPT_STDERR | TVHLOG_OPT_SYSLOG; const char *log_debug = NULL, *log_trace = NULL; char buf[512]; main_tid = pthread_self(); /* Setup global mutexes */ pthread_mutex_init(&ffmpeg_lock, NULL); pthread_mutex_init(&fork_lock, NULL); pthread_mutex_init(&global_lock, NULL); pthread_mutex_init(&atomic_lock, NULL); pthread_cond_init(>imer_cond, NULL); /* Defaults */ tvheadend_webui_port = 9981; tvheadend_webroot = NULL; tvheadend_htsp_port = 9982; tvheadend_htsp_port_extra = 0; /* Command line options */ int opt_help = 0, opt_version = 0, opt_fork = 0, opt_firstrun = 0, opt_stderr = 0, opt_syslog = 0, opt_uidebug = 0, opt_abort = 0, opt_noacl = 0, opt_fileline = 0, opt_threadid = 0, opt_ipv6 = 0, opt_tsfile_tuner = 0, opt_dump = 0; const char *opt_config = NULL, *opt_user = NULL, *opt_group = NULL, *opt_logpath = NULL, *opt_log_debug = NULL, *opt_log_trace = NULL, *opt_pidpath = "/var/run/tvheadend.pid", #if ENABLE_LINUXDVB *opt_dvb_adapters = NULL, #endif *opt_bindaddr = NULL, *opt_subscribe = NULL; str_list_t opt_tsfile = { .max = 10, .num = 0, .str = calloc(10, sizeof(char*)) }; cmdline_opt_t cmdline_opts[] = { { 0, NULL, "Generic Options", OPT_BOOL, NULL }, { 'h', "help", "Show this page", OPT_BOOL, &opt_help }, { 'v', "version", "Show version infomation", OPT_BOOL, &opt_version }, { 0, NULL, "Service Configuration", OPT_BOOL, NULL }, { 'c', "config", "Alternate config path", OPT_STR, &opt_config }, { 'f', "fork", "Fork and run as daemon", OPT_BOOL, &opt_fork }, { 'u', "user", "Run as user", OPT_STR, &opt_user }, { 'g', "group", "Run as group", OPT_STR, &opt_group }, { 'p', "pid", "Alternate pid path", OPT_STR, &opt_pidpath }, { 'C', "firstrun", "If no user account exists then create one with\n" "no username and no password. Use with care as\n" "it will allow world-wide administrative access\n" "to your Tvheadend installation until you edit\n" "the access-control from within the Tvheadend UI", OPT_BOOL, &opt_firstrun }, #if ENABLE_LINUXDVB { 'a', "adapters", "Only use specified DVB adapters (comma separated)", OPT_STR, &opt_dvb_adapters }, #endif { 0, NULL, "Server Connectivity", OPT_BOOL, NULL }, { '6', "ipv6", "Listen on IPv6", OPT_BOOL, &opt_ipv6 }, { 'b', "bindaddr", "Specify bind address", OPT_STR, &opt_bindaddr}, { 0, "http_port", "Specify alternative http port", OPT_INT, &tvheadend_webui_port }, { 0, "http_root", "Specify alternative http webroot", OPT_STR, &tvheadend_webroot }, { 0, "htsp_port", "Specify alternative htsp port", OPT_INT, &tvheadend_htsp_port }, { 0, "htsp_port2", "Specify extra htsp port", OPT_INT, &tvheadend_htsp_port_extra }, { 0, NULL, "Debug Options", OPT_BOOL, NULL }, { 'd', "stderr", "Enable debug on stderr", OPT_BOOL, &opt_stderr }, { 's', "syslog", "Enable debug to syslog", OPT_BOOL, &opt_syslog }, { 'l', "logfile", "Enable debug to file", OPT_STR, &opt_logpath }, { 0, "debug", "Enable debug subsystems", OPT_STR, &opt_log_debug }, #if ENABLE_TRACE { 0, "trace", "Enable trace subsystems", OPT_STR, &opt_log_trace }, #endif { 0, "fileline", "Add file and line numbers to debug", OPT_BOOL, &opt_fileline }, { 0, "threadid", "Add the thread ID to debug", OPT_BOOL, &opt_threadid }, { 0, "uidebug", "Enable webUI debug (non-minified JS)", OPT_BOOL, &opt_uidebug }, { 'A', "abort", "Immediately abort", OPT_BOOL, &opt_abort }, { 'D', "dump", "Enable coredumps for daemon", OPT_BOOL, &opt_dump }, { 0, "noacl", "Disable all access control checks", OPT_BOOL, &opt_noacl }, { 'j', "join", "Subscribe to a service permanently", OPT_STR, &opt_subscribe }, { 0, NULL, "TODO: testing", OPT_BOOL, NULL }, { 0, "tsfile_tuners", "Number of tsfile tuners", OPT_INT, &opt_tsfile_tuner }, { 0, "tsfile", "tsfile input (mux file)", OPT_STR_LIST, &opt_tsfile }, }; /* Get current directory */ tvheadend_cwd = dirname(dirname(tvh_strdupa(argv[0]))); /* Set locale */ setlocale(LC_ALL, ""); setlocale(LC_NUMERIC, "C"); /* make sure the timezone is set */ tzset(); /* Process command line */ for (i = 1; i < argc; i++) { /* Find option */ cmdline_opt_t *opt = cmdline_opt_find(cmdline_opts, ARRAY_SIZE(cmdline_opts), argv[i]); if (!opt) show_usage(argv[0], cmdline_opts, ARRAY_SIZE(cmdline_opts), "invalid option specified [%s]", argv[i]); /* Process */ if (opt->type == OPT_BOOL) *((int*)opt->param) = 1; else if (++i == argc) show_usage(argv[0], cmdline_opts, ARRAY_SIZE(cmdline_opts), "option %s requires a value", opt->lopt); else if (opt->type == OPT_INT) *((int*)opt->param) = atoi(argv[i]); else if (opt->type == OPT_STR_LIST) { str_list_t *strl = opt->param; if (strl->num < strl->max) strl->str[strl->num++] = argv[i]; } else *((char**)opt->param) = argv[i]; /* Stop processing */ if (opt_help) show_usage(argv[0], cmdline_opts, ARRAY_SIZE(cmdline_opts), NULL); if (opt_version) show_version(argv[0]); } /* Additional cmdline processing */ #if ENABLE_LINUXDVB if (!opt_dvb_adapters) { adapter_mask = ~0; } else { char *p, *e; char *r = NULL; char *dvb_adapters = strdup(opt_dvb_adapters); adapter_mask = 0x0; p = strtok_r(dvb_adapters, ",", &r); while (p) { int a = strtol(p, &e, 10); if (*e != 0 || a < 0 || a > 31) { tvhlog(LOG_ERR, "START", "Invalid adapter number '%s'", p); free(dvb_adapters); return 1; } adapter_mask |= (1 << a); p = strtok_r(NULL, ",", &r); } free(dvb_adapters); if (!adapter_mask) { tvhlog(LOG_ERR, "START", "No adapters specified!"); return 1; } } #endif if (tvheadend_webroot) { char *tmp; if (*tvheadend_webroot == '/') tmp = strdup(tvheadend_webroot); else { tmp = malloc(strlen(tvheadend_webroot)+2); *tmp = '/'; strcpy(tmp+1, tvheadend_webroot); } if (tmp[strlen(tmp)-1] == '/') tmp[strlen(tmp)-1] = '\0'; tvheadend_webroot = tmp; } tvheadend_webui_debug = opt_uidebug; /* Setup logging */ if (isatty(2)) log_options |= TVHLOG_OPT_DECORATE; if (opt_stderr || opt_syslog || opt_logpath) { if (!opt_log_trace && !opt_log_debug) log_debug = "all"; log_level = LOG_DEBUG; if (opt_stderr) log_options |= TVHLOG_OPT_DBG_STDERR; if (opt_syslog) log_options |= TVHLOG_OPT_DBG_SYSLOG; if (opt_logpath) log_options |= TVHLOG_OPT_DBG_FILE; } if (opt_fileline) log_options |= TVHLOG_OPT_FILELINE; if (opt_threadid) log_options |= TVHLOG_OPT_THREAD; if (opt_log_trace) { log_level = LOG_TRACE; log_trace = opt_log_trace; } if (opt_log_debug) log_debug = opt_log_debug; tvhlog_init(log_level, log_options, opt_logpath); tvhlog_set_debug(log_debug); tvhlog_set_trace(log_trace); signal(SIGPIPE, handle_sigpipe); // will be redundant later /* Daemonise */ if(opt_fork) { const char *homedir; gid_t gid; uid_t uid; struct group *grp = getgrnam(opt_group ?: "video"); struct passwd *pw = opt_user ? getpwnam(opt_user) : NULL; FILE *pidfile = fopen(opt_pidpath, "w+"); if(grp != NULL) { gid = grp->gr_gid; } else { gid = 1; } if (pw != NULL) { if (getuid() != pw->pw_uid) { gid_t glist[10]; int gnum; gnum = get_user_groups(pw, glist, 10); if (setgroups(gnum, glist)) { tvhlog(LOG_ALERT, "START", "setgroups() failed, do you have permission?"); return 1; } } uid = pw->pw_uid; homedir = pw->pw_dir; setenv("HOME", homedir, 1); } else { uid = 1; } if ((getgid() != gid) && setgid(gid)) { tvhlog(LOG_ALERT, "START", "setgid() failed, do you have permission?"); return 1; } if ((getuid() != uid) && setuid(uid)) { tvhlog(LOG_ALERT, "START", "setuid() failed, do you have permission?"); return 1; } if(daemon(0, 0)) { exit(2); } if(pidfile != NULL) { fprintf(pidfile, "%d\n", getpid()); fclose(pidfile); } /* Make dumpable */ if (opt_dump) { #ifdef PLATFORM_LINUX if (chdir("/tmp")) tvhwarn("START", "failed to change cwd to /tmp"); prctl(PR_SET_DUMPABLE, 1); #else tvhwarn("START", "Coredumps not implemented on your platform"); #endif } umask(0); } tvheadend_running = 1; /* Start log thread (must be done post fork) */ tvhlog_start(); /* Alter logging */ if (opt_fork) tvhlog_options &= ~TVHLOG_OPT_STDERR; if (!isatty(2)) tvhlog_options &= ~TVHLOG_OPT_DECORATE; /* Initialise clock */ pthread_mutex_lock(&global_lock); time(&dispatch_clock); /* Signal handling */ sigfillset(&set); sigprocmask(SIG_BLOCK, &set, NULL); trap_init(argv[0]); /* Initialise configuration */ uuid_init(); idnode_init(); config_init(opt_config); /** * Initialize subsystems */ api_init(); fsmonitor_init(); #if ENABLE_LIBAV libav_init(); transcoding_init(); #endif imagecache_init(); service_init(); #if ENABLE_TSFILE if(opt_tsfile.num) { tsfile_init(opt_tsfile_tuner ?: opt_tsfile.num); for (i = 0; i < opt_tsfile.num; i++) tsfile_add_file(opt_tsfile.str[i]); } #endif #if ENABLE_MPEGTS_DVB dvb_network_init(); #endif #if ENABLE_IPTV iptv_init(); #endif #if ENABLE_LINUXDVB linuxdvb_init(adapter_mask); #endif channel_init(); subscription_init(); access_init(opt_firstrun, opt_noacl); #if ENABLE_TIMESHIFT timeshift_init(); #endif http_client_init(); tcp_server_init(opt_ipv6); http_server_init(opt_bindaddr); webui_init(); service_mapper_init(); descrambler_init(); epggrab_init(); epg_init(); dvr_init(); htsp_init(opt_bindaddr); if(opt_subscribe != NULL) subscription_dummy_join(opt_subscribe, 1); avahi_init(); epg_updated(); // cleanup now all prev ref's should have been created pthread_mutex_unlock(&global_lock); /** * Wait for SIGTERM / SIGINT, but only in this thread */ sigemptyset(&set); sigaddset(&set, SIGTERM); sigaddset(&set, SIGINT); signal(SIGTERM, doexit); signal(SIGINT, doexit); pthread_sigmask(SIG_UNBLOCK, &set, NULL); tvhlog(LOG_NOTICE, "START", "HTS Tvheadend version %s started, " "running as PID:%d UID:%d GID:%d, CWD:%s CNF:%s", tvheadend_version, getpid(), getuid(), getgid(), getcwd(buf, sizeof(buf)), hts_settings_get_root()); if(opt_abort) abort(); mainloop(); tvhftrace("main", htsp_done); tvhftrace("main", http_server_done); tvhftrace("main", webui_done); tvhftrace("main", http_client_done); tvhftrace("main", fsmonitor_done); #if ENABLE_MPEGTS_DVB tvhftrace("main", dvb_network_done); #endif #if ENABLE_IPTV tvhftrace("main", iptv_done); #endif #if ENABLE_LINUXDVB tvhftrace("main", linuxdvb_done); #endif // Note: the locking is obviously a bit redundant, but without // we need to disable the gtimer_arm call in epg_save() pthread_mutex_lock(&global_lock); tvhftrace("main", epg_save); #if ENABLE_TIMESHIFT tvhftrace("main", timeshift_term); #endif pthread_mutex_unlock(&global_lock); tvhftrace("main", epggrab_done); tvhftrace("main", tcp_server_done); tvhftrace("main", descrambler_done); tvhftrace("main", service_mapper_done); tvhftrace("main", service_done); tvhftrace("main", channel_done); tvhftrace("main", dvr_done); tvhftrace("main", subscription_done); tvhftrace("main", access_done); tvhftrace("main", epg_done); tvhftrace("main", avahi_done); tvhftrace("main", imagecache_done); tvhftrace("main", idnode_done); tvhftrace("main", lang_code_done); tvhftrace("main", api_done); tvhftrace("main", config_done); tvhftrace("main", hts_settings_done); tvhftrace("main", dvb_done); tvhftrace("main", lang_str_done); tvhlog(LOG_NOTICE, "STOP", "Exiting HTS Tvheadend"); tvhlog_end(); if(opt_fork) unlink(opt_pidpath); free(opt_tsfile.str); return 0; }
BOOL DeleteFileA(LPCSTR lpFileName) { int status; status = unlink(lpFileName); return (status != -1) ? TRUE : FALSE; }
void FAST_FUNC data_extract_all(archive_handle_t *archive_handle) { file_header_t *file_header = archive_handle->file_header; int dst_fd; int res; if (archive_handle->ah_flags & ARCHIVE_CREATE_LEADING_DIRS) { char *slash = strrchr(file_header->name, '/'); if (slash) { *slash = '\0'; bb_make_directory(file_header->name, -1, FILEUTILS_RECUR); *slash = '/'; } } if (archive_handle->ah_flags & ARCHIVE_UNLINK_OLD) { /* Remove the entry if it exists */ if ((!S_ISDIR(file_header->mode)) && (unlink(file_header->name) == -1) && (errno != ENOENT) ) { bb_perror_msg_and_die("can't remove old file %s", file_header->name); } } else if (archive_handle->ah_flags & ARCHIVE_EXTRACT_NEWER) { /* Remove the existing entry if its older than the extracted entry */ struct stat existing_sb; if (lstat(file_header->name, &existing_sb) == -1) { if (errno != ENOENT) { bb_perror_msg_and_die("can't stat old file"); } } else if (existing_sb.st_mtime >= file_header->mtime) { if (!(archive_handle->ah_flags & ARCHIVE_EXTRACT_QUIET)) { bb_error_msg("%s not created: newer or " "same age file exists", file_header->name); } data_skip(archive_handle); return; } else if ((unlink(file_header->name) == -1) && (errno != EISDIR)) { bb_perror_msg_and_die("can't remove old file %s", file_header->name); } } /* Handle hard links separately * We identified hard links as regular files of size 0 with a symlink */ if (S_ISREG(file_header->mode) && file_header->link_target && file_header->size == 0 ) { /* hard link */ res = link(file_header->link_target, file_header->name); if ((res == -1) && !(archive_handle->ah_flags & ARCHIVE_EXTRACT_QUIET)) { bb_perror_msg("can't create %slink " "from %s to %s", "hard", file_header->name, file_header->link_target); } } else { /* Create the filesystem entry */ switch (file_header->mode & S_IFMT) { case S_IFREG: { /* Regular file */ int flags = O_WRONLY | O_CREAT | O_EXCL; if (archive_handle->ah_flags & ARCHIVE_O_TRUNC) flags = O_WRONLY | O_CREAT | O_TRUNC; dst_fd = xopen3(file_header->name, flags, file_header->mode ); bb_copyfd_exact_size(archive_handle->src_fd, dst_fd, file_header->size); close(dst_fd); break; } case S_IFDIR: res = mkdir(file_header->name, file_header->mode); if ((res == -1) && (errno != EISDIR) /* btw, Linux doesn't return this */ && (errno != EEXIST) && !(archive_handle->ah_flags & ARCHIVE_EXTRACT_QUIET) ) { bb_perror_msg("can't make dir %s", file_header->name); } break; case S_IFLNK: /* Symlink */ res = symlink(file_header->link_target, file_header->name); if ((res == -1) && !(archive_handle->ah_flags & ARCHIVE_EXTRACT_QUIET) ) { bb_perror_msg("can't create %slink " "from %s to %s", "sym", file_header->name, file_header->link_target); } break; case S_IFSOCK: case S_IFBLK: case S_IFCHR: case S_IFIFO: res = mknod(file_header->name, file_header->mode, file_header->device); if ((res == -1) && !(archive_handle->ah_flags & ARCHIVE_EXTRACT_QUIET) ) { bb_perror_msg("can't create node %s", file_header->name); } break; default: bb_error_msg_and_die("unrecognized file type"); } } if (!(archive_handle->ah_flags & ARCHIVE_DONT_RESTORE_OWNER)) { #if ENABLE_FEATURE_TAR_UNAME_GNAME if (!(archive_handle->ah_flags & ARCHIVE_NUMERIC_OWNER)) { uid_t uid = file_header->uid; gid_t gid = file_header->gid; if (file_header->tar__uname) { //TODO: cache last name/id pair? struct passwd *pwd = getpwnam(file_header->tar__uname); if (pwd) uid = pwd->pw_uid; } if (file_header->tar__gname) { struct group *grp = getgrnam(file_header->tar__gname); if (grp) gid = grp->gr_gid; } /* GNU tar 1.15.1 uses chown, not lchown */ chown(file_header->name, uid, gid); } else #endif chown(file_header->name, file_header->uid, file_header->gid); } if (!S_ISLNK(file_header->mode)) { /* uclibc has no lchmod, glibc is even stranger - * it has lchmod which seems to do nothing! * so we use chmod... */ if (!(archive_handle->ah_flags & ARCHIVE_DONT_RESTORE_PERM)) { chmod(file_header->name, file_header->mode); } /* same for utime */ if (archive_handle->ah_flags & ARCHIVE_RESTORE_DATE) { struct timeval t[2]; t[1].tv_sec = t[0].tv_sec = file_header->mtime; t[1].tv_usec = t[0].tv_usec = 0; utimes(file_header->name, t); } } }
int Q_unlink (const char *path) { return unlink(path); }
int main(int ac, char **av) { int rwfd; int i; int j; int c; off_t file_size = 1 * 1024 * 1024 * 1024; int first_stage = WRITE; struct io_oper *oper; int status = 0; int num_files = 0; int open_fds = 0; struct thread_info *t; page_size_mask = getpagesize() - 1; while (1) { c = getopt(ac, av, "a:b:c:C:m:s:r:d:i:I:o:t:lLnhOSxvu"); if (c < 0) break; switch (c) { case 'a': page_size_mask = parse_size(optarg, 1024); page_size_mask--; break; case 'c': num_contexts = atoi(optarg); break; case 'C': context_offset = parse_size(optarg, 1024 * 1024); case 'b': max_io_submit = atoi(optarg); break; case 's': file_size = parse_size(optarg, 1024 * 1024); break; case 'd': depth = atoi(optarg); break; case 'r': rec_len = parse_size(optarg, 1024); break; case 'i': io_iter = atoi(optarg); break; case 'I': iterations = atoi(optarg); break; case 'n': fsync_stages = 0; break; case 'l': latency_stats = 1; break; case 'L': completion_latency_stats = 1; break; case 'm': if (!strcmp(optarg, "shm")) { fprintf(stderr, "using ipc shm\n"); use_shm = USE_SHM; } else if (!strcmp(optarg, "shmfs")) { fprintf(stderr, "using /dev/shm for buffers\n"); use_shm = USE_SHMFS; } break; case 'o': i = atoi(optarg); stages |= 1 << i; fprintf(stderr, "adding stage %s\n", stage_name(i)); break; case 'O': o_direct = O_DIRECT; break; case 'S': o_sync = O_SYNC; break; case 't': num_threads = atoi(optarg); break; case 'x': stonewall = 0; break; case 'u': unlink_files = 1; break; case 'v': verify = 1; break; case 'h': default: print_usage(); exit(1); } } /* * make sure we don't try to submit more I/O than we have allocated * memory for */ if (depth < io_iter) { io_iter = depth; fprintf(stderr, "dropping io_iter to %d\n", io_iter); } if (optind >= ac) { print_usage(); exit(1); } num_files = ac - optind; if (num_threads > (num_files * num_contexts)) { num_threads = num_files * num_contexts; fprintf(stderr, "dropping thread count to the number of contexts %d\n", num_threads); } t = malloc(num_threads * sizeof(*t)); if (!t) { perror("malloc"); exit(1); } global_thread_info = t; /* by default, allow a huge number of iocbs to be sent towards * io_submit */ if (!max_io_submit) max_io_submit = num_files * io_iter * num_contexts; /* * make sure we don't try to submit more I/O than max_io_submit allows */ if (max_io_submit < io_iter) { io_iter = max_io_submit; fprintf(stderr, "dropping io_iter to %d\n", io_iter); } if (!stages) { stages = (1 << WRITE) | (1 << READ) | (1 << RREAD) | (1 << RWRITE); } else { for (i = 0; i < LAST_STAGE; i++) { if (stages & (1 << i)) { first_stage = i; fprintf(stderr, "starting with %s\n", stage_name(i)); break; } } } if (file_size < num_contexts * context_offset) { fprintf(stderr, "file size %ld too small for %d contexts\n", (long)file_size, num_contexts); exit(1); } fprintf(stderr, "file size %ldMB, record size %ldKB, depth %d, " "I/O per iteration %d\n", (long)(file_size / (1024 * 1024)), rec_len / 1024, depth, io_iter); fprintf(stderr, "max io_submit %d, buffer alignment set to %luKB\n", max_io_submit, (page_size_mask + 1) / 1024); fprintf(stderr, "threads %d files %d contexts %d context offset %ldMB " "verification %s\n", num_threads, num_files, num_contexts, (long)(context_offset / (1024 * 1024)), verify ? "on" : "off"); /* open all the files and do any required setup for them */ for (i = optind; i < ac; i++) { int thread_index; for (j = 0; j < num_contexts; j++) { thread_index = open_fds % num_threads; open_fds++; rwfd = open(av[i], O_CREAT | O_RDWR | o_direct | o_sync, 0600); if (rwfd == -1) { fprintf(stderr, "error while creating file %s: %s", av[i], strerror(errno)); exit(1); } oper = create_oper(rwfd, first_stage, j * context_offset, file_size - j * context_offset, rec_len, depth, io_iter, av[i]); if (!oper) { fprintf(stderr, "error in create_oper\n"); exit(-1); } oper_list_add(oper, &t[thread_index].active_opers); t[thread_index].num_files++; } } if (setup_shared_mem(num_threads, num_files * num_contexts, depth, rec_len, max_io_submit)) { exit(1); } for (i = 0; i < num_threads; i++) { if (setup_ious (&t[i], t[i].num_files, depth, rec_len, max_io_submit)) exit(1); } if (num_threads > 1) { printf("Running multi thread version num_threads:%d\n", num_threads); run_workers(t, num_threads); } else { printf("Running single thread version \n"); status = worker(t); } if (unlink_files) { for (i = optind; i < ac; i++) { printf("Cleaning up file %s \n", av[i]); unlink(av[i]); } } if (status) { exit(1); } return status; }
/** * Main program. Returns 1 if all programs run successfully, 0 if * something failed and -1 if there was an error running programs. */ int main(int argc, char *argv[]) { int retcode; struct sigaction zig; pid_t pid; char *c; /* Check parameters */ if (argc < 2) { fprintf(stderr, "Usage: %s test_prog\n", argv[0]); return 1; } if (argc > 2 && strcmp(argv[2], "--leader") == 0) { pounder_fprintf(stdout, "Logging this test output to %s/POUNDERLOG.\n", getenv("POUNDER_LOGDIR")); is_leader = 1; record_pid(); } progname = argv[0]; /* Set up signals */ memset(&zig, 0x00, sizeof(zig)); zig.sa_handler = jump_out; sigaction(SIGHUP, &zig, NULL); sigaction(SIGINT, &zig, NULL); sigaction(SIGTERM, &zig, NULL); if (is_directory(argv[1])) { retcode = process_dir(argv[1]); } else { if (is_executable(argv[1])) { c = rindex(argv[1], '/'); c++; // Start the test pid = spawn_test(argv[1]); if (pid < 0) { perror("fork"); retcode = -1; goto out; } // Track the test note_process(pid, argv[1]); if (wait_for_pids() == 0) { retcode = 1; } else { retcode = 0; } } else { pounder_fprintf(stderr, "%s: Not a directory or a test.\n", argv[1]); retcode = -1; } } out: kill_daemons(); wait_for_daemons(); if (is_leader) { if (retcode == 0) { pounder_fprintf(stdout, "%s: %s.\n", argv[1], pass_msg); } else if (retcode < 0 || retcode == 255) { pounder_fprintf(stdout, "%s: %s with code %d.\n", argv[1], abort_msg, retcode); } else { pounder_fprintf(stdout, "%s: %s with code %d.\n", argv[1], fail_msg, retcode); } unlink(pidfile); } exit(retcode); }
/* __CFWriteBytesToFileWithAtomicity is a "safe save" facility. Write the bytes using the specified mode on the file to the provided URL. If the atomic flag is true, try to do it in a fashion that will enable a safe save. */ static Boolean __CFWriteBytesToFileWithAtomicity(CFURLRef url, const void *bytes, int length, SInt32 mode, Boolean atomic) { int fd = -1; char auxPath[CFMaxPathSize + 16]; char cpath[CFMaxPathSize]; uid_t owner = getuid(); gid_t group = getgid(); Boolean writingFileAsRoot = ((getuid() != geteuid()) && (geteuid() == 0)); if (!CFURLGetFileSystemRepresentation(url, true, (uint8_t *)cpath, CFMaxPathSize)) { return false; } if (-1 == mode || writingFileAsRoot) { struct stat statBuf; if (0 == stat(cpath, &statBuf)) { mode = statBuf.st_mode; owner = statBuf.st_uid; group = statBuf.st_gid; } else { mode = 0664; if (writingFileAsRoot && (0 == strncmp(cpath, "/Library/Preferences", 20))) { owner = geteuid(); group = 80; } } } if (atomic) { CFURLRef dir = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorSystemDefault, url); CFURLRef tempFile = CFURLCreateCopyAppendingPathComponent(kCFAllocatorSystemDefault, dir, CFSTR("cf#XXXXX"), false); CFRelease(dir); if (!CFURLGetFileSystemRepresentation(tempFile, true, (uint8_t *)auxPath, CFMaxPathSize)) { CFRelease(tempFile); return false; } CFRelease(tempFile); fd = mkstemp(auxPath); } else { fd = open(cpath, O_WRONLY|O_CREAT|O_TRUNC, mode); } if (fd < 0) return false; if (length && (write(fd, bytes, length) != length || fsync(fd) < 0)) { int saveerr = thread_errno(); close(fd); if (atomic) unlink(auxPath); thread_set_errno(saveerr); return false; } close(fd); if (atomic) { // preserve the mode as passed in originally chmod(auxPath, mode); if (0 != rename(auxPath, cpath)) { unlink(auxPath); return false; } // If the file was renamed successfully and we wrote it as root we need to reset the owner & group as they were. if (writingFileAsRoot) { chown(cpath, owner, group); } } return true; }
DispValue *DispValue::_update(DispValue *source, bool& was_changed, bool& was_initialized) { if (source == this) { // We're updated from ourselves -- ignore it all. // This happens when a cluster is updated from the values of // the clustered dislays. if (descendant_changed()) was_changed = true; return this; } if (changed) { // Clear `changed' flag changed = false; was_changed = true; } if (source->enabled() != enabled()) { myenabled = source->enabled(); was_changed = true; // We don't set CHANGED to true since enabled/disabled changes // are merely a change in the view, not a change in the data. } if (source->full_name() == full_name() && source->type() == type()) { switch (type()) { case Simple: case Text: case Pointer: // Atomic values if (_value != source->value()) { _value = source->value(); changed = was_changed = true; } return this; case Array: // Array. Check for 1st element, too. if (_have_index_base != source->_have_index_base && (_have_index_base && _index_base != source->_index_base)) break; // FALL THROUGH case Reference: case Sequence: // Numbered children. If size changed, we assume // the whole has been changed. if (nchildren() == source->nchildren()) { for (int i = 0; i < nchildren(); i++) { // Update each child _children[i] = child(i)->update(source->child(i), was_changed, was_initialized); } return this; } break; case List: case Struct: { // Named children. Check whether names are the same. bool same_members = (nchildren() == source->nchildren()); for (int i = 0; same_members && i < nchildren(); i++) { if (child(i)->full_name() != source->child(i)->full_name()) same_members = false; } if (same_members) { // Update each child for (int i = 0; i < nchildren(); i++) { _children[i] = child(i)->update(source->child(i), was_changed, was_initialized); } return this; } // Members have changed. // Be sure to mark only those members that actually have changed // (i.e. don't mark the entire struct and don't mark new members) // We do so by creating a new list of children. `Old' children // that still are reported get updated; `new' children are added. DispValueArray new_children; DispValueArray processed_children; for (int j = 0; j < source->nchildren(); j++) { DispValue *c = 0; for (int i = 0; c == 0 && i < nchildren(); i++) { bool processed = false; for (int k = 0; k < processed_children.size(); k++) { if (child(i) == processed_children[k]) processed = true; } if (processed) continue; if (child(i)->full_name() == source->child(j)->full_name()) { c = child(i)->update(source->child(j), was_changed, was_initialized); processed_children += child(i); } } if (c == 0) { // Child not found -- use source child instead c = source->child(j)->link(); } new_children += c; } _children = new_children; was_changed = was_initialized = true; return this; } case UnknownType: assert(0); abort(); } } // Type, name or structure have changed -- use SOURCE instead of original DispValue *ret = source->link(); ret->changed = was_changed = was_initialized = true; // Copy the basic settings ret->myexpanded = expanded(); ret->dereference(dereferenced()); ret->set_orientation(orientation()); ret->set_member_names(member_names()); // Have new DispValue take over the plotter if (ret->plotter() == 0) { ret->_plotter = plotter(); _plotter = 0; } unlink(); return ret; }
void aofRemoveTempFile(pid_t childpid) { char tmpfile[256]; snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof", (int) childpid); unlink(tmpfile); }
/* * Pipe a one line command into a window * Bound to ^X @ */ int pipecmd(int f, int n) { int s; /* return status from CLI */ struct window *wp; /* pointer to new window */ struct buffer *bp; /* pointer to buffer to zot */ char line[NLINE]; /* command line send to shell */ static char bname[] = "command"; static char filnam[NSTRING] = "command"; #if MSDOS char *tmp; FILE *fp; int len; #endif /* don't allow this command if restricted */ if (restflag) return resterr(); #if MSDOS if ((tmp = getenv("TMP")) == NULL && (tmp = getenv("TEMP")) == NULL) xstrcpy(filnam, "command"); else { xstrcpy(filnam, tmp); len = strlen(tmp); if (len <= 0 || filnam[len - 1] != '\\' && filnam[len - 1] != '/') strcat(filnam, "\\"); strcat(filnam, "command"); } #endif #if VMS mlwrite("Not available under VMS"); return FALSE; #endif /* get the command to pipe in */ if ((s = mlreply("@", line, NLINE)) != TRUE) return s; /* get rid of the command output buffer if it exists */ if ((bp = bfind(bname, FALSE, 0)) != FALSE) { /* try to make sure we are off screen */ wp = wheadp; while (wp != NULL) { if (wp->w_bufp == bp) { #if PKCODE if (wp == curwp) delwind(FALSE, 1); else onlywind(FALSE, 1); break; #else onlywind(FALSE, 1); break; #endif } wp = wp->w_wndp; } if (zotbuf(bp) != TRUE) return FALSE; } #if MSDOS strcat(line, " >>"); strcat(line, filnam); movecursor(term.t_nrow, 0); TTkclose(); shellprog(line); TTkopen(); sgarbf = TRUE; if ((fp = fopen(filnam, "r")) == NULL) { s = FALSE; } else { fclose(fp); s = TRUE; } #endif #if V7 | USG | BSD TTflush(); TTclose(); /* stty to old modes */ TTkclose(); strcat(line, ">"); strcat(line, filnam); system(line); TTopen(); TTkopen(); TTflush(); sgarbf = TRUE; s = TRUE; #endif if (s != TRUE) return s; /* split the current window to make room for the command output */ if (splitwind(FALSE, 1) == FALSE) return FALSE; /* and read the stuff in */ if (getfile(filnam, FALSE) == FALSE) return FALSE; /* make this window in VIEW mode, update all mode lines */ curwp->w_bufp->b_mode |= MDVIEW; wp = wheadp; while (wp != NULL) { wp->w_flag |= WFMODE; wp = wp->w_wndp; } /* and get rid of the temporary file */ unlink(filnam); return TRUE; }
/* Write a sequence of commands able to fully rebuild the dataset into * "filename". Used both by REWRITEAOF and BGREWRITEAOF. * * In order to minimize the number of commands needed in the rewritten * log Redis uses variadic commands when possible, such as RPUSH, SADD * and ZADD. However at max REDIS_AOF_REWRITE_ITEMS_PER_CMD items per time * are inserted using a single command. */ int rewriteAppendOnlyFile(char *filename) { dictIterator *di = NULL; dictEntry *de; rio aof; FILE *fp; char tmpfile[256]; int j; long long now = mstime(); /* Note that we have to use a different temp name here compared to the * one used by rewriteAppendOnlyFileBackground() function. */ snprintf(tmpfile,256,"temp-rewriteaof-%d.aof", (int) getpid()); fp = fopen(tmpfile,"w"); if (!fp) { redisLog(REDIS_WARNING, "Opening the temp file for AOF rewrite in rewriteAppendOnlyFile(): %s", strerror(errno)); return REDIS_ERR; } rioInitWithFile(&aof,fp); if (server.aof_rewrite_incremental_fsync) rioSetAutoSync(&aof,REDIS_AOF_AUTOSYNC_BYTES); for (j = 0; j < server.dbnum; j++) { char selectcmd[] = "*2\r\n$6\r\nSELECT\r\n"; redisDb *db = server.db+j; dict *d = db->dict; if (dictSize(d) == 0) continue; di = dictGetSafeIterator(d); if (!di) { fclose(fp); return REDIS_ERR; } /* SELECT the new DB */ if (rioWrite(&aof,selectcmd,sizeof(selectcmd)-1) == 0) goto werr; if (rioWriteBulkLongLong(&aof,j) == 0) goto werr; /* Iterate this DB writing every entry */ while((de = dictNext(di)) != NULL) { sds keystr; robj key, *o; long long expiretime; keystr = dictGetKey(de); o = dictGetVal(de); initStaticStringObject(key,keystr); expiretime = getExpire(db,&key); /* If this key is already expired skip it */ if (expiretime != -1 && expiretime < now) continue; /* Save the key and associated value */ if (o->type == REDIS_STRING) { /* Emit a SET command */ char cmd[]="*3\r\n$3\r\nSET\r\n"; if (rioWrite(&aof,cmd,sizeof(cmd)-1) == 0) goto werr; /* Key and value */ if (rioWriteBulkObject(&aof,&key) == 0) goto werr; if (rioWriteBulkObject(&aof,o) == 0) goto werr; } else if (o->type == REDIS_LIST) { if (rewriteListObject(&aof,&key,o) == 0) goto werr; } else if (o->type == REDIS_SET) { if (rewriteSetObject(&aof,&key,o) == 0) goto werr; } else if (o->type == REDIS_ZSET) { if (rewriteSortedSetObject(&aof,&key,o) == 0) goto werr; } else if (o->type == REDIS_HASH) { if (rewriteHashObject(&aof,&key,o) == 0) goto werr; } else { redisPanic("Unknown object type"); } /* Save the expire time */ if (expiretime != -1) { char cmd[]="*3\r\n$9\r\nPEXPIREAT\r\n"; if (rioWrite(&aof,cmd,sizeof(cmd)-1) == 0) goto werr; if (rioWriteBulkObject(&aof,&key) == 0) goto werr; if (rioWriteBulkLongLong(&aof,expiretime) == 0) goto werr; } } dictReleaseIterator(di); } /* Make sure data will not remain on the OS's output buffers */ fflush(fp); aof_fsync(fileno(fp)); fclose(fp); /* Use RENAME to make sure the DB file is changed atomically only * if the generate DB file is ok. */ if (rename(tmpfile,filename) == -1) { redisLog(REDIS_WARNING,"Error moving temp append only file on the final destination: %s", strerror(errno)); unlink(tmpfile); return REDIS_ERR; } redisLog(REDIS_NOTICE,"SYNC append only file rewrite performed"); return REDIS_OK; werr: fclose(fp); unlink(tmpfile); redisLog(REDIS_WARNING,"Write error writing append only file on disk: %s", strerror(errno)); if (di) dictReleaseIterator(di); return REDIS_ERR; }
/* Main entry point. */ int main(int argc, char *argv[]) { int ret; int sc; pthread_mutexattr_t ma; testdata_t *td; testdata_t alternativ; int do_fork; pid_t child_pr = 0, chkpid; int status; pthread_t child_th; long pshared, mf; /* Initialize output */ output_init(); /* Test system abilities */ pshared = sysconf(_SC_THREAD_PROCESS_SHARED); mf = sysconf(_SC_MAPPED_FILES); #if VERBOSE > 0 output("Test starting\n"); output("System abilities:\n"); output(" TSH : %li\n", pshared); output(" MF : %li\n", mf); if ((mf < 0) || (pshared < 0)) output("Process-shared attributes won't be tested\n"); #endif /********** * Allocate space for the testdata structure */ if (mf < 0) { /* Cannot mmap a file (or not interested in this), we use an alternative method */ td = &alternativ; pshared = -1; /* We won't do this testing anyway */ #if VERBOSE > 0 output("Testdata allocated in the process memory.\n"); #endif } else { /* We will place the test data in a mmaped file */ char filename[] = "/tmp/mutex_trylock_2-1-XXXXXX"; size_t sz; void *mmaped; int fd; char *tmp; /* We now create the temp files */ fd = mkstemp(filename); if (fd == -1) { UNRESOLVED(errno, "Temporary file could not be created"); } /* and make sure the file will be deleted when closed */ unlink(filename); #if VERBOSE > 1 output("Temp file created (%s).\n", filename); #endif sz = (size_t) sysconf(_SC_PAGESIZE); tmp = calloc(1, sz); if (tmp == NULL) { UNRESOLVED(errno, "Memory allocation failed"); } /* Write the data to the file. */ if (write(fd, tmp, sz) != (ssize_t) sz) { UNRESOLVED(sz, "Writting to the file failed"); } free(tmp); /* Now we can map the file in memory */ mmaped = mmap(NULL, sz, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if (mmaped == MAP_FAILED) { UNRESOLVED(errno, "mmap failed"); } td = (testdata_t *) mmaped; /* Our datatest structure is now in shared memory */ #if VERBOSE > 1 output("Testdata allocated in shared memory.\n"); #endif } /********** * For each test scenario, initialize the attributes and other variables. * Do the whole thing for each time to test. */ for (sc = 0; sc < NSCENAR; sc++) { #if VERBOSE > 1 output("[parent] Preparing attributes for: %s\n", scenarii[sc].descr); #endif /* set / reset everything */ do_fork = 0; ret = pthread_mutexattr_init(&ma); if (ret != 0) { UNRESOLVED(ret, "[parent] Unable to initialize the mutex attribute object"); } /* Set the mutex type */ ret = pthread_mutexattr_settype(&ma, scenarii[sc].m_type); if (ret != 0) { UNRESOLVED(ret, "[parent] Unable to set mutex type"); } #if VERBOSE > 1 output("[parent] Mutex type : %i\n", scenarii[sc].m_type); #endif /* Set the pshared attributes, if supported */ if ((pshared > 0) && (scenarii[sc].m_pshared != 0)) { ret = pthread_mutexattr_setpshared(&ma, PTHREAD_PROCESS_SHARED); if (ret != 0) { UNRESOLVED(ret, "[parent] Unable to set the mutex process-shared"); } #if VERBOSE > 1 output("[parent] Mutex is process-shared\n"); #endif } #if VERBOSE > 1 else { output("[parent] Mutex is process-private\n"); } #endif /* Tell whether the test will be across processes */ if ((pshared > 0) && (scenarii[sc].fork != 0)) { do_fork = 1; #if VERBOSE > 1 output("[parent] Child will be a new process\n"); #endif } #if VERBOSE > 1 else { output("[parent] Child will be a new thread\n"); } #endif /********** * Initialize the testdata_t structure with the previously defined attributes */ /* Initialize the mutex */ ret = pthread_mutex_init(&(td->mtx), &ma); if (ret != 0) { UNRESOLVED(ret, "[parent] Mutex init failed"); } /* Initialize the other datas from the test structure */ td->status = 0; /********** * Proceed to the actual testing */ /* Trylock the mutex twice before creating children */ ret = pthread_mutex_trylock(&(td->mtx)); if (ret != 0) { UNRESOLVED(ret, "[parent] Unable to trylock the mutex"); } ret = pthread_mutex_trylock(&(td->mtx)); if (scenarii[sc].m_type == PTHREAD_MUTEX_RECURSIVE) { if (ret != 0) { FAILED ("Failed to pthread_mutex_trylock() twice a recursive mutex"); } /* Unlock once so the count is "1" */ ret = pthread_mutex_unlock(&(td->mtx)); if (ret != 0) { UNRESOLVED(ret, "Failed to unlock the mutex"); } } else if (ret == 0) { UNRESOLVED(-1, "Main was able to pthread_mutex_trylock() twice without error"); } /* Create the children */ if (do_fork != 0) { /* We are testing across processes */ child_pr = fork(); if (child_pr == -1) { UNRESOLVED(errno, "[parent] Fork failed"); } if (child_pr == 0) { #if VERBOSE > 3 output ("[child] Child process is starting...\n"); #endif if (tf((void *)td) != NULL) { UNRESOLVED(-1, "[child] Got an unexpected return value from test function"); } else { /* We cannot use the PASSED macro here since it would terminate the output */ exit(0); } } /* Only the parent process goes further */ } else { /* do_fork == 0 */ /* We are testing across two threads */ ret = pthread_create(&child_th, NULL, tf, td); if (ret != 0) { UNRESOLVED(ret, "[parent] Unable to create the child thread."); } } /* Wait for the child to terminate */ if (do_fork != 0) { /* We were testing across processes */ ret = 0; chkpid = waitpid(child_pr, &status, 0); if (chkpid != child_pr) { output("Expected pid: %i. Got %i\n", (int)child_pr, (int)chkpid); UNRESOLVED(errno, "Waitpid failed"); } if (WIFSIGNALED(status)) { output("Child process killed with signal %d\n", WTERMSIG(status)); UNRESOLVED(-1, "Child process was killed"); } if (WIFEXITED(status)) { ret = WEXITSTATUS(status); } else { UNRESOLVED(-1, "Child process was neither killed nor exited"); } if (ret != 0) { exit(ret); /* Output has already been closed in child */ } } else { /* child was a thread */ ret = pthread_join(child_th, NULL); if (ret != 0) { UNRESOLVED(ret, "[parent] Unable to join the thread"); } } /* Check the child status */ if (td->status != EBUSY) { output("Unexpected return value: %d (%s)\n", td->status, strerror(td->status)); FAILED ("pthread_mutex_trylock() did not return EBUSY in the child"); } /* Unlock the mutex */ ret = pthread_mutex_unlock(&(td->mtx)); if (ret != 0) { FAILED ("Failed to unlock the mutex -- count is broken?"); } ret = pthread_mutex_unlock(&(td->mtx)); if (ret == 0) { FAILED ("Was able to unlock once more the mutex -- count is broken?"); } /********** * Destroy the data */ ret = pthread_mutex_destroy(&(td->mtx)); if (ret != 0) { UNRESOLVED(ret, "Failed to destroy the mutex"); } ret = pthread_mutexattr_destroy(&ma); if (ret != 0) { UNRESOLVED(ret, "Failed to destroy the mutex attribute object"); } } /* Proceed to the next scenario */ #if VERBOSE > 0 output("Test passed\n"); #endif PASSED; }
int delegate_to_matlab( Dbptr db, Pf *delegate_pf ) { char scriptfile[FILENAME_MAX]; char fifofile[FILENAME_MAX]; char pffile[FILENAME_MAX]; char cmd[STRSZ]; char *commands; char *mypath; char *cwd; FILE *fp; Tbl *keys; char *key; Pf *pfpart; pid_t pid; int status; int i; if( ( mypath = datafile( "PATH", "matlab" ) ) == 0 ) { elog_complain( 0, "Couldn't find matlab on path.\n" ); return -1; } else if( access( mypath, R_OK|X_OK ) ) { elog_complain( 0, "Couldn't find matlab on path.\n" ); return -1; } if( ( commands = pfget_string( delegate_pf, "commands" ) ) == NULL ) { elog_complain( 0, "No commands &Literal in parameter file\n" ); return -1; } cwd = getcwd( NULL, FILENAME_MAX ); sprintf( scriptfile, "/tmp/dbgme_script_%d_%d.m", getuid(), getpid() ); sprintf( fifofile, "/tmp/dbgme_fifo_%d_%d", getuid(), getpid() ); sprintf( pffile, "/tmp/dbgme_pf_%d_%d.pf", getuid(), getpid() ); mkfifo( fifofile, 0775 ); fp = fopen( pffile, "w" ); keys = pfkeys( delegate_pf ); for( i = 0; i < maxtbl( keys ); i++ ) { key = gettbl( keys, i ); if( ! strcmp( key, "commands" ) ) { continue; } pfresolve( delegate_pf, key, 0, &pfpart ); fprintf( fp, "%s ", key ); pfout( fp, pfpart ); } fclose( fp ); fp = fopen( scriptfile, "w" ); fprintf( fp, "addpath('%s')\n", cwd ); fprintf( fp, "db = dbread_view( '%s' );\n", fifofile ); fprintf( fp, "pf = dbpf( '%s' );\n", pffile ); fprintf( fp, "%s\n", commands ); fprintf( fp, "exit\n" ); fclose( fp ); sprintf( cmd, "try, " "run %s, " "catch, " "lasterr, " "elog_clear_register('print'), " "unix(['kill -9 ' num2str(getpid)]), " "end", scriptfile ); if( ( pid = fork() ) == 0 ) { if( Verbose ) { fprintf( stderr, "Running Matlab delegate\n" ); } else { fflush( stderr ); fclose( stdout ); } execlp( "matlab", "matlab", "-nodisplay", "-nojvm", "-r", cmd, NULL ); } else { fp = fopen( fifofile, "w" ); dbwrite_view( db, fp ); fclose( fp ); wait( &status ); } if( Verbose ) { fprintf( stderr, "Matlab exit status is %d\n", status ); } free( cwd ); unlink( scriptfile ); unlink( fifofile ); unlink( pffile ); if( status != 0 ) { return -1; } else { return 0; } }
int main( int argc, char *argv[] ) { char out_filename[256]; if( argc != 4 ) { fprintf( stderr, "closeshp poly_shape arc_shape output_shape\n" ); return 1; } char *poly_file = argv[1]; char *arc_file = argv[2]; char *out_file = argv[3]; struct source poly, arc, simplified; memset( &poly, 0, sizeof(poly) ); memset( &arc, 0, sizeof(arc) ); memset( &simplified, 0, sizeof(simplified) ); poly.in_memory = arc.in_memory = 0; simplified.in_memory = 1; /* open shapefiles and dbf files */ if( SourceOpen( &poly, poly_file, SHPT_POLYGON ) ) return 1; if( SourceOpen( &arc, arc_file, SHPT_ARC ) ) return 1; sprintf( out_filename, "%s_p", out_file ); shp_out = SHPCreate( out_filename, SHPT_POLYGON ); if( !shp_out ) { fprintf( stderr, "Couldn't create shapefile '%s': %s\n", out_file, strerror(errno)); return 1; } dbf_out = DBFCreate( out_filename ); if( !dbf_out ) { fprintf( stderr, "Couldn't create DBF '%s': %s\n", out_file, strerror(errno)); return 1; } // DBFAddField( dbf_out, "way_id", FTInteger, 11, 0 ); // DBFAddField( dbf_out, "orientation", FTInteger, 1, 0 ); DBFAddField( dbf_out, "error", FTInteger, 1, 0 ); DBFAddField( dbf_out, "tile_x", FTInteger, 4, 0 ); DBFAddField( dbf_out, "tile_y", FTInteger, 4, 0 ); /* Initialise node arrays */ v_x = malloc( MAX_NODES * sizeof(double) ); v_y = malloc( MAX_NODES * sizeof(double) ); if( !v_x || !v_y ) { fprintf( stderr, "Couldn't allocate memory for nodes\n" ); return 1; } /* Setup state */ struct state state; memset( &state, 0, sizeof(state) ); ResizeSubareas(&state, INIT_MAX_SUBAREAS); // Temporary file for simplified shapes { // Make the file and open it char filename[32]; sprintf( filename, "tmp_coastline_%d", getpid() ); simplified.shp = SHPCreate( filename, SHPT_ARC ); if( !simplified.shp ) { fprintf( stderr, "Couldn't open temporary shapefile: %s\n", strerror(errno) ); return 1; } // And now unlink them so they're cleaned up when we die int len = strlen( filename ); strcpy( filename+len, ".shp" ); unlink(filename); strcpy( filename+len, ".shx" ); unlink(filename); // Setup the bitmap while creating the simplified polygons InitBitmap( &arc, &simplified ); InitBitmap( &poly, &simplified ); // And index the simplified polygons simplified.shx = SHPCreateTree( simplified.shp, 2, 10, NULL, NULL ); if( !simplified.shx ) { fprintf( stderr, "Couldn't build temporary shapetree\n" ); return 1; } SHPGetInfo( simplified.shp, &simplified.shape_count, NULL, NULL, NULL ); simplified.shapes = calloc( simplified.shape_count, sizeof(SHPObject*) ); } /* Split coastlines into arcs no longer than MAX_NODES_PER_ARC long */ sprintf( out_filename, "%s_i", out_file ); SplitCoastlines( &poly, &arc, out_filename ); #if !TEST for( int i=0; i<DIVISIONS; i++ ) for( int j=0; j<DIVISIONS; j++ ) //Divide the world into mercator blocks approx 100km x 100km #else for( int i=204; i<=204; i++ ) for( int j=248; j<=248; j++ ) //Divide the world into mercator blocks approx 100km x 100km #endif { state.x = i; state.y = j; double left = -MERC_MAX + (i*MERC_BLOCK) - TILE_OVERLAP; double right = -MERC_MAX + ((i+1)*MERC_BLOCK) + TILE_OVERLAP; double bottom = -MERC_MAX + (j*MERC_BLOCK) - TILE_OVERLAP; double top = -MERC_MAX + ((j+1)*MERC_BLOCK) + TILE_OVERLAP; if( left < -MERC_MAX ) left = -MERC_MAX; if( right > +MERC_MAX ) right = +MERC_MAX; state.lb[0] = left; state.lb[1] = bottom; state.rt[0] = right; state.rt[1] = top; if(isatty(STDERR_FILENO)) // fprintf( stderr, "\rProcessing (%d,%d) (%.2f,%.2f)-(%.2f,%.2f) ", i, j, left, bottom, right, top ); fprintf( stderr, "\rProcessing (%d,%d) (%.2f,%.2f)-(%.2f,%.2f) ", i, j, state.lb[0], state.lb[1], state.rt[0], state.rt[1] ); state.seg_count = 0; state.subarea_count = 0; state.subarea_nodecount = 0; state.enclosed = 0; // Optimisation: if we have determined nothing enters the tile, we can used the simplified tiles // Basically, we only need to test for enclosure if( check_tile( state.x, state.y ) ) { Process( &state, &poly, 1 ); Process( &state, &arc, 0 ); } else Process( &state, &simplified, 0 ); OutputSegs( &state ); } free( state.sub_areas ); free( simplified.shapes ); SHPDestroyTree( poly.shx ); SHPDestroyTree( arc.shx ); SHPDestroyTree( simplified.shx ); DBFClose( poly.dbf ); DBFClose( arc.dbf ); DBFClose( dbf_out ); SHPClose( poly.shp ); SHPClose( arc.shp ); SHPClose( simplified.shp ); SHPClose( shp_out ); printf("\n"); return 0; }
static void stat_update_cb(EV_P_ ev_timer *watcher, int revents) { struct sockaddr_un svaddr, claddr; int sfd = -1; size_t msgLen; char resp[BUF_SIZE]; if (verbose) { LOGI("update traffic stat: tx: %"PRIu64" rx: %"PRIu64"", tx, rx); } snprintf(resp, BUF_SIZE, "stat: {\"%s\":%"PRIu64"}", server_port, tx + rx); msgLen = strlen(resp) + 1; ss_addr_t ip_addr = { .host = NULL, .port = NULL }; parse_addr(manager_address, &ip_addr); if (ip_addr.host == NULL || ip_addr.port == NULL) { sfd = socket(AF_UNIX, SOCK_DGRAM, 0); if (sfd == -1) { ERROR("stat_socket"); return; } memset(&claddr, 0, sizeof(struct sockaddr_un)); claddr.sun_family = AF_UNIX; snprintf(claddr.sun_path, sizeof(claddr.sun_path), "/tmp/shadowsocks.%s", server_port); unlink(claddr.sun_path); if (bind(sfd, (struct sockaddr *) &claddr, sizeof(struct sockaddr_un)) == -1) { ERROR("stat_bind"); close(sfd); return; } memset(&svaddr, 0, sizeof(struct sockaddr_un)); svaddr.sun_family = AF_UNIX; strncpy(svaddr.sun_path, manager_address, sizeof(svaddr.sun_path) - 1); if (sendto(sfd, resp, strlen(resp) + 1, 0, (struct sockaddr *) &svaddr, sizeof(struct sockaddr_un)) != msgLen) { ERROR("stat_sendto"); close(sfd); return; } unlink(claddr.sun_path); } else { struct sockaddr_storage storage; memset(&storage, 0, sizeof(struct sockaddr_storage)); if (get_sockaddr(ip_addr.host, ip_addr.port, &storage, 0) == -1) { ERROR("failed to parse the manager addr"); return; } sfd = socket(storage.ss_family, SOCK_DGRAM, 0); if (sfd == -1) { ERROR("stat_socket"); return; } size_t addr_len = get_sockaddr_len((struct sockaddr *)&storage); if (sendto(sfd, resp, strlen(resp) + 1, 0, (struct sockaddr *)&storage, addr_len) != msgLen) { ERROR("stat_sendto"); close(sfd); return; } } close(sfd); }
static int tcl_rmdir(ClientData cd, Tcl_Interp *irp, int argc, char *argv[]) { FILE *fdb; filedb_entry *fdbe; char *s = NULL, *t, *d, *p; BADARGS(2, 2, " dir"); malloc_strcpy(s, argv[1]); if (s[strlen(s) - 1] == '/') s[strlen(s) - 1] = 0; p = strrchr(s, '/'); if (p == NULL) { p = s; d = ""; } else { *p = 0; p++; d = s; } fdb = filedb_open(d, 0); if (!fdb) { Tcl_AppendResult(irp, "1", NULL); my_free(s); return TCL_OK; } filedb_readtop(fdb, NULL); fdbe = filedb_matchfile(fdb, ftell(fdb), p); if (!fdbe) { Tcl_AppendResult(irp, "1", NULL); filedb_close(fdb); my_free(s); return TCL_OK; } if (!(fdbe->stat & FILE_DIR)) { Tcl_AppendResult(irp, "1", NULL); filedb_close(fdb); free_fdbe(&fdbe); my_free(s); return TCL_OK; } /* Erase '.filedb' and '.files' if they exist */ t = nmalloc(strlen(dccdir) + strlen(d) + strlen(p) + 11); sprintf(t, "%s%s/%s/.filedb", dccdir, d, p); unlink(t); sprintf(t, "%s%s/%s/.files", dccdir, d, p); unlink(t); sprintf(t, "%s%s/%s", dccdir, d, p); my_free(s); if (rmdir(t) == 0) { filedb_delfile(fdb, fdbe->pos); filedb_close(fdb); free_fdbe(&fdbe); my_free(t); Tcl_AppendResult(irp, "0", NULL); return TCL_OK; } my_free(t); free_fdbe(&fdbe); filedb_close(fdb); Tcl_AppendResult(irp, "1", NULL); return TCL_OK; }
int main(int ac, char *av[]) { int pid, child, status, count, k, j; char name[3]; int lc; const char *msg; /* * parse standard options */ if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); /* * Default values for run conditions. */ iterations = 50; nchild = 5; if (signal(SIGTERM, term) == SIG_ERR) { tst_resm(TBROK, "first signal failed"); } /* use the default values for run conditions */ for (lc = 0; TEST_LOOPING(lc); lc++) { local_flag = PASSED; /* * Make a directory to do this in; ignore error if already exists. */ parent_pid = getpid(); tst_tmpdir(); if (!startdir[0]) { if (getcwd(startdir, MAXPATHLEN) == NULL) { tst_brkm(TFAIL | TERRNO, NULL, "getcwd failed"); } } cwd = startdir; snprintf(dirname, ARRAY_SIZE(dirname), "%s/ftest06.%d", cwd, getpid()); snprintf(homedir, ARRAY_SIZE(homedir), "%s/ftest06h.%d", cwd, getpid()); mkdir(dirname, 0755); mkdir(homedir, 0755); if (chdir(dirname) < 0) tst_brkm(TFAIL | TERRNO, cleanup, "\tCan't chdir(%s)", dirname); dirlen = strlen(dirname); if (chdir(homedir) < 0) tst_brkm(TFAIL | TERRNO, cleanup, "\tCan't chdir(%s)", homedir); /* enter block */ for (k = 0; k < nchild; k++) { if ((child = fork()) == 0) { dotest(k, iterations); tst_exit(); } if (child < 0) { tst_brkm(TBROK | TERRNO, cleanup, "fork failed"); } pidlist[k] = child; } /* * Wait for children to finish. */ count = 0; while ((child = wait(&status)) > 0) { //tst_resm(TINFO,"Test{%d} exited status = 0x%x", child, status); //fprintf(stdout, "status is %d",status); if (status) { tst_resm(TFAIL, "Test{%d} failed, expected 0 exit.", child); local_flag = FAILED; } ++count; } /* * Should have collected all children. */ if (count != nchild) { tst_resm(TFAIL, "Wrong # children waited on, count = %d", count); local_flag = FAILED; } if (local_flag == PASSED) tst_resm(TPASS, "Test passed."); else tst_resm(TFAIL, "Test failed."); if (iterations > 26) iterations = 26; for (k = 0; k < nchild; k++) for (j = 0; j < iterations + 1; j++) { ft_mkname(name, dirname, k, j); rmdir(name); unlink(name); } if (chdir(startdir) < 0) tst_brkm(TFAIL | TERRNO, cleanup, "Can't chdir(%s)", startdir); pid = fork(); if (pid < 0) { tst_brkm(TBROK | TERRNO, NULL, "fork failed"); } if (pid == 0) { execl("/bin/rm", "rm", "-rf", homedir, NULL); } else wait(&status); if (status) tst_resm(TINFO, "CAUTION - ftest06, '%s' may not have been removed.", homedir); pid = fork(); if (pid < 0) { tst_brkm(TBROK | TERRNO, NULL, "fork failed"); } if (pid == 0) { execl("/bin/rm", "rm", "-rf", dirname, NULL); exit(1); } else wait(&status); if (status) { tst_resm(TWARN, "CAUTION - ftest06, '%s' may not have been removed.", dirname); } sync(); } if (local_flag == FAILED) tst_resm(TFAIL, "Test failed."); else tst_resm(TPASS, "Test passed."); cleanup(); tst_exit(); }
static Port * OpenPortInternal(const DeviceConfig &config, DataHandler &handler) { const TCHAR *path = NULL; TCHAR buffer[MAX_PATH]; switch (config.port_type) { case DeviceConfig::PortType::DISABLED: return NULL; case DeviceConfig::PortType::SERIAL: if (config.path.empty()) return NULL; path = config.path.c_str(); break; case DeviceConfig::PortType::RFCOMM: #ifdef ANDROID if (config.bluetooth_mac.empty()) { LogFormat("No Bluetooth MAC configured"); return NULL; } return OpenAndroidBluetoothPort(config.bluetooth_mac, handler); #else LogFormat("Bluetooth not available on this platform"); return NULL; #endif case DeviceConfig::PortType::RFCOMM_SERVER: #ifdef ANDROID return OpenAndroidBluetoothServerPort(handler); #else LogFormat("Bluetooth not available on this platform"); return NULL; #endif case DeviceConfig::PortType::IOIOUART: #if defined(ANDROID) && defined(IOIOLIB) if (config.ioio_uart_id >= AndroidIOIOUartPort::getNumberUarts()) { LogFormat("No IOIOUart configured in profile"); return NULL; } return OpenAndroidIOIOUartPort(config.ioio_uart_id, config.baud_rate, handler); #else LogFormat("IOIO Uart not available on this platform or version"); return NULL; #endif case DeviceConfig::PortType::AUTO: if (!DetectGPS(buffer, sizeof(buffer))) { LogFormat("no GPS detected"); return NULL; } LogStartUp(_T("GPS detected: %s"), buffer); path = buffer; break; case DeviceConfig::PortType::INTERNAL: case DeviceConfig::PortType::DROIDSOAR_V2: case DeviceConfig::PortType::NUNCHUCK: case DeviceConfig::PortType::I2CPRESSURESENSOR: case DeviceConfig::PortType::IOIOVOLTAGE: break; case DeviceConfig::PortType::TCP_LISTENER: { TCPPort *port = new TCPPort(handler); if (!port->Open(config.tcp_port)) { delete port; return NULL; } return port; } case DeviceConfig::PortType::UDP_LISTENER: { SocketPort *port = new SocketPort(handler); if (!port->OpenUDPListener(config.tcp_port)) { delete port; return NULL; } return port; } case DeviceConfig::PortType::PTY: { #if defined(HAVE_POSIX) && !defined(ANDROID) if (config.path.empty()) return NULL; if (unlink(config.path.c_str()) < 0 && errno != ENOENT) return NULL; TTYPort *port = new TTYPort(handler); const char *slave_path = port->OpenPseudo(); if (slave_path == NULL) { delete port; return NULL; } if (symlink(slave_path, config.path.c_str()) < 0) { delete port; return NULL; } return port; #else return NULL; #endif } } if (path == NULL) return NULL; #ifdef HAVE_POSIX TTYPort *port = new TTYPort(handler); #else SerialPort *port = new SerialPort(handler); #endif if (!port->Open(path, config.baud_rate)) { delete port; return NULL; } return port; }
static pngquant_error write_image(png8_image *output_image, png24_image *output_image24, const char *outname, struct pngquant_options *options) { FILE *outfile; char *tempname = NULL; if (options->using_stdout) { set_binary_mode(stdout); outfile = stdout; if (output_image) { verbose_printf(options, " writing %d-color image to stdout", output_image->num_palette); } else { verbose_printf(options, " writing truecolor image to stdout"); } } else { tempname = temp_filename(outname); if (!tempname) return OUT_OF_MEMORY_ERROR; if ((outfile = fopen(tempname, "wb")) == NULL) { fprintf(stderr, " error: cannot open '%s' for writing\n", tempname); free(tempname); return CANT_WRITE_ERROR; } if (output_image) { verbose_printf(options, " writing %d-color image as %s", output_image->num_palette, filename_part(outname)); } else { verbose_printf(options, " writing truecolor image as %s", filename_part(outname)); } } pngquant_error retval; #pragma omp critical (libpng) { if (output_image) { retval = rwpng_write_image8(outfile, output_image); } else { retval = rwpng_write_image24(outfile, output_image24); } } if (!options->using_stdout) { fclose(outfile); if (SUCCESS == retval) { // Image has been written to a temporary file and then moved over destination. // This makes replacement atomic and avoids damaging destination file on write error. if (!replace_file(tempname, outname, options->force)) { retval = CANT_WRITE_ERROR; } } if (retval) { unlink(tempname); } free(tempname); } if (retval && retval != TOO_LARGE_FILE) { fprintf(stderr, " error: failed writing image to %s\n", outname); } return retval; }
static int task_main(int argc, char *argv[]) { work_q_item_t *work; /* inform about start */ warnx("Initializing.."); /* Initialize global variables */ g_key_offsets[0] = 0; for (unsigned i = 0; i < (DM_KEY_NUM_KEYS - 1); i++) g_key_offsets[i + 1] = g_key_offsets[i] + (g_per_item_max_index[i] * k_sector_size); unsigned max_offset = g_key_offsets[DM_KEY_NUM_KEYS - 1] + (g_per_item_max_index[DM_KEY_NUM_KEYS - 1] * k_sector_size); for (unsigned i = 0; i < dm_number_of_funcs; i++) g_func_counts[i] = 0; /* Initialize the item type locks, for now only DM_KEY_MISSION_STATE supports locking */ sem_init(&g_sys_state_mutex, 1, 1); /* Initially unlocked */ for (unsigned i = 0; i < DM_KEY_NUM_KEYS; i++) g_item_locks[i] = NULL; g_item_locks[DM_KEY_MISSION_STATE] = &g_sys_state_mutex; g_task_should_exit = false; init_q(&g_work_q); init_q(&g_free_q); sem_init(&g_work_queued_sema, 1, 0); /* See if the data manage file exists and is a multiple of the sector size */ g_task_fd = open(k_data_manager_device_path, O_RDONLY | O_BINARY); if (g_task_fd >= 0) { /* File exists, check its size */ int file_size = lseek(g_task_fd, 0, SEEK_END); if ((file_size % k_sector_size) != 0) { warnx("Incompatible data manager file %s, resetting it", k_data_manager_device_path); close(g_task_fd); unlink(k_data_manager_device_path); } else close(g_task_fd); } /* Open or create the data manager file */ g_task_fd = open(k_data_manager_device_path, O_RDWR | O_CREAT | O_BINARY); if (g_task_fd < 0) { warnx("Could not open data manager file %s", k_data_manager_device_path); sem_post(&g_init_sema); /* Don't want to hang startup */ return -1; } if ((unsigned)lseek(g_task_fd, max_offset, SEEK_SET) != max_offset) { close(g_task_fd); warnx("Could not seek data manager file %s", k_data_manager_device_path); sem_post(&g_init_sema); /* Don't want to hang startup */ return -1; } fsync(g_task_fd); /* see if we need to erase any items based on restart type */ int sys_restart_val; if (param_get(param_find("SYS_RESTART_TYPE"), &sys_restart_val) == OK) { if (sys_restart_val == DM_INIT_REASON_POWER_ON) { warnx("Power on restart"); _restart(DM_INIT_REASON_POWER_ON); } else if (sys_restart_val == DM_INIT_REASON_IN_FLIGHT) { warnx("In flight restart"); _restart(DM_INIT_REASON_IN_FLIGHT); } else warnx("Unknown restart"); } else warnx("Unknown restart"); /* We use two file descriptors, one for the caller context and one for the worker thread */ /* They are actually the same but we need to some way to reject caller request while the */ /* worker thread is shutting down but still processing requests */ g_fd = g_task_fd; warnx("Initialized, data manager file '%s' size is %d bytes", k_data_manager_device_path, max_offset); /* Tell startup that the worker thread has completed its initialization */ sem_post(&g_init_sema); /* Start the endless loop, waiting for then processing work requests */ while (true) { /* do we need to exit ??? */ if ((g_task_should_exit) && (g_fd >= 0)) { /* Close the file handle to stop further queuing */ g_fd = -1; } if (!g_task_should_exit) { /* wait for work */ sem_wait(&g_work_queued_sema); } /* Empty the work queue */ while ((work = dequeue_work_item())) { /* handle each work item with the appropriate handler */ switch (work->func) { case dm_write_func: g_func_counts[dm_write_func]++; work->result = _write(work->write_params.item, work->write_params.index, work->write_params.persistence, work->write_params.buf, work->write_params.count); break; case dm_read_func: g_func_counts[dm_read_func]++; work->result = _read(work->read_params.item, work->read_params.index, work->read_params.buf, work->read_params.count); break; case dm_clear_func: g_func_counts[dm_clear_func]++; work->result = _clear(work->clear_params.item); break; case dm_restart_func: g_func_counts[dm_restart_func]++; work->result = _restart(work->restart_params.reason); break; default: /* should never happen */ work->result = -1; break; } /* Inform the caller that work is done */ sem_post(&work->wait_sem); } /* time to go???? */ if ((g_task_should_exit) && (g_fd < 0)) break; } close(g_task_fd); g_task_fd = -1; /* The work queue is now empty, empty the free queue */ for (;;) { if ((work = (work_q_item_t *)sq_remfirst(&(g_free_q.q))) == NULL) break; if (work->first) free(work); } destroy_q(&g_work_q); destroy_q(&g_free_q); sem_destroy(&g_work_queued_sema); sem_destroy(&g_sys_state_mutex); return 0; }
/** * fit_handle_file - main FIT file processing function * * fit_handle_file() runs dtc to convert .its to .itb, includes * binary data, updates timestamp property and calculates hashes. * * datafile - .its file * imagefile - .itb file * * returns: * only on success, otherwise calls exit (EXIT_FAILURE); */ static int fit_handle_file(struct image_tool_params *params) { char tmpfile[MKIMAGE_MAX_TMPFILE_LEN]; char cmd[MKIMAGE_MAX_DTC_CMDLINE_LEN]; int tfd, destfd = 0; void *dest_blob = NULL; struct stat sbuf; void *ptr; off_t destfd_size = 0; /* Flattened Image Tree (FIT) format handling */ debug ("FIT format handling\n"); /* call dtc to include binary properties into the tmp file */ if (strlen (params->imagefile) + strlen (MKIMAGE_TMPFILE_SUFFIX) + 1 > sizeof (tmpfile)) { fprintf (stderr, "%s: Image file name (%s) too long, " "can't create tmpfile", params->imagefile, params->cmdname); return (EXIT_FAILURE); } sprintf (tmpfile, "%s%s", params->imagefile, MKIMAGE_TMPFILE_SUFFIX); /* We either compile the source file, or use the existing FIT image */ if (params->datafile) { /* dtc -I dts -O dtb -p 500 datafile > tmpfile */ snprintf(cmd, sizeof(cmd), "%s %s %s > %s", MKIMAGE_DTC, params->dtc, params->datafile, tmpfile); debug("Trying to execute \"%s\"\n", cmd); } else { snprintf(cmd, sizeof(cmd), "cp %s %s", params->imagefile, tmpfile); } if (system (cmd) == -1) { fprintf (stderr, "%s: system(%s) failed: %s\n", params->cmdname, cmd, strerror(errno)); goto err_system; } if (params->keydest) { destfd = mmap_fdt(params->cmdname, params->keydest, &dest_blob, &sbuf, 1); if (destfd < 0) goto err_keydest; destfd_size = sbuf.st_size; } tfd = mmap_fdt(params->cmdname, tmpfile, &ptr, &sbuf, 1); if (tfd < 0) goto err_mmap; /* set hashes for images in the blob */ if (fit_add_verification_data(params->keydir, dest_blob, ptr, params->comment, params->require_keys)) { fprintf(stderr, "%s Can't add hashes to FIT blob\n", params->cmdname); goto err_add_hashes; } /* for first image creation, add a timestamp at offset 0 i.e., root */ if (params->datafile && fit_set_timestamp(ptr, 0, sbuf.st_mtime)) { fprintf (stderr, "%s: Can't add image timestamp\n", params->cmdname); goto err_add_timestamp; } debug ("Added timestamp successfully\n"); munmap ((void *)ptr, sbuf.st_size); close (tfd); if (dest_blob) { munmap(dest_blob, destfd_size); close(destfd); } if (rename (tmpfile, params->imagefile) == -1) { fprintf (stderr, "%s: Can't rename %s to %s: %s\n", params->cmdname, tmpfile, params->imagefile, strerror (errno)); unlink (tmpfile); unlink (params->imagefile); return (EXIT_FAILURE); } return (EXIT_SUCCESS); err_add_timestamp: err_add_hashes: munmap(ptr, sbuf.st_size); err_mmap: if (dest_blob) munmap(dest_blob, destfd_size); err_keydest: err_system: unlink(tmpfile); return -1; }