xfnw/plan9fox
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

libc: avoid static table and supurious reads in nsec()

Browse source 
use two per process memory slots, one for the
pid and one for the fd instead of a global table
avoiding the case when the table gets full.

instead of calling pread() on the cached fd
(dangerous as it has side effects when the
fd was not closed), we check if the cached fd
is still good  using fd2path() when called
the first time in this process.
This commit is contained in:
cinap_lenrek 2014-05-23 18:56:20 +02:00
parent 440202d029
commit eef4565003
2 changed files with 34 additions and 84 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

80
sys/src/libc/9sys/nsec.c
View file

@ -16,60 +16,48 @@ be2vlong(vlong *to, uchar *f)
t[o[i]] = f[i];
}
static int fd = -1;
static struct {
int pid;
int fd;
} fds[64];
static int
stillopen(int fd, char *name)
{
char buf[64];
return fd >= 0 && fd2path(fd, buf, sizeof(buf)) == 0 && strcmp(buf, name) == 0;
}
vlong
nsec(void)
{
static char name[] = "/dev/bintime";
static int *pidp = nil, *fdp = nil, fd = -1;
uchar b[8];
vlong t;
int pid, i, f, tries;
int f;
/*
* Threaded programs may have multiple procs
* with different fd tables, so we may need to open
* /dev/bintime on a per-pid basis
*/
/* First, look if we've opened it for this particular pid */
pid = _tos->pid;
do{
f = -1;
for(i = 0; i < nelem(fds); i++)
if(fds[i].pid == pid){
f = fds[i].fd;
break;
}
tries = 0;
if(f < 0){
/* If it's not open for this pid, try the global pid */
if(fd >= 0)
f = fd;
else{
/* must open */
if((f = open("/dev/bintime", OREAD|OCEXEC)) < 0)
return 0;
fd = f;
for(i = 0; i < nelem(fds); i++)
if(fds[i].pid == pid || fds[i].pid == 0){
fds[i].pid = pid;
fds[i].fd = f;
break;
}
}
if(pidp != nil && *pidp == _tos->pid)
f = *fdp;
else{
Reopen:
f = fd;
if(fdp != nil && *fdp != f && stillopen(*fdp, name))
f = *fdp;
else if(!stillopen(f, name)){
if((f = open(name, OREAD|OCEXEC)) < 0)
return 0;
}
if(pread(f, b, sizeof b, 0) == sizeof b){
be2vlong(&t, b);
return t;
fd = f;
if(fdp == nil){
fdp = (int*)privalloc();
pidp = (int*)privalloc();
}
*fdp = f;
*pidp = _tos->pid;
}
if(pread(f, b, sizeof b, 0) != sizeof b){
if(!stillopen(f, name))
goto Reopen;
close(f);
if(i < nelem(fds))
fds[i].fd = -1;
}while(tries++ == 0); /* retry once */
USED(tries);
return 0;
return 0;
}
be2vlong(&t, b);
return t;
}

38
sys/src/libc/9sys/time.c
View file

@ -1,50 +1,12 @@
#include <u.h>
#include <libc.h>
/*
* After a fork with fd's copied, both fd's are pointing to
* the same Chan structure. Since the offset is kept in the Chan
* structure, the seek's and read's in the two processes can
* compete at moving the offset around. Hence the unusual loop
* in the middle of this routine.
*/
static long
oldtime(long *tp)
{
char b[20];
static int f = -1;
int i, retries;
long t;
memset(b, 0, sizeof(b));
for(retries = 0; retries < 100; retries++){
if(f < 0)
f = open("/dev/time", OREAD|OCEXEC);
if(f < 0)
break;
if(seek(f, 0, 0) < 0 || (i = read(f, b, sizeof(b))) < 0){
close(f);
f = -1;
} else {
if(i != 0)
break;
}
}
t = atol(b);
if(tp)
*tp = t;
return t;
}
long
time(long *tp)
{
vlong t;
t = nsec()/1000000000LL;
if(t == 0)
t = oldtime(0);
if(tp != nil)
*tp = t;
return t;