自学教程：C++ wunlock函数代码示例

/* *  associate an address with the interface.  This wipes out any previous *  addresses.  This is a macro that means, remove all the old interfaces *  and add a new one. */static char*ipifcconnect(Conv* c, char **argv, int argc){	Proc *up = externup();	char *err;	Ipifc *ifc;	ifc = (Ipifc*)c->ptcl;	if(ifc->medium == nil)		 return "ipifc not yet bound to device";	if(waserror()){		wunlock(ifc);		nexterror();	}	wlock(ifc);	while(ifc->lifc){		err = ipifcremlifc(ifc, ifc->lifc);		if(err)			error(err);	}	wunlock(ifc);	poperror();	err = ipifcadd(ifc, argv, argc, 0, nil);	if(err)		return err;	Fsconnected(c, nil);	return nil;}

voidclosepgrp(Pgrp *p){	Mhead **h, **e, *f, *next;	if(decref(&p->ref) != 0)		return;	qlock(&p->debug);	wlock(&p->ns);	p->pgrpid = -1;	e = &p->mnthash[MNTHASH];	for(h = p->mnthash; h < e; h++) {		for(f = *h; f; f = next) {			wlock(&f->lock);			cclose(f->from);			mountfree(f->mount);			f->mount = nil;			next = f->hash;			wunlock(&f->lock);			putmhead(f);		}	}	wunlock(&p->ns);	qunlock(&p->debug);	free(p);}

/* *  associate an address with the interface.  This wipes out any previous *  addresses.  This is a macro that means, remove all the old interfaces *  and add a new one. */static char *ipifcconnect(struct conv *c, char **argv, int argc){	ERRSTACK(1);	char *err;	struct Ipifc *ifc;	ifc = (struct Ipifc *)c->ptcl;	if (ifc->m == NULL)		return "ipifc not yet bound to device";	if (waserror()) {		wunlock(&ifc->rwlock);		nexterror();	}	wlock(&ifc->rwlock);	while (ifc->lifc) {		err = ipifcremlifc(ifc, ifc->lifc);		if (err)			error(err);	}	wunlock(&ifc->rwlock);	poperror();	err = ipifcadd(ifc, argv, argc, 0, NULL);	if (err)		return err;	Fsconnected(c, NULL);	return NULL;}

static Devlogfs *devlogfssetdefname(char *name){	Devlogfs *l;	char *searchname;	wlock(&devlogfslist.rwlock);	if (waserror()) {		wunlock(&devlogfslist.rwlock);		nexterror();	}	if (name == nil)		searchname = devlogfslist.defname;	else		searchname = name;	for (l = devlogfslist.head; l; l = l->next)		if (strcmp(l->name, searchname) == 0)			break;	if (l == nil) {		logfsfreemem(devlogfslist.defname);		devlogfslist.defname = nil;	}	else if (name) {		if (devlogfslist.defname) {			logfsfreemem(devlogfslist.defname);			devlogfslist.defname = nil;		}		devlogfslist.defname = estrdup(name);	}	poperror();	wunlock(&devlogfslist.rwlock);	return l;}

// ---tERROR pr_call _MemoryRealloc( tPO* po, tHANDLE* handle, tDWORD size ) {  tOBJECT* obj;  tERROR   error;  PR_TRACE_A0( MakeObject(handle), "Enter _MemoryRealloc" );  if ( handle->obj == NULL ) {  // alloc new memory		error = PrAlloc( (tPTR*)&obj, sizeof(tOBJECT) + size );    if ( PR_SUCC(error) ) {      wlock(po);      handle->obj = obj;      _ObjectInit0( handle );      wunlock(po);    }  }  else {    wlock(po);    if ( PR_SUCC(error=PrRealloc((tPTR*)&handle->obj,handle->obj,sizeof(tOBJECT)+size)) ) {      *odata(handle->obj) = handle->obj + 1;    }    wunlock(po);  }  PR_TRACE_A1( MakeObject(handle), "Leave _MemoryRealloc ret %terr", error );  return error;}

