plan 9 kernel history: overview | file list | diff list

1998/0313/ip/netlog.c (diff list | history)

1998/0307/sys/src/9/ip/netlog.c:6,151998/0313/sys/src/9/ip/netlog.c:6,11 (short | long | prev | next)
1997/0327    
#include	"../port/error.h" 
#include	"../ip/ip.h" 
 
int logmask;				/* mask of things to debug */ 
1998/0306    
uchar iponly[IPaddrlen];		/* ip address to print debugging for */ 
int iponlyset; 
1997/0327    
                 
enum { 
	Nlog		= 4*1024, 
}; 
1998/0307/sys/src/9/ip/netlog.c:17,231998/0313/sys/src/9/ip/netlog.c:13,19
1997/0327    
/* 
 *  action log 
 */ 
typedef struct Log { 
1998/0313    
struct Log { 
1997/0327    
	Lock; 
	int	opens; 
	char*	buf; 
1998/0307/sys/src/9/ip/netlog.c:25,391998/0313/sys/src/9/ip/netlog.c:21,39
1997/0327    
	char	*rptr; 
	int	len; 
 
1998/0313    
	int	logmask;			/* mask of things to debug */ 
	uchar	iponly[IPaddrlen];		/* ip address to print debugging for */ 
	int	iponlyset; 
 
1997/0327    
	QLock; 
	Rendez; 
} Log; 
static Log alog; 
1998/0313    
}; 
1997/0327    
 
typedef struct Logflag { 
	char*	name; 
	int	mask; 
} Logflag; 
1998/0313    
 
