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");
}
}