static voidgencurrent(Wcache *w, Qid *q, char *file, char *lock, uint32_t *t,	   Whist **wp, int n){	Dir *d;	Whist *wh;	if(*wp && *t+Tcache >= time(0))		return;	wlock(w);	if(*wp && *t+Tcache >= time(0)){		wunlock(w);		return;	}	if(((d = wdirstat(file)) == nil) || (d->qid.path==q->path && d->qid.vers==q->vers)){		*t = time(0);		wunlock(w);		free(d);		return;	}	free(d);	if(wh = readwhist(file, lock, q)){		wh->n = n;		*t = time(0);		closewhist(*wp);		*wp = wh;	}else fprint(2, "error file=%s lock=%s %r/n", file, lock);	wunlock(w);}

static Chan*consopen(Chan *c, int omode){	c->aux = 0;	switch((ulong)c->qid.path){	case Qconsctl:		if(!iseve())			error(Eperm);		qlock(&kbd);		kbd.ctl++;		qunlock(&kbd);		break;	case Qkeyboard:		if((omode & 3) != OWRITE) {			qlock(&kbd);			kbd.kbdr++;			flushkbdline(kbdq);			kbd.raw = 1;			qunlock(&kbd);		}		break;	case Qscancode:		qlock(&kbd);		if(kscanq || !kscanid) {			qunlock(&kbd);			c->flag &= ~COPEN;			if(kscanq)				error(Einuse);			else				error(Ebadarg);		}		kscanq = qopen(256, 0, nil, nil);		qunlock(&kbd);		break;	case Qkprint:		if((omode & 3) != OWRITE) {			wlock(&kprintq);			if(kprintq.q != nil){				wunlock(&kprintq);				error(Einuse);			}			kprintq.q = qopen(32*1024, Qcoalesce, nil, nil);			if(kprintq.q == nil){				wunlock(&kprintq);				error(Enomem);			}			qnoblock(kprintq.q, 1);			wunlock(&kprintq);			c->iounit = qiomaxatomic;		}		break;	}	return devopen(c, omode, consdir, nelem(consdir), devgen);}

voiddevream(Device *d, int top){	Device *l;loop:	print("/tdevream: %Z %d/n", d, top);	switch(d->type) {	default:		print("ream: unknown dev type %Z/n", d);		return;	case Devcw:		devream(d->cw.w, 0);		devream(d->cw.c, 0);		if(top) {			wlock(&mainlock);			cwream(d);			wunlock(&mainlock);		}		devinit(d);		return;	case Devfworm:		devream(d->fw.fw, 0);		fwormream(d);		break;	case Devpart:		devream(d->part.d, 0);		break;	case Devmlev:	case Devmcat:	case Devmirr:		for(l=d->cat.first; l; l=l->link)			devream(l, 0);		break;	case Devjuke:	case Devworm:	case Devlworm:	case Devwren:		break;	case Devswab:		d = d->swab.d;		goto loop;	}	devinit(d);	if(top) {		wlock(&mainlock);		rootream(d, ROOT_ADDR);		superream(d, SUPER_ADDR);		wunlock(&mainlock);	}}

Chan*consopen(Chan *c, int omode){	c = devopen(c, omode, contab, nelem(contab), devgen);	switch((ulong)c->qid.path) {	case Qconsctl:		incref(&kbd.ctl);		break;	case Qpointer:		if(incref(&kbd.ptr) != 1){			decref(&kbd.ptr);			c->flag &= ~COPEN;			error(Einuse);		}		break;	case Qscancode:		qlock(&kbd.gq);		if(gkscanq || !gkscanid) {			qunlock(&kbd.q);			c->flag &= ~COPEN;			if(gkscanq)				error(Einuse);			else				error(Ebadarg);		}		gkscanq = qopen(256, 0, nil, nil);		qunlock(&kbd.gq);		break;	case Qkprint:		wlock(&kprintq.l);		if(kprintq.q != nil){			wunlock(&kprintq.l);			c->flag &= ~COPEN;			error(Einuse);		}		kprintq.q = qopen(32*1024, 0, 0, 0);		if(kprintq.q == nil){			wunlock(&kprintq.l);			c->flag &= ~COPEN;			error(Enomem);		}		qnoblock(kprintq.q, 1);		wunlock(&kprintq.l);		break;	case Qsnarf:		if(omode == ORDWR)			error(Eperm);		if(omode == OREAD)			c->aux = strdup("");		else			c->aux = mallocz(SnarfSize, 1);		break;	}	return c;}

