187 lines
2.9 KiB
C
187 lines
2.9 KiB
C
#include "u.h"
|
|
#include "../port/lib.h"
|
|
#include "mem.h"
|
|
#include "dat.h"
|
|
#include "fns.h"
|
|
#include "../port/error.h"
|
|
|
|
static char Ebadlogctl[] = "unknown log ctl message";
|
|
|
|
void
|
|
logopen(Log *alog)
|
|
{
|
|
lock(&alog->l);
|
|
if(waserror()){
|
|
unlock(&alog->l);
|
|
nexterror();
|
|
}
|
|
if(alog->opens == 0){
|
|
if(alog->nlog == 0)
|
|
alog->nlog = 4*1024;
|
|
if(alog->minread == 0)
|
|
alog->minread = 1;
|
|
if(alog->buf == nil)
|
|
alog->buf = smalloc(alog->nlog);
|
|
alog->rptr = alog->buf;
|
|
alog->end = alog->buf + alog->nlog;
|
|
alog->len = 0;
|
|
}
|
|
alog->opens++;
|
|
unlock(&alog->l);
|
|
poperror();
|
|
}
|
|
|
|
void
|
|
logclose(Log *alog)
|
|
{
|
|
lock(&alog->l);
|
|
alog->opens--;
|
|
if(alog->opens == 0){
|
|
jehanne_free(alog->buf);
|
|
alog->buf = nil;
|
|
}
|
|
unlock(&alog->l);
|
|
}
|
|
|
|
static int
|
|
logready(void *a)
|
|
{
|
|
Log *alog = a;
|
|
|
|
return alog->len >= alog->minread;
|
|
}
|
|
|
|
long
|
|
logread(Log *alog, void *a, uint32_t _1, long n)
|
|
{
|
|
int i, d;
|
|
char *p, *rptr;
|
|
|
|
qlock(&alog->readq);
|
|
if(waserror()){
|
|
qunlock(&alog->readq);
|
|
nexterror();
|
|
}
|
|
|
|
for(;;){
|
|
lock(&alog->l);
|
|
if(alog->len >= alog->minread || alog->len >= n){
|
|
if(n > alog->len)
|
|
n = alog->len;
|
|
d = 0;
|
|
rptr = alog->rptr;
|
|
alog->rptr += n;
|
|
if(alog->rptr >= alog->end){
|
|
d = alog->rptr - alog->end;
|
|
alog->rptr = alog->buf + d;
|
|
}
|
|
alog->len -= n;
|
|
unlock(&alog->l);
|
|
|
|
i = n-d;
|
|
p = a;
|
|
jehanne_memmove(p, rptr, i);
|
|
jehanne_memmove(p+i, alog->buf, d);
|
|
break;
|
|
}
|
|
else
|
|
unlock(&alog->l);
|
|
|
|
sleep(&alog->readr, logready, alog);
|
|
}
|
|
|
|
qunlock(&alog->readq);
|
|
poperror();
|
|
|
|
return n;
|
|
}
|
|
|
|
char*
|
|
logctl(Log *alog, int argc, char *argv[], Logflag *flags)
|
|
{
|
|
int i, set;
|
|
Logflag *fp;
|
|
|
|
if(argc < 2)
|
|
return Ebadlogctl;
|
|
|
|
if(jehanne_strcmp("set", argv[0]) == 0)
|
|
set = 1;
|
|
else if(jehanne_strcmp("clear", argv[0]) == 0)
|
|
set = 0;
|
|
else
|
|
return Ebadlogctl;
|
|
|
|
for(i = 1; i < argc; i++){
|
|
for(fp = flags; fp->name; fp++)
|
|
if(jehanne_strcmp(fp->name, argv[i]) == 0)
|
|
break;
|
|
if(fp->name == nil)
|
|
continue;
|
|
if(set)
|
|
alog->logmask |= fp->mask;
|
|
else
|
|
alog->logmask &= ~fp->mask;
|
|
}
|
|
|
|
return nil;
|
|
}
|
|
|
|
void
|
|
logn(Log *alog, int mask, void *buf, int n)
|
|
{
|
|
char *fp, *t;
|
|
int dowake, i;
|
|
|
|
if(!(alog->logmask & mask))
|
|
return;
|
|
|
|
if(alog->opens == 0)
|
|
return;
|
|
|
|
if(n > alog->nlog)
|
|
return;
|
|
|
|
lock(&alog->l);
|
|
i = alog->len + n - alog->nlog;
|
|
if(i > 0){
|
|
alog->len -= i;
|
|
alog->rptr += i;
|
|
if(alog->rptr >= alog->end)
|
|
alog->rptr = alog->buf + (alog->rptr - alog->end);
|
|
}
|
|
t = alog->rptr + alog->len;
|
|
fp = buf;
|
|
alog->len += n;
|
|
while(n-- > 0){
|
|
if(t >= alog->end)
|
|
t = alog->buf + (t - alog->end);
|
|
*t++ = *fp++;
|
|
}
|
|
dowake = alog->len >= alog->minread;
|
|
unlock(&alog->l);
|
|
|
|
if(dowake)
|
|
wakeup(&alog->readr);
|
|
}
|
|
|
|
void
|
|
log(Log *alog, int mask, char *fmt, ...)
|
|
{
|
|
int n;
|
|
va_list arg;
|
|
char buf[128];
|
|
|
|
if(!(alog->logmask & mask))
|
|
return;
|
|
|
|
if(alog->opens == 0)
|
|
return;
|
|
|
|
va_start(arg, fmt);
|
|
n = jehanne_vseprint(buf, buf+sizeof(buf), fmt, arg) - buf;
|
|
va_end(arg);
|
|
|
|
logn(alog, mask, buf, n);
|
|
}
|