implement Fsmodule;include "sys.m";	sys: Sys;include "readdir.m";	readdir: Readdir;include "draw.m";include "sh.m";include "fslib.m";	fslib: Fslib;	Report, Value, type2s, report, quit: import fslib;	Fschan, Fsdata, Entrychan, Entry,	Gatechan, Gatequery, Nilentry, Option,	Next, Down, Skip, Quit: import Fslib; Loopcheck: adt {	a: array of list of ref Sys->Dir; 	new:		fn(): ref Loopcheck;	enter:	fn(l: self ref Loopcheck, d: ref Sys->Dir): int;	leave:	fn(l: self ref Loopcheck, d: ref Sys->Dir);}; types(): string{	return "xs-bs";} badmod(p: string){	sys->fprint(sys->fildes(2), "fs: walk: cannot load %s: %r\n", p);	raise "fail:bad module";} init(){	sys = load Sys Sys->PATH;	fslib = load Fslib Fslib->PATH;	if(fslib == nil)		badmod(Fslib->PATH);	readdir = load Readdir Readdir->PATH;	if(readdir == nil)		badmod(Readdir->PATH);} run(nil: ref Draw->Context, report: ref Report,			nil: list of Option, args: list of ref Value): ref Value{	path := (hd args).s().i;	(ok, d) := sys->stat(path);	if(ok== -1){		sys->fprint(sys->fildes(2), "fs: walk: cannot stat %q: %r\n", path);		return nil;	}	if((d.mode & Sys->DMDIR) == 0){		# XXX could produce an fs containing just the single file.		# would have to split the path though.		sys->fprint(sys->fildes(2), "fs: walk: %q is not a directory\n", path);		return nil;	}	sync := chan of int;	c := chan of (Fsdata, chan of int);	spawn fswalkproc(sync, path, c, Sys->ATOMICIO, report.start("walk"));	<-sync;	return ref Value.X(c);} # XXX need to avoid loops in the filesystem...fswalkproc(sync: chan of int, path: string, c: Fschan, blocksize: int, errorc: chan of string){	sys->pctl(Sys->FORKNS, nil);	sync <-= 1;	# XXX could allow a single root file?	if(sys->chdir(path) == -1){		report(errorc, sys->sprint("cannot cd to %q: %r", path));		fslib->sendnulldir(c);		quit(errorc);	}	(ok, d) := sys->stat(".");	if(ok == -1){		report(errorc, sys->sprint("cannot stat %q: %r", path));		fslib->sendnulldir(c);		quit(errorc);	}	d.name = path;	reply := chan of int;	c <-= ((ref d, nil), reply);	if(<-reply == Down){		loopcheck := Loopcheck.new();		loopcheck.enter(ref d);		if(path[len path - 1] != '/')			path[len path] = '/';		fswalkdir(path, c, blocksize, loopcheck, errorc);		c <-= ((nil, nil), reply);		<-reply;	}	quit(errorc);} fswalkdir(path: string, c: Fschan, blocksize: int, loopcheck: ref Loopcheck, errorc: chan of string){	reply := chan of int;	(a, n) := readdir->init(".", Readdir->NAME|Readdir->COMPACT);	if(n == -1){		report(errorc, sys->sprint("cannot readdir %q: %r", path));		return;	}	for(i := 0; i < n; i++)		if(a[i].mode & Sys->DMDIR)			if(loopcheck.enter(a[i]) == 0)				a[i].dtype = ~0;directory:	for(i = 0; i < n; i++){		if(a[i].mode & Sys->DMDIR){			d := a[i];			if(d.dtype == ~0){				report(errorc, sys->sprint("filesystem loop at %#q", path + d.name));				continue;			}			if(sys->chdir("./" + d.name) == -1){				report(errorc, sys->sprint("cannot cd to %#q: %r", path + a[i].name));				continue;			}			c <-= ((d, nil), reply);			case <-reply {			Quit =>				quit(errorc);			Down =>				fswalkdir(path + a[i].name + "/", c, blocksize, loopcheck, errorc);				c <-= ((nil, nil), reply);				if(<-reply == Quit)					quit(errorc);			Skip =>				sys->chdir("..");				i++;				break directory;			Next =>				break;			}			if(sys->chdir("..") == -1)		# XXX what should we do if this fails?				report(errorc, sys->sprint("failed to cd .. from %#q: %r\n", path + a[i].name));					} else {			if(fswalkfile(path, a[i], c, blocksize, errorc) == Skip)				break directory;		}	}	for(i = n - 1; i >= 0; i--)		if(a[i].mode & Sys->DMDIR && a[i].dtype != ~0)			loopcheck.leave(a[i]);} fswalkfile(path: string, d: ref Sys->Dir, c: Fschan, blocksize: int, errorc: chan of string): int{	reply := chan of int;	fd := sys->open(d.name, Sys->OREAD);	if(fd == nil){		report(errorc, sys->sprint("cannot open %q: %r", path+d.name));		return Next;	}	c <-= ((d, nil), reply);	case <-reply {	Quit =>		quit(errorc);	Skip =>		return Skip;	Next =>		return Next;	Down =>		break;	}	length := d.length;	for(n := big 0; n < length; ){		nr := blocksize;		if(n + big blocksize > length)			nr = int (length - n);		buf := array[nr] of byte;		nr = sys->read(fd, buf, nr);		if(nr <= 0){			if(nr < 0)				report(errorc, sys->sprint("error reading %q: %r", path + d.name));			else				report(errorc, sys->sprint("%q is shorter than expected (%bd/%bd)",						path + d.name, n, length));			break;		}else if(nr < len buf)			buf = buf[0:nr];		c <-= ((nil, buf), reply);		case <-reply {		Quit =>			quit(errorc);		Skip =>			return Next;		}		n += big nr;	}	c <-= ((nil, nil), reply);	if(<-reply == Quit)		quit(errorc);	return Next;} HASHSIZE: con 32; issamedir(d0, d1: ref Sys->Dir): int{	(q0, q1) := (d0.qid, d1.qid);	return q0.path == q1.path &&		q0.qtype == q1.qtype &&		d0.dtype == d1.dtype &&		d0.dev == d1.dev;} Loopcheck.new(): ref Loopcheck{	return ref Loopcheck(array[HASHSIZE] of list of ref Sys->Dir);} # XXX we're assuming no-one modifies the values in d behind our back...Loopcheck.enter(l: self ref Loopcheck, d: ref Sys->Dir): int{	slot := int d.qid.path & (HASHSIZE-1);	for(ll := l.a[slot]; ll != nil; ll = tl ll)		if(issamedir(d, hd ll))			return 0;	l.a[slot] = d :: l.a[slot];	return 1;} Loopcheck.leave(l: self ref Loopcheck, d: ref Sys->Dir){	slot := int d.qid.path & (HASHSIZE-1);	l.a[slot] = tl l.a[slot];}