static Chan*envcreate(Chan *c, char *name, int omode, ulong){	Egrp *eg;	Evalue *e;	Evalue **ent;	if(c->qid.type != QTDIR || !envwriteable(c))		error(Eperm);	if(strlen(name) >= sizeof(up->genbuf))		error(Etoolong);	omode = openmode(omode);	eg = envgrp(c);	wlock(eg);	if(waserror()) {		wunlock(eg);		nexterror();	}	if(envlookup(eg, name, -1) != nil)		error(Eexist);	e = smalloc(sizeof(Evalue));	e->name = smalloc(strlen(name)+1);	strcpy(e->name, name);	if(eg->nent == eg->ment){		eg->ment += 32;		ent = smalloc(sizeof(eg->ent[0])*eg->ment);		if(eg->nent)			memmove(ent, eg->ent, sizeof(eg->ent[0])*eg->nent);		free(eg->ent);		eg->ent = ent;	}	e->qid.path = ++eg->path;	e->qid.vers = 0;	eg->vers++;	eg->ent[eg->nent++] = e;	c->qid = e->qid;	wunlock(eg);	poperror();	c->offset = 0;	c->mode = omode;	c->flag |= COPEN;	return c;}

static Chan*envcreate(Chan *c, char *name, int omode, ulong){	Egrp *eg;	Evalue *e;	if(c->qid.type != QTDIR || !envwriteable(c))		error(Eperm);	if(strlen(name) >= sizeof(up->genbuf))		error(Etoolong);	omode = openmode(omode);	eg = envgrp(c);	wlock(eg);	if(waserror()) {		wunlock(eg);		nexterror();	}	if(envlookup(eg, name, -1) != nil)		error(Eexist);	if(eg->nent == eg->ment){		Evalue *tmp;		eg->ment += DELTAENV;		if((tmp = realloc(eg->ent, sizeof(eg->ent[0])*eg->ment)) == nil){			eg->ment -= DELTAENV;			error(Enomem);		}		eg->ent = tmp;	}	eg->vers++;	e = &eg->ent[eg->nent++];	e->value = nil;	e->len = 0;	e->name = smalloc(strlen(name)+1);	strcpy(e->name, name);	mkqid(&e->qid, ++eg->path, 0, QTFILE);	c->qid = e->qid;	wunlock(eg);	poperror();	c->offset = 0;	c->mode = omode;	c->flag |= COPEN;	return c;}

static voidenvcreate(Chan *c, char *name, int omode, int i){	Proc *up = externup();	Egrp *eg;	Evalue *e;	Evalue **ent;	if(c->qid.type != QTDIR)		error(Eperm);	omode = openmode(omode);	eg = envgrp(c);	wlock(&eg->rwl);	if(waserror()) {		wunlock(&eg->rwl);		nexterror();	}	if(envlookup(eg, name, -1))		error(Eexist);	e = smalloc(sizeof(Evalue));	e->name = smalloc(strlen(name)+1);	strcpy(e->name, name);	if(eg->nent == eg->ment){		eg->ment += 32;		ent = smalloc(sizeof(eg->ent[0])*eg->ment);		if(eg->nent)			memmove(ent, eg->ent, sizeof(eg->ent[0])*eg->nent);		free(eg->ent);		eg->ent = ent;	}	e->qid.path = ++eg->path;	e->qid.vers = 0;	eg->vers++;	eg->ent[eg->nent++] = e;	c->qid = e->qid;	wunlock(&eg->rwl);	poperror();	c->offset = 0;	c->mode = omode;	c->flag |= COPEN;}

