void entrySection(int id) { // LEAVE THESE STATEMENTS int isFemale = femaleOnly ? 1 : (id % 2 == 0); // TODO: Complete this function if (isFemale) { mutexLock(id, &limitFemaleMutex); //pthread_mutex_lock(&limitFemaleMutex); // sem_wait(&female); semWait(id, &female); mutexLock(id, &femaleCountMutex); //pthread_mutex_lock(&femaleCountMutex); femaleCount++; if (femaleCount == 1) { // sem_wait(&male); semWait(id, &male); } mutexUnlock(id, &femaleCountMutex); //pthread_mutex_unlock(&femaleCountMutex); // sem_post(&female); semPost(id, &female); mutexUnlock(id, &limitFemaleMutex); //pthread_mutex_unlock(&limitFemaleMutex); } else { mutexLock(id, &limitMaleMutex); //pthread_mutex_lock(&limitMaleMutex); //sem_wait(&male); semWait(id, &male); mutexLock(id, &maleCountMutex); //pthread_mutex_lock(&maleCountMutex); maleCount++; if (maleCount == 1) { //sem_wait(&female); semWait(id, &female); } mutexUnlock(id, &maleCountMutex); //pthread_mutex_unlock(&maleCountMutex); //sem_post(&male); semPost(id, &male); mutexUnlock(id, &limitMaleMutex); //pthread_mutex_unlock(&limitMaleMutex); } }
static ssize_t pipe_read(File *fp, void *buffer, size_t size) { if (size == 0) return 0; Pipe *pipe = (Pipe*) fp->fsdata; semWait(&pipe->sem); if (pipe->size == 0) { if (pipe->writecount == 0) { semSignal(&pipe->sem); return 0; } else if (fp->oflag & O_NONBLOCK) { semSignal(&pipe->sem); getCurrentThread()->therrno = EAGAIN; return -1; } else { semSignal(&pipe->sem); while (1) { if (getCurrentThread()->sigcnt > 0) { getCurrentThread()->therrno = EINTR; return -1; }; semWait(&pipe->sem); if (pipe->size > 0) break; semSignal(&pipe->sem); }; }; }; if (size > pipe->size) size = pipe->size; ssize_t outSize = 0; uint8_t *out = (uint8_t*) buffer; while (size--) { *out++ = pipe->buffer[pipe->offRead]; pipe->offRead = (pipe->offRead + 1) % 1024; outSize++; pipe->size--; }; semSignal(&pipe->sem); return outSize; };
static ssize_t pipe_write(File *fp, const void *buffer, size_t size) { if (size == 0) return 0; Pipe *pipe = (Pipe*) fp->fsdata; semWait(&pipe->sem); if (pipe->readcount == 0) { semSignal(&pipe->sem); return 0; }; if ((pipe->size+size) > 1024) { if (fp->oflag & O_NONBLOCK) { semSignal(&pipe->sem); getCurrentThread()->therrno = EAGAIN; return -1; } else { semSignal(&pipe->sem); while (1) { if (getCurrentThread()->sigcnt > 0) { getCurrentThread()->therrno = EINTR; return -1; }; semWait(&pipe->sem); if ((pipe->size+size) <= 1024) break; semSignal(&pipe->sem); }; }; }; ssize_t inSize = 0; const uint8_t *in = (const uint8_t*) buffer; while (size--) { pipe->buffer[pipe->offWrite] = *in++;; pipe->offWrite = (pipe->offWrite + 1) % 1024; inSize++; pipe->size++; }; semSignal(&pipe->sem); return inSize; };
static int gxdir_chmod(Dir *dir, mode_t mode) { time_t now = time(); GXDir *gxdir = (GXDir*) dir->fsdata; semWait(&gxdir->gxfs->sem); //kprintf_debug("gxfs: chmod on inode %d\n", dir->dirent.d_ino); GXInode gxino; GXOpenInode(gxdir->gxfs, &gxino, dir->dirent.d_ino); gxfsInode inode; GXReadInodeHeader(&gxino, &inode); inode.inoMode = (inode.inoMode & 0xF000) | (mode & 0x0FFF); inode.inoCTime = now; GXWriteInodeHeader(&gxino, &inode); dir->stat.st_mode = (mode_t) inode.inoMode; dir->stat.st_ctime = inode.inoCTime; if (gxdir->gxfs->fp->fsync != NULL) gxdir->gxfs->fp->fsync(gxdir->gxfs->fp); semSignal(&gxdir->gxfs->sem); return 0; };
/* ========================================================================= */ inline static void pong_busy(int _N) { while(_N--) { semWait(g_semPing); sem_post(g_semPong); } }
static int gxdir_chown(Dir *dir, uid_t uid, gid_t gid) { time_t now = time(); GXDir *gxdir = (GXDir*) dir->fsdata; semWait(&gxdir->gxfs->sem); //kprintf_debug("gxfs: chmod on inode %d\n", dir->dirent.d_ino); GXInode gxino; GXOpenInode(gxdir->gxfs, &gxino, dir->dirent.d_ino); gxfsInode inode; GXReadInodeHeader(&gxino, &inode); inode.inoOwner = (uint16_t) uid; inode.inoGroup = (uint16_t) gid; inode.inoCTime = now; GXWriteInodeHeader(&gxino, &inode); dir->stat.st_mode = (mode_t) inode.inoMode; dir->stat.st_ctime = inode.inoCTime; if (gxdir->gxfs->fp->fsync != NULL) gxdir->gxfs->fp->fsync(gxdir->gxfs->fp); semSignal(&gxdir->gxfs->sem); return 0; };
static int gxdir_next(Dir *dir) { GXDir *gxdir = (GXDir*) dir->fsdata; semWait(&gxdir->gxfs->sem); if ((gxdir->index++) == gxdir->count) { semSignal(&gxdir->gxfs->sem); return -1; }; gxdir->offCurrent = gxdir->gxino.pos; char buffer[257]; GXReadInode(&gxdir->gxino, buffer, gxdir->szNext); buffer[gxdir->szNext] = 0; gxfsDirent *ent = (gxfsDirent*) buffer; gxdir->szNext = ent->deNextSz; if (ent->deNameLen > 127) { semSignal(&gxdir->gxfs->sem); return -1; }; strcpy(dir->dirent.d_name, ent->deName); dir->dirent.d_ino = ent->deInode; //kprintf_debug("NEXT INODE : %d\n", ent->deInode); if (dir->dirent.d_ino == 0) dir->dirent.d_name[0] = 0; //kprintf_debug("NEXT: %s (%d)\n", dir->dirent.d_name, dir->dirent.d_ino); semSignal(&gxdir->gxfs->sem); return 0; };
static XObj bidCreateSessn( XObj self, XObj hlpRcv, XObj hlpType, ActiveKey *key, Path path) { PState *ps = (PState *)self->state; XObj s; /* * We might block (but only briefly), so we'll only allow one * thread to create a session at a time to avoid map binding * conflicts. */ semWait(&ps->sessnCreationSem); /* * Check again now that we have the lock */ if ( mapResolve(ps->activeMap, key, &s) == XK_FAILURE ) { s = bidNewSessn(self, hlpRcv, hlpType, key, path); } semSignal(&ps->sessnCreationSem); return s; }
//------------------------------------------------------------------------------ void WorkerThread::handler() { while (1) { semWait(&semaphore); if (finalize) break; if (!argumentCount || firstArgument == nullptr || baseContext == nullptr) continue; for (auto entry : owner.owner.commands()) { if (!strcmp(entry->name(), *firstArgument)) { memcpy(&environment, baseContext, sizeof(Shell::ShellContext)); const result res = entry->run(argumentCount - 1, firstArgument + 1, &environment); owner.onCommandCompleted(this, res); break; } } } }
void tcpsock_shutdown(Socket *sock, int shutflags) { TCPSocket *tcpsock = (TCPSocket*) sock; semWait(&tcpsock->lock); if (shutflags & SHUT_RD) { if ((tcpsock->shutflags & SHUT_RD) == 0) { tcpsock->shutflags |= SHUT_RD; // do not terminate the receive semaphore. this should only happen // if we actually receive a FIN. }; }; if (shutflags & SHUT_WR) { if ((tcpsock->shutflags & SHUT_WR) == 0) { tcpsock->shutflags |= SHUT_WR; semTerminate(&tcpsock->semSendPut); }; }; semSignal(&tcpsock->lock); };
void brelse(buffer *buff) { debug(BUFFER_DL, "brelse(buff:%p) {\n", buff); // wait for semaphore to start while (!semWait(semid)) { // skip signal interruptions if (errno != EINTR) { perror("brelse, semWait"); debug(2 + BUFFER_DL, "ERROR en brelse, semWait."); exit(1); } } // enqueue buffer at end of free list setfree(buff); // unlock buffer BS_CLR(buff->status, BS_LOCKED); // wakeup all procs waiting for any buffer to become free brelease(NULL); // wakeup all procs waiting for this buffer to become free brelease(buff); // free the semaphore if (!semSignal(semid)) { perror("brelse, semSignal"); debug(2 + BUFFER_DL, "ERROR en brelse, semSignal."); exit(1); } debug(BUFFER_DL, "}\n"); }
static File *openPipe(Pipe *pipe, int mode) { semWait(&pipe->sem); File *fp = (File*) kmalloc(sizeof(File)); memset(fp, 0, sizeof(File)); if (mode == O_RDONLY) { pipe->readcount++; } else { pipe->writecount++; }; fp->fsdata = pipe; fp->oflag = mode; fp->read = pipe_read; fp->write = pipe_write; fp->close = pipe_close; fp->dup = pipe_dup; fp->fstat = pipe_fstat; semSignal(&pipe->sem); return fp; };
static void isofile_close(File *fp) { ISOFile *file = (ISOFile*) fp->fsdata; semWait(&file->isofs->sem); file->isofs->numOpenInodes--; semSignal(&file->isofs->sem); kfree(fp->fsdata); };
void termPutChar(char c) { semWait(&semLineBuffer); if ((c == '\b') && (termState.c_lflag & ICANON)) { if (lineBufferSize != 0) { if (inputWrite == 0) inputWrite = INPUT_BUFFER_SIZE; else inputWrite--; lineBufferSize--; if (termState.c_lflag & ECHO) kprintf("\b"); }; semSignal(&semLineBuffer); return; } else if (c < 0x80) { inputBuffer[inputWrite++] = c; if (inputWrite == INPUT_BUFFER_SIZE) inputWrite = 0; lineBufferSize++; }; __sync_synchronize(); if (((c & 0x80) == 0) && (termState.c_lflag & ECHO)) { kprintf("%c", c); } else if ((c == '\n') && (termState.c_lflag & ECHONL)) { kprintf("\n"); }; if ((termState.c_lflag & ICANON) == 0) { semSignal2(&semCount, lineBufferSize); lineBufferSize = 0; } else if (c == '\n') { semSignal2(&semCount, lineBufferSize); lineBufferSize = 0; }; if ((unsigned char)c == CC_VINTR) { if (termState.c_lflag & ECHO) kprintf("^C"); if (termState.c_lflag & ICANON) { inputWrite = inputRead; while (semWaitGen(&semCount, 1024, SEM_W_NONBLOCK, 0) > 0); lineBufferSize = 0; }; if (termGroup != 0) signalPid(-termGroup, SIGINT); }; semSignal(&semLineBuffer); };
static void gxdir_close(Dir *dir) { GXDir *gxdir = (GXDir*) dir->fsdata; semWait(&gxdir->gxfs->sem); gxdir->gxfs->numOpenInodes--; semSignal(&gxdir->gxfs->sem); kfree(dir->fsdata); };
int main(int argc, char *argv[]) { struct busTicket myTicket; pname = argc > 0 ? argv[1] : "CUSTOMER"; pid = getpid(); printInfo("Initializing Customer"); /* initialize shared resource variables */ locateResources(&semid, &shmid, &shm); /* get in line */ semWait(semid, SEM_LINE); printInfo("My turn in line"); /* wait for mutex */ semWait(semid, SEM_MUTEX); /* tell agent my name */ snprintf(shm->name, sizeof(shm->name), "%s", pname); semSignal(semid, SEM_AGENT); /* wait for my ticket to be assigned */ semWait(semid, SEM_TICKET); /* get the ticket */ myTicket = shm->ticket; sprintf(buf, "My Ticket: [Name:%s Seat:%d Depart:%ld]", myTicket.name, myTicket.seat, myTicket.depart); printInfo(buf); /* release mutex */ if(myTicket.depart == shm->nbDepart) { printInfo("Waiting for next bus"); shm->nbWait++; semSignal(semid, SEM_MUTEX); /* wait for next bus */ semWait(semid, SEM_NBUS); } else { semSignal(semid, SEM_MUTEX); } /* board the bus */ printInfo("Boarding the bus"); return EXIT_SUCCESS; }
int main(int argc, char const *argv[]) { pid = getpid(); printf("Pid of this Client is: %d\n",pid); //////////semGet////////////////// semid = semGet(SEMNUM); printf("semid: %d\n",semid); //////opeing famous fifo to place request/////// fd = open(famfifo,O_WRONLY); assert(fd != -1); /////place request//////////// struct Request req; req.pid = pid; semWait(semid,0); //acquire mutex write(fd,&req,REQSIZE); //place request semSignal(semid,1); //notify server that request is available semWait(semid,1); //wait until fifo gets created by server genearteFifo(pid); //opnes 2 fifo names pid.in and pid.out already created by server semSignal(semid,0); //release mutex /////////////////////////////////////////////////////// ///////////////Server to poll msg from other clients///////////// assert(pthread_create(&tid,NULL,pollServer,NULL) == 0); /////////////Take Msg from STDIN////////////////// char buff[BUFFSIZE]; while(1) { int pos=0; char ch; struct Msg msg; printf("write===: "); while((ch = getchar()) != '\n') msg.data[pos++] = ch; msg.pid = pid; msg.data[pos] = '\0'; write(ofd,&msg,MSGSIZE); } return 0; }
int p2Task(int argc, char* argv[]) { time_t curTime; while(1) { semWait(tics10sec); time(&curTime); printf("\nTask[%s] Activated at: %s", argv[0], ctime(&curTime)); } }
static int isofile_dup(File *me, File *fp, size_t szfile) { ISOFile *org = (ISOFile*) me->fsdata; semWait(&org->isofs->sem); org->isofs->numOpenInodes++; ISOFile *file = (ISOFile*) kmalloc(sizeof(ISOFile)); memcpy(file, me->fsdata, sizeof(ISOFile)); memcpy(fp, me, szfile); fp->fsdata = file; semSignal(&org->isofs->sem); return 0; };
int pipeWrite(struct Pipe *pipe, const void *buffer, size_t size) { const char *cbuf = (const char *)buffer; while (size) { semWait(&pipe->bytesFree); pipe->buf[pipe->wIndex] = *cbuf; semSignal(&pipe->bytesUsed); pipe->wIndex = (pipe->wIndex + 1) % PIPE_BUF; cbuf++; size--; } return 0; }
ssize_t pipeRead(struct Pipe *pipe, void *buffer, size_t size) { char *cbuf = (char *)buffer; ssize_t ret = 0; while (ret != (ssize_t)size) { semWait(&pipe->bytesUsed); *cbuf = pipe->buf[pipe->rIndex]; semSignal(&pipe->bytesFree); pipe->rIndex = (pipe->rIndex + 1) % PIPE_BUF; ret++; cbuf++; } return ret; }
static int sendSWP(SwpState *state, Msg *frame) { struct sendQ_slot *slot; hbuf[HLEN]; //wait for send window to open semWait(&state->sendWindowNotFull); state->hdr.SeqNum = ++state->LFS; slot = &state->sendQ[state->hdr.SeqNum % SWS]; store_swp_hdr(state->hdr, hbuf); msgAddHdr(frame, hbuf, HLEN); msgSaveCopy(&slot->msg, frame); slot->timeout = evSchedule(swpTimeout, slot, SWP_SEND_TIMEOUT); return send(LINK, frame); }
static ssize_t gxdir_readlink(Dir *dir, char *buffer) { GXDir *gxdir = (GXDir*) dir->fsdata; semWait(&gxdir->gxfs->sem); GXInode gxInode; GXOpenInode(gxdir->gxfs, &gxInode, dir->dirent.d_ino); gxfsInode inode; GXReadInodeHeader(&gxInode, &inode); strcpy(buffer, (const char*) inode.inoFrags); semSignal(&gxdir->gxfs->sem); return strlen(buffer); };
int tryPush( XObj self, XObj sessn, int times, int length ) { xkern_return_t xkr; int i; Msg_s savedMsg, request; int c = 0; PState *ps = (PState *)self->state; #if MACH_KERNEL tvalspec_t time_val_before, time_val_after; #endif /* MACH_KERNEL */ xkr = msgConstructContig(&savedMsg, self->path, (u_int)length, TEST_STACK_SIZE); if (xkr == XK_FAILURE) { sprintf(errBuf, "Could not construct a msg of length %d\n", length + TEST_STACK_SIZE); Kabort(errBuf); } msgConstructContig(&request, self->path, 0, 0); semInit(&ps->sema, 0); ps->flushing = FALSE; ps->partialcount = times - 1; #if MACH_KERNEL rtc_gettime(&ps->starttime); rtc_gettime(&ps->partialtime); #else xGetTime(&ps->starttime); #endif /* MACH_KERNEL */ for (i = 0; i < ps->groupsize; i++) { msgAssign(&request, &savedMsg); xkr = xPush(sessn, &request); if( xkr == XK_FAILURE ) { printf( "Dgram Push error %d\n" , xkr ); goto abort; } } evSchedule(ps->evdgram, dgram_abort, self, 30000000); semWait(&ps->sema); evCancel(ps->evdgram); abort: msgDestroy(&savedMsg); msgDestroy(&request); return (times - ps->partialcount); }
int recvFileList(int sfd, struct actionParameters *ap, struct serverActionParameters *sap){ int res; struct flEntry file; struct array *fl2; //memmove(&file.ip,&ap->comip, sizeof(struct sockaddr)); file.ip = ap->comip; while (( res = getTokenFromStream( sfd, &ap->combuf, &ap->comline, "\n", "\r\n",NULL ))){ if (res == -1) return -1; strcpy(file.filename, (char *)ap->comline.buf); flushBuf(&ap->comline); if (getTokenFromStream( sfd, &ap->combuf, &ap->comline, "\n", "\r\n",NULL ) == -1) return -1; long size = my_strtol((char *)ap->comline.buf); if ( errno || size < 0 ) { file.size = size; logmsg(ap->semid, ap->logfd, LOGLEVEL_WARN, "problem converting file size for %s - %s\n", file.filename, ap->comline.buf); continue; } logmsg(ap->semid, ap->logfd, LOGLEVEL_VERBOSE, "recvFileList: %s - %lu\n", file.filename, file.size); if ( (res = semWait(ap->semid, SEM_FILELIST))) logmsg(ap->semid, ap->logfd, LOGLEVEL_WARN, "(recvfile) can't get semaphore, %d", res); fl2 = addArrayItem(sap->filelist, &file); if ( (res = semSignal(ap->semid, SEM_FILELIST))) logmsg(ap->semid, ap->logfd, LOGLEVEL_WARN, "(recvfile) can't release semaphore, %d", res); if (fl2) sap->filelist = fl2; else { logmsg(ap->semid, ap->logfd, LOGLEVEL_FATAL, "leaving the functions because realloc failed %d", fl2); return -1; } } return 1; }
int main(int argc, char const *argv[]) { setbuf(stdout, NULL); printf("%s created============\n",servername); /////////SemGet and Init/////////// semid = semGet(SEMNUM); printf("semid: %d\n",semid); unsigned short arr[] = {1,0}; semInit(semid,arr,SEMNUM); ////////////////create famfifo/////////////// unlink(famfifo); int ret = mkfifo(famfifo,0666); assert(ret != -1); ffd = open(famfifo,O_RDWR); assert(ffd != -1); //////////////////////////////////////////// //////////Create another thread to poll clients///////// assert(pthread_mutex_init(&mut,NULL) == 0); assert(pthread_create(&tid,NULL,pollFifo,NULL) == 0); struct Request req; int i; while(1) { semWait(semid,1); read(ffd,&req,REQSIZE); printf("Request received from: %d\n",req.pid); genearteFifo(req.pid); cfd[numclients][INSTREAM] = ifd; cfd[numclients][OUTSTREAM] = ofd; pfd[numclients].fd = ifd; pfd[numclients].events = POLLIN; pfd[numclients].revents = 0; ////////Use MUTEX to CHANGE tHIS exclusively/////////// pthread_mutex_lock(&mut); numclients++; printf("numclients %d\n",numclients); pthread_mutex_unlock(&mut); ////////////////////////////////////// semSignal(semid,1); } return 0; }
static int gxdir_unlink(Dir *dir) { GXDir *gxdir = (GXDir*) dir->fsdata; GXFileSystem *gxfs = gxdir->gxfs; if (dir->dirent.d_ino < gxfs->cis.cisFirstDataIno) { return -1; }; semWait(&gxdir->gxfs->sem); gxfsInode parentInode; GXReadInodeHeader(&gxdir->gxino, &parentInode); parentInode.inoCTime = time(); parentInode.inoMTime = time(); parentInode.inoLinks--; // file count decreases GXWriteInodeHeader(&gxdir->gxino, &parentInode); // rermove the current entry by setting the inode to 0. uint64_t inodeZero = 0; gxdir->gxino.pos = gxdir->offCurrent; GXWriteInode(&gxdir->gxino, &inodeZero, 8); #if 0 if (gxdir->gxino.pos != parentInode.inoSize) { off_t thisPos = gxdir->gxino.pos - sizeof(struct dirent); gxdir->gxino.pos = thisPos; struct dirent ent; memset(&ent, 0, sizeof(struct dirent)); GXWriteInode(&gxdir->gxino, &ent, sizeof(struct dirent)); } else { GXShrinkInode(&gxdir->gxino, sizeof(struct dirent), &parentInode); GXWriteInodeHeader(&gxdir->gxino, &parentInode); }; #endif // TODO: file opens should add to inoLinks! GXInode gxino; GXOpenInode(gxfs, &gxino, dir->dirent.d_ino); GXUnlinkInode(&gxino); semSignal(&gxdir->gxfs->sem); return 0; };
void registerFSDriver(FSDriver *drv) { semWait(&semFS); if (firstDriver == NULL) { firstDriver = drv; drv->prev = NULL; drv->next = NULL; } else { FSDriver *last = firstDriver; while (last->next != NULL) last = last->next; last->next = drv; drv->prev = last; drv->next = NULL; }; semSignal(&semFS); };
int main(int argc, char const *argv[]) { char buff[512]; setbuf(stdout,NULL); int semid; assert((semid=semget(SEMKEY,1,IPC_CREAT|0666)) != -1); int fd = open(famfifo,O_RDWR); assert(fd !=-1); while(1) { semWait(semid,0); printf("write (fifo) :"); int size = read(0,buff,BUFFSIZE); //printf("read %s\n",buff); write(fd,buff,size); semSignal(semid,0); } return 0; }
/** * signalTask */ int signalTask(int argc, char* argv[]) { int count = 0; /* task variable */ TCB* tcb = getTCB(); int curTask = gettid(); // create a semaphore int* mySem = (!strcmp(argv[1], "s1Sem")) ? &s1Sem : &s2Sem; *mySem = createSemaphore(argv[1], 0, 1); // loop waiting for semaphore to be signaled while(count < COUNT_MAX) { semWait(*mySem); printf("%s Task[%d], count=%d\n", tcb[curTask].name, curTask, ++count); } return 0; }