1997/0327    
static Logflag flags[] = 
{ 
	{ "ppp",	Logppp, }, 
1998/0307/sys/src/9/ip/netlog.c:55,1271998/0313/sys/src/9/ip/netlog.c:55,135
1997/0327    
static char Ebadnetctl[] = "unknown netlog ctl message"; 
 
void 
netlogopen(void) 
1998/0313    
netloginit(Fs *f) 
1997/0327    
{ 
	lock(&alog); 
1998/0313    
	f->alog = smalloc(sizeof(Log)); 
} 
 
void 
netlogopen(Fs *f) 
{ 
	lock(f->alog); 
1997/0327    
	if(waserror()){ 
		unlock(&alog); 
1998/0313    
		unlock(f->alog); 
1997/0327    
		nexterror(); 
	} 
	if(alog.opens == 0){ 
1998/0306    
		if(alog.buf == nil) 
1997/0327    
			alog.buf = malloc(Nlog); 
		alog.rptr = alog.buf; 
		alog.end = alog.buf + Nlog; 
1998/0313    
	if(f->alog->opens == 0){ 
		if(f->alog->buf == nil) 
			f->alog->buf = malloc(Nlog); 
		f->alog->rptr = f->alog->buf; 
		f->alog->end = f->alog->buf + Nlog; 
1997/0327    
	} 
	alog.opens++; 
	unlock(&alog); 
1998/0313    
	f->alog->opens++; 
	unlock(f->alog); 
1997/0327    
	poperror(); 
} 
 
void 
netlogclose(void) 
1998/0313    
netlogclose(Fs *f) 
1997/0327    
{ 
	lock(&alog); 
1998/0313    
	lock(f->alog); 
1997/0327    
	if(waserror()){ 
		unlock(&alog); 
1998/0313    
		unlock(f->alog); 
1997/0327    
		nexterror(); 
	} 
	alog.opens--; 
	if(alog.opens == 0){ 
		free(alog.buf); 
		alog.buf = nil; 
1998/0313    
	f->alog->opens--; 
	if(f->alog->opens == 0){ 
		free(f->alog->buf); 
		f->alog->buf = nil; 
1997/0327    
	} 
	unlock(&alog); 
1998/0313    
	unlock(f->alog); 
1997/0327    
	poperror(); 
} 
 
static int 
netlogready(void*) 
1998/0313    
netlogready(void *a) 
1997/0327    
{ 
	return alog.len; 
1998/0313    
	Fs *f = a; 
 
	return f->alog->len; 
1997/0327    
} 
 
long 
netlogread(void* a, ulong, long n) 
1998/0313    
netlogread(Fs *f, void *a, ulong, long n) 
1997/0327    
{ 
	int i, d; 
	char *p, *rptr; 
 
	qlock(&alog); 
1998/0313    
	qlock(f->alog); 
1997/0327    
	if(waserror()){ 
		qunlock(&alog); 
1998/0313    
		qunlock(f->alog); 
1997/0327    
		nexterror(); 
	} 
 
	for(;;){ 
		lock(&alog); 
		if(alog.len){ 
			if(n > alog.len) 
				n = alog.len; 
1998/0313    
		lock(f->alog); 
		if(f->alog->len){ 
			if(n > f->alog->len) 
				n = f->alog->len; 
1997/0327    
			d = 0; 
			rptr = alog.rptr; 
			alog.rptr += n; 
			if(alog.rptr >= alog.end){ 
				d = alog.rptr - alog.end; 
				alog.rptr = alog.buf + d; 
1998/0313    
			rptr = f->alog->rptr; 
			f->alog->rptr += n; 
			if(f->alog->rptr >= f->alog->end){ 
				d = f->alog->rptr - f->alog->end; 
				f->alog->rptr = f->alog->buf + d; 
1997/0327    
			} 
			alog.len -= n; 
			unlock(&alog); 
1998/0313    
			f->alog->len -= n; 
			unlock(f->alog); 
1997/0327    
 
			i = n; 
			p = a; 
1998/0307/sys/src/9/ip/netlog.c:129,1461998/0313/sys/src/9/ip/netlog.c:137,154
1997/0327    
				memmove(p, rptr, d); 
				i -= d; 
				p += d; 
				rptr = alog.buf; 
1998/0313    
				rptr = f->alog->buf; 
1997/0327    
			} 
			memmove(p, rptr, i); 
			break; 
		} 
		else 
			unlock(&alog); 
1998/0313    
			unlock(f->alog); 
1997/0327    
 
		sleep(&alog, netlogready, 0); 
1998/0313    
		sleep(f->alog, netlogready, 0); 
1997/0327    
	} 
 
	qunlock(&alog); 
1998/0313    
	qunlock(f->alog); 
1997/0327    
	poperror(); 
 
	return n; 
1998/0307/sys/src/9/ip/netlog.c:147,1561998/0313/sys/src/9/ip/netlog.c:155,164
1997/0327    
} 
 
char* 
netlogctl(char* s, int len) 
1998/0313    
netlogctl(Fs *f, char* s, int len) 
1997/0327    
{ 
	int i, n, set; 
	Logflag *f; 
1998/0313    
	Logflag *fp; 
1997/0423    
	char *fields[10], *p, buf[256]; 
1997/0327    
 
	if(len == 0) 
1998/0307/sys/src/9/ip/netlog.c:172,1821998/0313/sys/src/9/ip/netlog.c:180,190
1997/0327    
	else if(strcmp("clear", fields[0]) == 0) 
		set = 0; 
	else if(strcmp("only", fields[0]) == 0){ 
1998/0306    
		parseip(iponly, fields[1]); 
		if(ipcmp(iponly, IPnoaddr) == 0) 
			iponlyset = 0; 
1998/0313    
		parseip(f->alog->iponly, fields[1]); 
		if(ipcmp(f->alog->iponly, IPnoaddr) == 0) 
			f->alog->iponlyset = 0; 
1998/0306    
		else 
			iponlyset = 1; 
1998/0313    
			f->alog->iponlyset = 1; 
1997/0327    
		return nil; 
	} else 
		return Ebadnetctl; 
1998/0307/sys/src/9/ip/netlog.c:186,2001998/0313/sys/src/9/ip/netlog.c:194,208
1997/0327    
		*p = 0; 
 
	for(i = 1; i < n; i++){ 
		for(f = flags; f->name; f++) 
			if(strcmp(f->name, fields[i]) == 0) 
1998/0313    
		for(fp = flags; fp->name; fp++) 
			if(strcmp(fp->name, fields[i]) == 0) 
1997/0327    
				break; 
		if(f->name == nil) 
1998/0313    
		if(fp->name == nil) 
1997/0327    
			continue; 
		if(set) 
			logmask |= f->mask; 
1998/0313    
			f->alog->logmask |= fp->mask; 
1997/0327    
		else 
			logmask &= ~f->mask; 
1998/0313    
			f->alog->logmask &= ~fp->mask; 
1997/0327    
	} 
 
	return nil; 
1998/0307/sys/src/9/ip/netlog.c:201,2131998/0313/sys/src/9/ip/netlog.c:209,221
1997/0327    
} 
 
void 
netlog(int mask, char *fmt, ...) 
1998/0313    
netlog(Fs *f, int mask, char *fmt, ...) 
1997/0327    
{ 
	char buf[128], *t, *f; 
1998/0313    
	char buf[128], *t, *fp; 
1997/0327    
	int i, n; 
	va_list arg; 
 
1998/0306    
	if(!(logmask & mask)) 
1998/0313    
	if(!(f->alog->logmask & mask)) 
1997/0327    
		return; 
 
	va_start(arg, fmt); 
1998/0307/sys/src/9/ip/netlog.c:214,2411998/0313/sys/src/9/ip/netlog.c:222,247
1997/0327    
	n = doprint(buf, buf+sizeof(buf), fmt, arg) - buf; 
	va_end(arg); 
1998/0306    
 
print("%s", buf); 
1997/0327    
                 
	if(alog.opens == 0) 
1998/0313    
	if(f->alog->opens == 0) 
1997/0327    
		return; 
 
	lock(&alog); 
	i = alog.len + n - Nlog; 
1998/0313    
	lock(f->alog); 
	i = f->alog->len + n - Nlog; 
1997/0327    
	if(i > 0){ 
		alog.len -= i; 
		alog.rptr += i; 
		if(alog.rptr >= alog.end) 
			alog.rptr = alog.buf + (alog.rptr - alog.end); 
1998/0313    
		f->alog->len -= i; 
		f->alog->rptr += i; 
		if(f->alog->rptr >= f->alog->end) 
			f->alog->rptr = f->alog->buf + (f->alog->rptr - f->alog->end); 
1997/0327    
	} 
	t = alog.rptr + alog.len; 
	f = buf; 
	alog.len += n; 
1998/0313    
	t = f->alog->rptr + f->alog->len; 
	fp = buf; 
	f->alog->len += n; 
1997/0327    
	while(n-- > 0){ 
		if(t >= alog.end) 
			t = alog.buf + (t - alog.end); 
		*t++ = *f++; 
1998/0313    
		if(t >= f->alog->end) 
			t = f->alog->buf + (t - f->alog->end); 
		*t++ = *fp++; 
1997/0327    
	} 
	unlock(&alog); 
1998/0313    
	unlock(f->alog); 
1997/0327    
 
	wakeup(&alog); 
1998/0313    
	wakeup(f->alog); 
1997/0327    
} 


source code copyright © 1990-2005 Lucent Technologies; see license
Plan 9 distribution
comments to russ cox (rsc@swtch.com)