const char *GetLastErrorMsg(void){	static unsigned int lock = 0;	wlock(&lock);    static TCHAR szBuf[256];     LPVOID lpMsgBuf;    DWORD dw = GetLastError();     FormatMessage(        FORMAT_MESSAGE_ALLOCATE_BUFFER |         FORMAT_MESSAGE_FROM_SYSTEM,        NULL,        dw,        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),        (LPTSTR) &lpMsgBuf,        0, NULL );	char *p;	while ( (p=strchr((char*)lpMsgBuf,'/n'))!=NULL ) *p=' ';	while ( (p=strchr((char*)lpMsgBuf,'/r'))!=NULL ) *p=' ';    sprintf(szBuf, "%s (error code %d)", lpMsgBuf, dw);      LocalFree(lpMsgBuf);	wunlock(&lock);	return szBuf;}

/* * allocate 'count' contiguous channels * of type 'type' and return pointer to base */Chan*fs_chaninit(int type, int count, int data){	uint8_t *p;	Chan *cp, *icp;	int i;	p = malloc(count * (sizeof(Chan)+data));	icp = (Chan*)p;	for(i = 0; i < count; i++) {		cp = (Chan*)p;		cp->next = chans;		chans = cp;		cp->type = type;		cp->chan = cons.chano;		cons.chano++;		strncpy(cp->whoname, "<none>", sizeof cp->whoname);		wlock(&cp->reflock);		wunlock(&cp->reflock);		rlock(&cp->reflock);		runlock(&cp->reflock);		p += sizeof(Chan);		if(data){			cp->pdata = p;			p += data;		}	}	return icp;}

static voidenvremove(Chan *c){	int i;	Egrp *eg;	Evalue *e;	if(c->qid.type & QTDIR)		error(Eperm);	eg = envgrp(c);	wlock(&eg->rwl);	e = 0;	for(i=0; i<eg->nent; i++){		if(eg->ent[i]->qid.path == c->qid.path){			e = eg->ent[i];			eg->nent--;			eg->ent[i] = eg->ent[eg->nent];			eg->vers++;			break;		}	}	wunlock(&eg->rwl);	if(e == 0)		error(Enonexist);	free(e->name);	if(e->value)		free(e->value);	free(e);}

voidconsclose(Chan *c){	if((c->flag & COPEN) == 0)		return;	switch((ulong)c->qid.path) {	case Qconsctl:		if(decref(&kbd.ctl) == 0)			kbd.raw = 0;		break;	case Qpointer:		decref(&kbd.ptr);		break;	case Qscancode:		qlock(&kbd.gq);		if(gkscanq) {			qfree(gkscanq);			gkscanq = 0;		}		qunlock(&kbd.gq);		break;	case Qkprint:		wlock(&kprintq.l);		qfree(kprintq.q);		kprintq.q = nil;		wunlock(&kprintq.l);		break;	case Qsnarf:		if(c->mode == OWRITE)			clipwrite(c->aux, strlen(c->aux));		free(c->aux);		break;	}}

voidcmd_start(void){	superok(cur_fs->dev, superaddr(cur_fs->dev), 0);	wunlock(&mainlock);	print("kfs: file system started/n");}

static voidconsclose(Chan *c){	if((c->flag & COPEN) == 0)		return;	switch((ulong)c->qid.path) {	case Qconsctl:		/* last close of control file turns off raw */		if(decref(&kbd.ctl) == 0)			kbd.raw = 0;		break;	case Qscancode:		qlock(&kbd.gq);		if(gkscanq) {			qfree(gkscanq);			gkscanq = nil;		}		qunlock(&kbd.gq);		break;	case Qkprint:		wlock(&kprintq.l);		qfree(kprintq.q);		kprintq.q = nil;		wunlock(&kprintq.l);		break;	}}

