struct rwlock *rwlock_create(const char *name) { struct rwlock *rw; rw=kmalloc(sizeof(struct rwlock)); if(rw==NULL) { return NULL; } rw->rwlock_name=kstrdup(name); if(rw->rwlock_name==NULL) { kfree(rw); return NULL; } rw->rd_wchan=wchan_create(rw->rwlock_name); if(rw->rd_wchan==NULL) { kfree(rw->rwlock_name); kfree(rw); return NULL; } rw->wr_wchan=wchan_create(rw->rwlock_name); if(rw->wr_wchan==NULL) { kfree(rw->rwlock_name); kfree(rw); return NULL; } rw->rw_sem=sem_create("mysem",20); rw->rw_lock=lock_create("mylock"); ///rw->res_count=MAXREADERS; return rw; }
struct lock * lock_create(const char *name) { /* DEBUG(DB_THREADS, "Inside Lock_create");*/ struct lock *lock; lock = kmalloc(sizeof(struct lock)); if (lock == NULL) { return NULL; } lock->lk_name = kstrdup(name); if (lock->lk_name == NULL) { kfree(lock); return NULL; } // add stuff here as needed lock->lock_wchan = wchan_create(lock->lk_name); if (lock->lock_wchan == NULL) { kfree(lock->lk_name); kfree(lock); return NULL; } spinlock_init(&lock->lk_spinlock); lock->lock_hold=0; lock->lk_thread= NULL; /* DEBUG(DB_THREADS, "Exiting lock_create");*/ return lock; }
struct cv * cv_create(const char *name) { struct cv *cv; cv = kmalloc(sizeof(struct cv)); if (cv == NULL) { return NULL; } cv->cv_name = kstrdup(name); if (cv->cv_name==NULL) { kfree(cv); return NULL; } // add stuff here as needed /* * @Author: Student * Implementing Condition Variable by defining the name * and initializing the wait channel */ cv->cv_wchan= wchan_create(cv->cv_name); if (cv->cv_wchan == NULL) { kfree(cv->cv_name); kfree(cv); return NULL; } return cv; }
struct semaphore * sem_create(const char *name, int initial_count) { struct semaphore *sem; KASSERT(initial_count >= 0); sem = kmalloc(sizeof(struct semaphore)); if (sem == NULL) { return NULL; } sem->sem_name = kstrdup(name); if (sem->sem_name == NULL) { kfree(sem); return NULL; } sem->sem_wchan = wchan_create(sem->sem_name); if (sem->sem_wchan == NULL) { kfree(sem->sem_name); kfree(sem); return NULL; } spinlock_init(&sem->sem_lock); sem->sem_count = initial_count; return sem; }
struct cv * cv_create(const char *name) { struct cv *mycv; mycv = kmalloc(sizeof(struct cv)); if (mycv == NULL) { return NULL; } mycv->cv_name = kstrdup(name); if (mycv->cv_name==NULL) { kfree(mycv); return NULL; } // add stuff here as needed spinlock_init(&mycv->cv_spinlock); mycv->cv_wchan = wchan_create(mycv->cv_name); if (mycv->cv_wchan == NULL) { kfree(mycv->cv_name); kfree(mycv); return NULL; } //end of added stuff return mycv; }
struct lock * lock_create(const char *name) { struct lock *lock; lock = kmalloc(sizeof(struct lock)); if (lock == NULL) { return NULL; } lock->lk_name = kstrdup(name); if (lock->lk_name == NULL) { kfree(lock); return NULL; } // add stuff here as needed lock->lock_wchan = wchan_create("Lock WChan"); if (lock->lock_wchan == NULL) { kfree (lock->lk_name); kfree (lock); return NULL; } spinlock_init(&lock->slock); lock->locked = false; lock->owner = curthread; return lock; }
struct cv * cv_create(const char *name) { struct cv *cv; cv = kmalloc(sizeof(*cv)); if (cv == NULL) { return NULL; } cv->cv_name = kstrdup(name); if (cv->cv_name == NULL) { kfree(cv); return NULL; } cv->cv_wchan = wchan_create(cv->cv_name); if (cv->cv_wchan == NULL) { kfree(cv->cv_name); kfree(cv); return NULL; } spinlock_init(&cv->cv_lock); return cv; }
struct lock * lock_create(const char *name) { struct lock *lock; lock = kmalloc(sizeof(struct lock)); if (lock == NULL) { return NULL; } lock->lk_name = kstrdup(name); if (lock->lk_name == NULL) { kfree(lock); return NULL; } lock->lk_wchan = wchan_create(lock->lk_name); if (lock->lk_wchan == NULL) { kfree(lock->lk_name); kfree(lock); return NULL; } spinlock_init(&lock->lk_spinlock); lock->lk_owner = NULL; return lock; }
struct lock * lock_create(const char *name) { struct lock *lock; lock = kmalloc(sizeof(*lock)); if (lock == NULL) { return NULL; } lock->lk_name = kstrdup(name); if (lock->lk_name == NULL) { kfree(lock); return NULL; } HANGMAN_LOCKABLEINIT(&lock->lk_hangman, lock->lk_name); lock->lk_wchan = wchan_create(lock->lk_name); if (lock->lk_wchan == NULL) { kfree(lock->lk_name); kfree(lock); return NULL; } spinlock_init(&lock->lk_lock); lock->lk_holder = NULL; return lock; }
struct lock * lock_create(const char *name) { struct lock *lock; lock = kmalloc(sizeof(*lock)); if (lock == NULL) { return NULL; } lock->lk_name = kstrdup(name); if (lock->lk_name == NULL) { kfree(lock); return NULL; } lock->lk_wchan = wchan_create(lock->lk_name); if (lock->lk_wchan == NULL) { kfree(lock->lk_name); kfree(lock); return NULL; } spinlock_init(&lock->lk_spinlock); lock->lk_isheld = false; lock->lk_curthread = NULL; // add stuff here as needed return lock; }
struct cv * cv_create(const char *name) { struct cv *cv; cv = kmalloc(sizeof(struct cv)); if (cv == NULL) { return NULL; } cv->cv_name = kstrdup(name); if (cv->cv_name==NULL) { kfree(cv); return NULL; } // add stuff here as needed #if OPT_A1 cv->cv_wchan = wchan_create(cv->cv_name); if (cv->cv_wchan == NULL) { kfree(cv->cv_name); kfree(cv); return NULL; } #endif return cv; }
struct cv * cv_create(const char *name) { struct cv *cv; cv = kmalloc(sizeof(struct cv)); if (cv == NULL) { return NULL; } cv->cv_name = kstrdup(name); if (cv->cv_name==NULL) { kfree(cv); return NULL; } //create the wchan for CV cv->cv_wchan = wchan_create(cv->cv_name); if (cv->cv_wchan == NULL) { kfree(cv->cv_name); kfree(cv); } return cv; }
struct lock * lock_create(const char *name) { struct lock *mylock; mylock = kmalloc(sizeof(struct lock)); if (mylock == NULL) { return NULL; } mylock->lk_name = kstrdup(name); if (mylock->lk_name == NULL) { kfree(mylock); return NULL; } // add stuff here as needed mylock->lk_wchan = wchan_create(mylock->lk_name); if (mylock->lk_wchan == NULL) { kfree(mylock->lk_name); kfree(mylock); return NULL; } spinlock_init(&mylock->lk_spinlock); mylock->owner_thread = NULL; //end of added stuff return mylock; }
struct lock * lock_create(const char *name) { struct lock *lock; lock = kmalloc(sizeof(struct lock)); if (lock == NULL) { return NULL; } lock->lk_name = kstrdup(name); if (lock->lk_name == NULL) { kfree(lock); return NULL; } // add stuff here as needed //Peng 2.19.2016 lock->lock_wchan = wchan_create(lock->lk_name); if (lock->lock_wchan == NULL) { kfree(lock->lk_name); kfree(lock); return NULL; } spinlock_init(&lock->lock_splk); lock->held=false; lock->holder=NULL; //Peng return lock; }
struct cv * cv_create(const char *name) { struct cv *cv; cv = kmalloc(sizeof(struct cv)); if (cv == NULL) { return NULL; } cv->cv_name = kstrdup(name); if (cv->cv_name==NULL) { kfree(cv); return NULL; } // add stuff here as needed cv->cv_wchan = wchan_create(cv->cv_name); if (cv->cv_wchan == NULL) { kfree(cv->cv_name); kfree(cv); return NULL; } spinlock_init(&cv->cv_splk); // return cv; }
struct lock * lock_create(const char *name) { struct lock *lock; lock = kmalloc(sizeof(struct lock)); if (lock == NULL) { return NULL; } lock->lk_name = kstrdup(name); if (lock->lk_name == NULL) { kfree(lock); return NULL; } #if OPT_A1 lock->lk_wchan = wchan_create(lock->lk_name); if (lock->lk_wchan == NULL) { kfree(lock->lk_name); kfree(lock); return NULL; } spinlock_init(&lock->lk_spinlock); lock->lk_holder = NULL; # endif // add stuff here as needed return lock; }
struct lock * lock_create(const char *name) { struct lock *lock; lock = kmalloc(sizeof(struct lock)); if (lock == NULL) { return NULL; } lock->lk_name = kstrdup(name); if (lock->lk_name == NULL) { kfree(lock); return NULL; } #if OPT_A1 lock->who_hold = NULL; lock->be_held = false; lock->lk_wchan = wchan_create(lock->lk_name); if (lock->lk_wchan == NULL) { kfree(lock->lk_name); kfree(lock); return NULL; } spinlock_init(&lock->lk_lock); #endif //kprintf("create sucessfully %s\n",name); return lock; }
struct lock * lock_create(const char *name) { struct lock *lock; lock = kmalloc(sizeof(struct lock)); if (lock == NULL) { return NULL; } lock->lk_name = kstrdup(name); if (lock->lk_name == NULL) { kfree(lock); return NULL; } #if OPT_A1 lock->lock_wchan = wchan_create(lock->lk_name); if (lock->lock_wchan == NULL) { kfree(lock->lk_name); kfree(lock); } spinlock_init(&lock->lk_spinlock); lock->available = true; #endif return lock; }
/* * Start up secondary cpus. Called from boot(). */ void thread_start_cpus(void) { char buf[64]; unsigned i; cpu_identify(buf, sizeof(buf)); kprintf("cpu0: %s\n", buf); cpu_startup_sem = sem_create("cpu_hatch", 0); thread_count_wchan = wchan_create("thread_count"); mainbus_start_cpus(); num_cpus = cpuarray_num(&allcpus); for (i=0; i<num_cpus - 1; i++) { P(cpu_startup_sem); } sem_destroy(cpu_startup_sem); if (i == 0) { kprintf("1 CPU online\n"); } else { kprintf("%d CPUs online\n", i + 1); } cpu_startup_sem = NULL; // Gross hack to deal with os/161 "idle" threads. Hardcode the thread count // to 1 so the inc/dec properly works in thread_[fork/exit]. The one thread // is the cpu0 boot thread (menu), which is the only thread that hasn't // exited yet. thread_count = 1; }
struct lock * lock_create(const char *name) { struct lock* new_lock; new_lock = kmalloc(sizeof(struct lock)); if (new_lock == NULL) { return NULL; } new_lock->lk_name = kstrdup(name); if (new_lock->lk_name == NULL) { kfree(new_lock); return NULL; } new_lock->lk_wchan = wchan_create(new_lock->lk_name); if (new_lock->lk_wchan == NULL) { kfree(new_lock->lk_name); kfree(new_lock); return NULL; } spinlock_init(&new_lock->spin_lock); spinlock_data_set(&new_lock->lk_busy, 0); new_lock->lk_cpu = NULL; new_lock->lk_thread = NULL; return new_lock; }
static void setup(void) { char tmp[16]; int i; if (wakersem == NULL) { wakersem = sem_create("wakersem", 1); donesem = sem_create("donesem", 0); for (i=0; i<NWAITCHANS; i++) { snprintf(tmp, sizeof(tmp), "wc%d", i); waitchans[i] = wchan_create(kstrdup(tmp)); } } wakerdone = 0; }
struct cv* cv_create(const char* name) { struct cv* cv; cv = kmalloc(sizeof(struct cv)); if (cv == NULL) return NULL; cv->cv_name = strdup(name); if (cv->cv_name == NULL) { kfree(cv); return NULL; } // Initialize cv fields cv->cv_wchan = wchan_create(cv->cv_name); spinlock_init(&cv->cv_splock); return cv; }
struct lock * lock_create(const char *name) { struct lock *lock; lock = kmalloc(sizeof(struct lock)); if (lock == NULL) { return NULL; } lock->lk_name = kstrdup(name); if (lock->lk_name == NULL) { kfree(lock); return NULL; } // add stuff here as needed //do i need to initialize hold? lock->lock_wchan = wchan_create(lock->lk_name); if(lock->lock_wchan == NULL){ kfree(lock->lk_name); kfree(lock); return NULL; } spinlock_init(&lock->splk); //lock->lock_hold = 0; //is this necessary lock->currentplace = NULL; return lock; }
struct lock * lock_create(const char *name) { struct lock *lock; lock = kmalloc(sizeof(struct lock)); if (lock == NULL) { return NULL; } lock->lk_name = kstrdup(name); if (lock->lk_name == NULL) { kfree(lock); return NULL; } #if OPT_A1 //Make wchan lock->lk_wchan = wchan_create(lock->lk_name); if (lock->lk_wchan == NULL) { kfree(lock->lk_name); kfree(lock); return NULL; } //Make spinlock spinlock_init(&lock->lock_lock); //Make thread lock->lock_holder = NULL; #endif /* OPT_A1 */ return lock; }
struct rwlock * rwlock_create(const char *name) { struct rwlock *rw; rw = kmalloc(sizeof(*rw)); if (rw == NULL) { return NULL; } rw->rwlock_name = kstrdup(name); if (rw->rwlock_name==NULL) { kfree(rw); return NULL; } rw->rwlock_read_wchan = wchan_create(rw->rwlock_name); if (rw->rwlock_read_wchan == NULL) { kfree(rw->rwlock_name); kfree(rw); return NULL; } rw->rwlock_write_wchan = wchan_create(rw->rwlock_name); if (rw->rwlock_write_wchan == NULL) { kfree(rw->rwlock_name); kfree(rw->rwlock_read_wchan); kfree(rw); return NULL; } /*rw->rwlock_cv_lock = cv_create(name); if (rw->rwlock_cv_lock == NULL) { kfree(rw->rwlock_cv_lock); kfree(rw->rwlock_read_wchan); kfree(rw->rwlock_write_wchan); kfree(rw); return NULL; }*/ // add null check /*rw->rwlock_read_lock = lock_create(name); if (rw->rwlock_read_lock == NULL) { kfree(rw->rwlock_cv_lock); kfree(rw->rwlock_read_wchan); kfree(rw->rwlock_write_wchan); kfree(rw->rwlock_read_lock); kfree(rw); return NULL; }*/ rw->rwlock_write_lock = lock_create(name); if (rw->rwlock_write_lock == NULL) { //kfree(rw->rwlock_cv_lock); kfree(rw->rwlock_read_wchan); kfree(rw->rwlock_write_wchan); //kfree(rw->rwlock_read_lock); //kfree(rw->rwlock_write_lock); kfree(rw); } spinlock_init(&rw->rwlock_spinlock); rw->rwlock_next_thread = NONE; rw->rwlock_readers_count = 0; rw->is_held_by_writer = false; //threadlist_init(&rw->readers_list); return rw; }
void coremap_bootstrap(void) { uint32_t i; paddr_t first, last; uint32_t npages, coremapsize; ram_getsize(&first, &last); /* The way ram.c works, these should be page-aligned */ KASSERT((first & PAGE_FRAME) == first); KASSERT((last & PAGE_FRAME) == last); npages = (last - first) / PAGE_SIZE; DEBUG(DB_VM, "coremap: first: 0x%x, last 0x%x: %u pages\n", first, last, npages); /* * The coremap contains one coremap_entry per page. Because * of the allocation constraints here, it must be rounded up * to a whole number of pages. * * Note that while we don't need space for coremap entries for * the coremap pages, and could save a few slots that way, the * operating regime of OS/161 is such that we're unlikely to * need more than one page for the coremap, and certainly not * more than two. So for simplicity (and robustness) we'll * avoid the relaxation computations necessary to optimize the * coremap size. */ coremapsize = npages * sizeof(struct coremap_entry); coremapsize = ROUNDUP(coremapsize, PAGE_SIZE); KASSERT((coremapsize & PAGE_FRAME) == coremapsize); /* * Steal pages for the coremap. */ coremap = (struct coremap_entry *) PADDR_TO_KVADDR(first); first += coremapsize; if (first >= last) { /* This cannot happen unless coremap_entry gets really huge */ panic("vm: coremap took up all of physical memory?\n"); } /* * Now, set things up to reflect the range of memory we're * managing. Note that we skip the pages the coremap is using. */ base_coremap_page = first / PAGE_SIZE; num_coremap_entries = (last / PAGE_SIZE) - base_coremap_page; num_coremap_kernel = 0; num_coremap_user = 0; num_coremap_free = num_coremap_entries; KASSERT(num_coremap_entries + (coremapsize/PAGE_SIZE) == npages); /* * Initialize the coremap entries. */ for (i=0; i < num_coremap_entries; i++) { coremap[i].cm_kernel = 0; coremap[i].cm_notlast = 0; coremap[i].cm_allocated = 0; coremap[i].cm_pinned = 0; coremap[i].cm_tlbix = -1; coremap[i].cm_cpunum = 0; coremap[i].cm_lpage = NULL; } coremap_pinchan = wchan_create("vmpin"); coremap_shootchan = wchan_create("tlbshoot"); if (coremap_pinchan == NULL || coremap_shootchan == NULL) { panic("Failed allocating coremap wchans\n"); } }