static voidsysbrk(void){	ulong v;	Segment *s;		v = arg(0);	if(systrace)		fprint(2, "brk(%#lux)/n", v);	if(v >= P->S[SEGSTACK]->start)		sysfatal("bss > stack, wtf?");	if(v < P->S[SEGBSS]->start)		sysfatal("bss length < 0, wtf?");	s = P->S[SEGBSS];	wlock(&s->rw);	s->dref = realloc(s->dref, v - s->start + sizeof(Ref));	if(s->dref == nil)		sysfatal("error reallocating");	s->data = s->dref + 1;	if(s->size < v - s->start)		memset((char*)s->data + s->size, 0, v - s->start - s->size);	s->size = v - s->start;	P->R[0] = 0;	wunlock(&s->rw);}

static Chan*consopen(Chan *c, int omode){	c = devopen(c, omode, contab, nelem(contab), devgen);	switch((ulong)c->qid.path) {	case Qconsctl:		incref(&kbd.ctl);		break;	case Qscancode:		qlock(&kbd.gq);		if(gkscanq != nil || gkscanid == nil) {			qunlock(&kbd.q);			c->flag &= ~COPEN;			if(gkscanq)				error(Einuse);			else				error("not supported");		}		gkscanq = qopen(256, 0, nil, nil);		qunlock(&kbd.gq);		break;	case Qkprint:		wlock(&kprintq.l);		if(waserror()){			wunlock(&kprintq.l);			c->flag &= ~COPEN;			nexterror();		}		if(kprintq.q != nil)			error(Einuse);		kprintq.q = qopen(32*1024, Qcoalesce, nil, nil);		if(kprintq.q == nil)			error(Enomem);		qnoblock(kprintq.q, 1);		poperror();		wunlock(&kprintq.l);		c->iounit = qiomaxatomic;		break;	case Qevents:		c->aux = qopen(512, 0, nil, nil);		add_listener(&event_listeners, c->aux);		break;	}	return c;}

static int report_close(void){	wlock(&report_lock);	if ( report_fp ) fclose(report_fp);	report_fp = NULL;	wunlock(&report_lock);	return report_rows;}

/* *  detach a device from an interface, close the interface *  called with ifc->conv closed */static char*ipifcunbind(Ipifc *ifc){	Proc *up = externup();	char *err;	if(waserror()){		wunlock(ifc);		nexterror();	}	wlock(ifc);	/* dissociate routes */	if(ifc->medium != nil && ifc->medium->unbindonclose == 0)		ifc->conv->inuse--;	ifc->ifcid++;	/* disassociate logical interfaces (before zeroing ifc->arg) */	while(ifc->lifc){		err = ipifcremlifc(ifc, ifc->lifc);		/*		 * note: err non-zero means lifc not found,		 * which can't happen in this case.		 */		if(err)			error(err);	}	/* disassociate device */	if(ifc->medium && ifc->medium->unbind)		(*ifc->medium->unbind)(ifc);	memset(ifc->dev, 0, sizeof(ifc->dev));	ifc->arg = nil;	ifc->reassemble = 0;	/* close queues to stop queuing of packets */	qclose(ifc->conv->rq);	qclose(ifc->conv->wq);	qclose(ifc->conv->sq);	ifc->medium = nil;	wunlock(ifc);	poperror();	return nil;}

static Chan*envopen(Chan *c, int omode){	Egrp *eg;	Evalue *e;	int trunc;	eg = envgrp(c);	if(c->qid.type & QTDIR) {		if(omode != OREAD)			error(Eperm);	}	else {		trunc = omode & OTRUNC;		if(omode != OREAD && !envwriteable(c))			error(Eperm);		if(trunc)			wlock(&eg->rwl);		else			rlock(&eg->rwl);		e = envlookup(eg, nil, c->qid.path);		if(e == 0) {			if(trunc)				wunlock(&eg->rwl);			else				runlock(&eg->rwl);			error(Enonexist);		}		if(trunc && e->value) {			e->qid.vers++;			free(e->value);			e->value = 0;			e->len = 0;		}		if(trunc)			wunlock(&eg->rwl);		else			runlock(&eg->rwl);	}	c->mode = openmode(omode);	c->flag |= COPEN;	c->offset = 0;	return c;}

voidclosedirfile(Readdir *r){	if(decref(&r->dir->readers) == 0){		wlock(&r->dir->RWLock);		cleanfilelist(r->dir);		wunlock(&r->dir->RWLock);	}	free(r);}

static voiddochaninit(Chan *cp, int fd){	cp->chan = fd;	fileinit(cp);	wlock(&cp->reflock);	wunlock(&cp->reflock);	lock(&cp->flock);	unlock(&cp->flock);}

static longenvwrite(Chan *c, void *a, long n, vlong off){	char *s;	ulong len;	Egrp *eg;	Evalue *e;	ulong offset = off;	if(n <= 0)		return 0;	if(offset > Maxenvsize || n > (Maxenvsize - offset))		error(Etoobig);	eg = envgrp(c);	wlock(eg);	if(waserror()){		wunlock(eg);		nexterror();	}	e = envlookup(eg, nil, c->qid.path);	if(e == nil)		error(Enonexist);	len = offset+n;	if(len > e->len) {		s = realloc(e->value, len);		if(s == nil)			error(Enomem);		memset(s+offset, 0, n);		e->value = s;		e->len = len;	}	memmove(e->value+offset, a, n);	e->qid.vers++;	eg->vers++;	wunlock(eg);	poperror();	return n;}

/* *  remove a multicast address from an interface, called with c locked */void ipifcremmulti(struct conv *c, uint8_t * ma, uint8_t * ia){	ERRSTACK(1);	struct Ipmulti *multi, **l;	struct Iplifc *lifc;	struct conv **p;	struct Ipifc *ifc;	struct Fs *f;	f = c->p->f;	for (l = &c->multi; *l; l = &(*l)->next)		if (ipcmp(ma, (*l)->ma) == 0)			if (ipcmp(ia, (*l)->ia) == 0)				break;	multi = *l;	if (multi == NULL)		return;	/* we don't have it open */	*l = multi->next;	for (p = f->ipifc->conv; *p; p++) {		if ((*p)->inuse == 0)			continue;		ifc = (struct Ipifc *)(*p)->ptcl;		if (waserror()) {			wunlock(&ifc->rwlock);			nexterror();		}		wlock(&ifc->rwlock);		for (lifc = ifc->lifc; lifc; lifc = lifc->next)			if (ipcmp(ia, lifc->local) == 0)				remselfcache(f, ifc, lifc, ma);		wunlock(&ifc->rwlock);		poperror();	}	kfree(multi);}

/* *  remove a multicast address from an interface, called with c->car locked */voidipifcremmulti(Conv *c, uint8_t *ma, uint8_t *ia){	Proc *up = externup();	Ipmulti *multi, **l;	Iplifc *lifc;	Conv **p;	Ipifc *ifc;	Fs *f;	f = c->p->f;	for(l = &c->multi; *l; l = &(*l)->next)		if(ipcmp(ma, (*l)->ma) == 0 && ipcmp(ia, (*l)->ia) == 0)			break;	multi = *l;	if(multi == nil)		return; 	/* we don't have it open */	*l = multi->next;	for(p = f->ipifc->conv; *p; p++){		if((*p)->inuse == 0)			continue;		ifc = (Ipifc*)(*p)->ptcl;		if(waserror()){			wunlock(ifc);			nexterror();		}		wlock(ifc);		for(lifc = ifc->lifc; lifc; lifc = lifc->next)			if(ipcmp(ia, lifc->local) == 0)				remselfcache(f, ifc, lifc, ma);		wunlock(ifc);		poperror();	}	free(multi);}