[openbsd_emul.git] / linux_emul_base / fs.c

#include <u.h>
#include <libc.h>
#include <ureg.h>
#include "dat.h"
#include "fns.h"
#include "linux.h"

typedef struct Mount Mount;

struct Mount
{
	Mount	*next;
	Udev		*dev;
	int		npath;
	char		path[];
};

static Mount *mtab;

void
fsmount(Udev *dev, char *path)
{
	Mount *m, **p;
	int n;

	if(dev == nil)
		return;

	n = strlen(path);
	m = kmalloc(sizeof(*m) + n + 1);
	m->dev = dev;
	m->next = nil;
	m->npath = n;
	strcpy(m->path, path);

	for(p=&mtab;;p=&((*p)->next)){
		Mount *x;

		if(x = *p){
			if(m->npath < x->npath)
				continue;
			if(m->npath == x->npath){
				if(strcmp(m->path, x->path) < 0)
					continue;
			}
		}
		m->next = *p;
		*p = m;
		break;
	}
}

ulong
hashpath(char *s)
{
	ulong h;
	for(h=0; *s; s++)
		h = (h * 13) + (*s - 'a');
	return h;
}

char*
basepath(char *p, char **ps)
{
	char *x, *s;
	int n;

	if(s = strrchr(p, '/')){
		if(s[1] != 0){
			if(ps)
				*ps = kstrdup(s+1);
			if((n = s - p) == 0)
				n = 1;
			x = kmalloc(n+1);
			memmove(x, p, n);
			x[n] = 0;
			return x;
		}
	}
	if(ps)
		*ps = nil;
	return nil;
}

char*
allocpath(char *base, char *prefix, char *name)
{
	char *p, *s;
	int n, m, k;

	n = strlen(base);
	m = strlen(name);
	k = prefix ? strlen(prefix) : 0;
	p = s = kmalloc(n+m+k+2);
	memmove(p, base, n);
	p += n;
	if(m || k)
		*p++ = '/';
	if(k){
		memmove(p, prefix, k);
		p += k;
	}
	memmove(p, name, m+1);
	return s;
}

char*
fullpath(char *base, char *name)
{
	char *s;

	if(*name == '/' || *name == '#'){
		s = kstrdup(name);
	} else if(base) {
		s = allocpath(base, nil, name);
	} else {
		s = nil;
	}
	if(s != nil)
		cleanname(s);
	return s;
}

char*
shortpath(char *base, char *path)
{
	int n;

	n = strlen(base);
	if((n <= strlen(path)) && (strncmp(path, base, n)==0)){
		path += n;
		if(*path == '/')
			path++;
		if(*path == 0)
			path = ".";
	}
	return path;
}

char*
fsfullpath(char *path)
{
	char *root;

	path = fullpath(current->cwd, path);
	if(path && (root = current->root)){
		root = allocpath(root, nil, path+1);
		free(path);
		path = root;
	}
	return path;
}

char*
fsrootpath(char *path)
{
	char *root;

	if(root = current->root){
		root = shortpath(root, path);
		if(*root == '.'){
			path = "/";
		} else if(root > path){
			path = root-1;
		}
	}
	return path;
}

static Mount*
path2mount(char *path)
{
	Mount *m;

	for(m=mtab; m; m=m->next){
		if(strncmp(path, m->path, m->npath) == 0){
			switch(path[m->npath]){
			case '\0':
			case '/':
				return m;
			}
		}
	}
	return nil;
}

static Udev*
path2dev(char *path)
{
	Mount *m;

	if(m = path2mount(path))
		return m->dev;
	return nil;
}

static int
fsenter(int *perr)
{
	int err;

	if(perr == nil)
		perr = &err;
	if(current->linkloop > 8)
		return *perr = -ELOOP;
	current->linkloop++;
	return 0;
}

static void
fsleave(void)
{
	current->linkloop--;
}

int sys_getcwd(char *buf, int len)
{
	int n;
	char *cwd;

	trace("sys_getcwd(%p, %x)", buf, len);

	cwd = current->cwd;
	n = strlen(cwd)+1;
	if(n > len)
		return -ERANGE;
	memmove(buf, cwd, n);
	return n;
}

int
fsopen(char *path, int mode, int perm, Ufile **pf)
{
	int err;
	Udev *dev;

	trace("fsopen(%s, %#o, %#o)", path, mode, perm);

	*pf = nil;
	if(fsenter(&err) < 0)
		return err;
	err = -ENOENT;
	if((dev = path2dev(path)) && dev->open)
		err = dev->open(path, mode, perm, pf);
	fsleave();
	return err;
}

int
fsaccess(char *path, int mode)
{
	int err;
	Udev *dev;

	trace("fsaccess(%s, %#o)", path, mode);

	if(fsenter(&err) < 0)
		return err;
	err = -ENOENT;
	if(dev = path2dev(path)){
		err = 0;
		if(dev->access)
			err = dev->access(path, mode);
	}
	fsleave();

	return err;
}

int sys_access(char *name, int mode)
{
	int err;

	trace("sys_access(%s, %#o)", name, mode);

	if((name = fsfullpath(name)) == nil)
		return -EFAULT;
	err = fsaccess(name, mode);
	free(name);

	return err;
}

int sys_open(char *name, int mode, int perm)
{
	int err;
	Ufile *file;

	trace("sys_open(%s, %#o, %#o)", name, mode, perm);

	if((name = fsfullpath(name)) == nil)
		return -EFAULT;
	err = fsopen(name, mode, perm, &file);
	free(name);

	if(err == 0)
		err = newfd(file, FD_CLOEXEC);

	return err;
}

int sys_creat(char *name, int perm)
{
	trace("sys_create(%s, %#o)", name, perm);

	return sys_open(name, O_CREAT|O_TRUNC, perm);
}

int
fsstat(char *path, int link, Ustat *ps)
{
	int err;
	Udev *dev;

	trace("fsstat(%s, %d)", path, link);

	if(fsenter(&err) < 0)
		return err;
	err = -EPERM;
	if((dev = path2dev(path)) && dev->stat){
		memset(ps, 0, sizeof(Ustat));
		err = dev->stat(path, link, ps);
	}
	fsleave();
	return err;
}

int
sys_chdir(char *name)
{
	int err;
	Ufile *f;

	trace("sys_chdir(%s)", name);

	if((name = fsfullpath(name)) == nil)
		return -EFAULT;
	err = fsopen(name, O_RDONLY, 0, &f);
	free(name);
	if(err == 0){
		err = chdirfile(f);
		putfile(f);
	}
	return err;
}

int sys_chroot(char *name)
{
	Ufile *f;
	Ustat s;
	int err;

	trace("sys_chroot(%s)", name);

	f = nil;
	if((err = fsopen(name, O_RDONLY, 0, &f)) < 0)
		goto out;
	err = -ENOTDIR;
	if(f->path == nil)
		goto out;
	if(devtab[f->dev]->fstat == nil)
		goto out;
	if((err = devtab[f->dev]->fstat(f, &s)) < 0)
		goto out;
	err = -ENOTDIR;
	if((s.mode & ~0777) != S_IFDIR)
		goto out;
	err = 0;
	free(current->root);
	if(strcmp(f->path, "/") == 0){
		current->root = nil;
	} else {
		current->root = kstrdup(f->path);
	}
out:
	putfile(f);
	return err;
}

int
fschown(char *path, int uid, int gid, int link)
{
	int err;
	Udev *dev;

	trace("fschown(%s, %d, %d, %d)", path, uid, gid, link);

	if(fsenter(&err) < 0)
		return err;
	err = -EPERM;
	if((dev = path2dev(path)) && dev->chown)
		err = dev->chown(path, uid, gid, link);
	fsleave();
	return err;
}

int sys_chown(char *name, int uid, int gid)
{
	int err;

	trace("sys_chown(%s, %d, %d)", name, uid, gid);

	if((name = fsfullpath(name)) == nil)
		return -EFAULT;
	err =  fschown(name, uid, gid, 0);
	free(name);

	return err;
}

int sys_lchown(char *name, int uid, int gid)
{
	int err;

	trace("sys_lchown(%s, %d, %d)", name, uid, gid);

	if((name = fsfullpath(name)) == nil)
		return -EFAULT;
	err = fschown(name, uid, gid, 1);
	free(name);

	return err;
}

int
fsreadlink(char *path, char *buf, int len)
{
	int err;
	Udev *dev;

	trace("fsreadlink(%s)", path);

	if(fsenter(&err) < 0)
		return err;
	err = -EPERM;
	if((dev = path2dev(path)) && dev->readlink)
		err = dev->readlink(path, buf, len);
	fsleave();

	return err;
}

int sys_readlink(char *name, char *buf, int len)
{
	int err;

	trace("sys_readlink(%s, %p, %x)", name, buf, len);

	if((name = fsfullpath(name)) == nil)
		return -EFAULT;
	err = fsreadlink(name, buf, len);
	free(name);

	return err;
}

int
fsrename(char *old, char *new)
{
	int err;
	Udev *dev;

	trace("fsrename(%s, %s)", old, new);

	if(fsenter(&err) < 0)
		return err;
	err = -EPERM;
	if((dev = path2dev(old)) && dev->rename){
		err = -EXDEV;
		if(dev == path2dev(new))
			err = dev->rename(old, new);
	}
	fsleave();

	return err;
}


int sys_rename(char *from, char *to)
{
	int err;

	trace("sys_rename(%s, %s)", from, to);

	if((from = fsfullpath(from)) == nil)
		return -EFAULT;
	if((to = fsfullpath(to)) == nil){
		free(from);
		return -EFAULT;
	}
	err = fsrename(from, to);
	free(from);
	free(to);

	return err;
}

int
fsmkdir(char *path, int mode)
{
	int err;
	Udev *dev;

	trace("fsmkdir(%s, %#o)", path, mode);

	if(fsenter(&err) < 0)
		return err;

	err = -EPERM;
	if((dev = path2dev(path)) && dev->mkdir)
		err = dev->mkdir(path, mode);
	fsleave();

	return err;
}

int sys_mkdir(char *name, int mode)
{
	int err;

	trace("sys_mkdir(%s, %#o)", name, mode);

	if((name = fsfullpath(name)) == nil)
		return -EFAULT;
	err = fsmkdir(name, mode);
	free(name);

	return err;
}

int
fsutime(char *path, int atime, int mtime)
{
	int err;
	Udev *dev;

	trace("fsutime(%s, %d, %d)", path, atime, mtime);

	if(fsenter(&err) < 0)
		return err;
	err = -EPERM;
	if((dev = path2dev(path)) && dev->utime)
		err = dev->utime(path, atime, mtime);
	fsleave();

	return err;
}

struct linux_utimbuf
{
	long	atime;
	long	mtime;
};

int sys_utime(char *name, void *times)
{
	int err;
	struct linux_utimbuf *t = times;

	trace("sys_utime(%s, %p)", name, times);

	if((name = fsfullpath(name)) == nil)
		return -EFAULT;
	if(t != nil){
		err = fsutime(name, t->atime, t->mtime);
	}else{
		long x = time(0);
		err = fsutime(name, x, x);
	}
	free(name);

	return err;
}

int sys_utimes(char *name, void *tvp)
{
	int err;
	struct linux_timeval *t = tvp;

	trace("sys_utimes(%s, %p)", name, tvp);

	if((name = fsfullpath(name)) == nil)
		return -EFAULT;
	if(t != nil){
		err = fsutime(name, t[0].tv_sec, t[1].tv_sec);
	}else{
		long x = time(0);
		err = fsutime(name, x, x);
	}
	free(name);

	return err;
}

int
fschmod(char *path, int mode)
{
	int err;
	Udev *dev;

	trace("fschmod(%s, %#o)", path, mode);

	if(fsenter(&err) < 0)
		return err;
	err = -EPERM;
	if((dev = path2dev(path)) && dev->chmod)
		err = dev->chmod(path, mode);
	fsleave();

	return err;
}

int sys_chmod(char *name, int mode)
{
	int err;

	trace("sys_chmod(%s, %#o)", name, mode);

	if((name = fsfullpath(name)) == nil)
		return -EFAULT;
	err = fschmod(name, mode);
	free(name);

	return err;
}

int
fstruncate(char *path, vlong size)
{
	int err;
	Udev *dev;

	trace("fstruncate(%s, %llx)", path, size);

	if(fsenter(&err) < 0)
		return err;
	err = -EPERM;
	if((dev = path2dev(path)) && dev->truncate)
		err = dev->truncate(path, size);
	fsleave();

	return err;
}

int sys_truncate(char *name, ulong size)
{
	int err;

	trace("sys_truncate(%s, %lux)", name, size);

	if((name = fsfullpath(name)) == nil)
		return -EFAULT;
	err = fstruncate(name, size);
	free(name);

	return err;
}

int
fsunlink(char *path, int rmdir)
{
	int err;
	Udev *dev;

	trace("fsunlink(%s, %d)", path, rmdir);

	if(fsenter(&err) < 0)
		return err;
	err = -EPERM;
	if((dev = path2dev(path)) && dev->unlink)
		err = dev->unlink(path, rmdir);
	fsleave();

	return err;
}

int sys_unlink(char *name)
{
	int err;

	trace("sys_unlink(%s)", name);

	if((name = fsfullpath(name)) == nil)
		return -EFAULT;
	err = fsunlink(name, 0);
	free(name);

	return err;
}

int sys_rmdir(char *name)
{
	int err;

	trace("sys_rmdir(%s)", name);

	if((name = fsfullpath(name)) == nil)
		return -EFAULT;
	err = fsunlink(name, 1);
	free(name);

	return err;
}

int
fslink(char *old, char *new, int sym)
{
	int err;
	Udev *dev;

	trace("fslink(%s, %s, %d)", old, new, sym);

	if(fsenter(&err) < 0)
		return err;
	err = -EPERM;
	if((dev = path2dev(new)) && dev->link){
		err = -EXDEV;
		if(sym || dev == path2dev(old))
			err = dev->link(old, new, sym);
	}
	fsleave();

	return err;
}

int sys_link(char *old, char *new)
{
	int err;

	trace("sys_link(%s, %s)", old, new);

	if((old = fsfullpath(old)) == nil)
		return -EFAULT;
	if((new = fsfullpath(new)) == nil){
		free(old);
		return -EFAULT;
	}
	err = fslink(old, new, 0);
	free(old);
	free(new);

	return err;
}

int sys_symlink(char *old, char *new)
{
	int err;

	trace("sys_symlink(%s, %s)", old, new);

	if((new = fsfullpath(new)) == nil)
		return -EFAULT;
	err = fslink(old, new, 1);
	free(new);

	return err;
}
Commit	Line	Data
cae36a52	1	#include <u.h>
	2	#include <libc.h>
	3	#include <ureg.h>
	4	#include "dat.h"
	5	#include "fns.h"
	6	#include "linux.h"
	7
	8	typedef struct Mount Mount;
	9
	10	struct Mount
	11	{
	12	Mount *next;
	13	Udev *dev;
	14	int npath;
	15	char path[];
	16	};
	17
	18	static Mount *mtab;
	19
	20	void
	21	fsmount(Udev dev, char path)
	22	{
	23	Mount m, *p;
	24	int n;
	25
	26	if(dev == nil)
	27	return;
	28
	29	n = strlen(path);
	30	m = kmalloc(sizeof(*m) + n + 1);
	31	m->dev = dev;
	32	m->next = nil;
	33	m->npath = n;
	34	strcpy(m->path, path);
	35
	36	for(p=&mtab;;p=&((*p)->next)){
	37	Mount *x;
	38
	39	if(x = *p){
	40	if(m->npath < x->npath)
	41	continue;
	42	if(m->npath == x->npath){
	43	if(strcmp(m->path, x->path) < 0)
	44	continue;
	45	}
	46	}
	47	m->next = *p;
	48	*p = m;
	49	break;
	50	}
	51	}
	52
	53	ulong
	54	hashpath(char *s)
	55	{
	56	ulong h;
	57	for(h=0; *s; s++)
	58	h = (h * 13) + (*s - 'a');
	59	return h;
	60	}
	61
	62	char*
	63	basepath(char p, char *ps)
	64	{
65	char x, s;
66	int n;
67
68	if(s = strrchr(p, '/')){
69	if(s[1] != 0){
70	if(ps)
71	*ps = kstrdup(s+1);
72	if((n = s - p) == 0)
73	n = 1;
74	x = kmalloc(n+1);
75	memmove(x, p, n);
76	x[n] = 0;
77	return x;
78	}
79	}
80	if(ps)
81	*ps = nil;
82	return nil;
83	}
84
85	char*
86	allocpath(char base, char prefix, char *name)
87	{
88	char p, s;
89	int n, m, k;
90
91	n = strlen(base);
92	m = strlen(name);
93	k = prefix ? strlen(prefix) : 0;
94	p = s = kmalloc(n+m+k+2);
95	memmove(p, base, n);
96	p += n;
97	if(m \|\| k)
98	*p++ = '/';
99	if(k){
100	memmove(p, prefix, k);
101	p += k;
102	}
103	memmove(p, name, m+1);
104	return s;
105	}
106
107	char*
108	fullpath(char base, char name)
109	{
110	char *s;
111
112	if(name == '/' \|\| name == '#'){
113	s = kstrdup(name);
114	} else if(base) {
115	s = allocpath(base, nil, name);
116	} else {
117	s = nil;
118	}
119	if(s != nil)
120	cleanname(s);
121	return s;
122	}
123
124	char*
125	shortpath(char base, char path)
126	{
127	int n;
128
129	n = strlen(base);
130	if((n <= strlen(path)) && (strncmp(path, base, n)==0)){
131	path += n;
132	if(*path == '/')
133	path++;
134	if(*path == 0)
135	path = ".";
136	}
137	return path;
138	}
139
140	char*
141	fsfullpath(char *path)
142	{
143	char *root;
144
145	path = fullpath(current->cwd, path);
146	if(path && (root = current->root)){
147	root = allocpath(root, nil, path+1);
148	free(path);
149	path = root;
150	}
151	return path;
152	}
153
154	char*
155	fsrootpath(char *path)
156	{
157	char *root;
158
159	if(root = current->root){
160	root = shortpath(root, path);
161	if(*root == '.'){
162	path = "/";
163	} else if(root > path){
164	path = root-1;
165	}
166	}
167	return path;
168	}
169
170	static Mount*
171	path2mount(char *path)
172	{
173	Mount *m;
174
175	for(m=mtab; m; m=m->next){
176	if(strncmp(path, m->path, m->npath) == 0){
177	switch(path[m->npath]){
178	case '\0':
179	case '/':
180	return m;
181	}
182	}
183	}
184	return nil;
185	}
186
187	static Udev*
188	path2dev(char *path)
189	{
190	Mount *m;
191
192	if(m = path2mount(path))
193	return m->dev;
194	return nil;
195	}
196
197	static int
198	fsenter(int *perr)
199	{
200	int err;
201
202	if(perr == nil)
203	perr = &err;
204	if(current->linkloop > 8)
205	return *perr = -ELOOP;
206	current->linkloop++;
207	return 0;
208	}
209
210	static void
211	fsleave(void)
212	{
213	current->linkloop--;
214	}
215
216	int sys_getcwd(char *buf, int len)
217	{
218	int n;
219	char *cwd;
220
221	trace("sys_getcwd(%p, %x)", buf, len);
222
223	cwd = current->cwd;
224	n = strlen(cwd)+1;
225	if(n > len)
226	return -ERANGE;
227	memmove(buf, cwd, n);
228	return n;
229	}
230
231	int
232	fsopen(char path, int mode, int perm, Ufile *pf)
233	{
234	int err;
235	Udev *dev;
236
237	trace("fsopen(%s, %#o, %#o)", path, mode, perm);
238
239	*pf = nil;
240	if(fsenter(&err) < 0)
241	return err;
242	err = -ENOENT;
243	if((dev = path2dev(path)) && dev->open)
244	err = dev->open(path, mode, perm, pf);
245	fsleave();
246	return err;
247	}
248
249	int
250	fsaccess(char *path, int mode)
251	{
252	int err;
253	Udev *dev;
254
255	trace("fsaccess(%s, %#o)", path, mode);
256
257	if(fsenter(&err) < 0)
258	return err;
259	err = -ENOENT;
260	if(dev = path2dev(path)){
261	err = 0;
262	if(dev->access)
263	err = dev->access(path, mode);
264	}
265	fsleave();
266
267	return err;
268	}
269
270	int sys_access(char *name, int mode)
271	{
272	int err;
273
274	trace("sys_access(%s, %#o)", name, mode);
275
276	if((name = fsfullpath(name)) == nil)
277	return -EFAULT;
278	err = fsaccess(name, mode);
279	free(name);
280
281	return err;
282	}
283
284	int sys_open(char *name, int mode, int perm)
285	{
286	int err;
287	Ufile *file;
288
289	trace("sys_open(%s, %#o, %#o)", name, mode, perm);
290
291	if((name = fsfullpath(name)) == nil)
292	return -EFAULT;
293	err = fsopen(name, mode, perm, &file);
294	free(name);
295
296	if(err == 0)
297	err = newfd(file, FD_CLOEXEC);
298
299	return err;
300	}
301
302	int sys_creat(char *name, int perm)
303	{
304	trace("sys_create(%s, %#o)", name, perm);
305
306	return sys_open(name, O_CREAT\|O_TRUNC, perm);
307	}
308
309	int
310	fsstat(char path, int link, Ustat ps)
311	{
312	int err;
313	Udev *dev;
314
315	trace("fsstat(%s, %d)", path, link);
316
317	if(fsenter(&err) < 0)
318	return err;
319	err = -EPERM;
320	if((dev = path2dev(path)) && dev->stat){
321	memset(ps, 0, sizeof(Ustat));
322	err = dev->stat(path, link, ps);
323	}
324	fsleave();
325	return err;
326	}
327
328	int
329	sys_chdir(char *name)
330	{
331	int err;
332	Ufile *f;
333
334	trace("sys_chdir(%s)", name);
335
336	if((name = fsfullpath(name)) == nil)
337	return -EFAULT;
338	err = fsopen(name, O_RDONLY, 0, &f);
339	free(name);
340	if(err == 0){
341	err = chdirfile(f);
342	putfile(f);
343	}
344	return err;
345	}
346
347	int sys_chroot(char *name)
348	{
349	Ufile *f;
350	Ustat s;
351	int err;
352
353	trace("sys_chroot(%s)", name);
354
355	f = nil;
356	if((err = fsopen(name, O_RDONLY, 0, &f)) < 0)
357	goto out;
358	err = -ENOTDIR;
359	if(f->path == nil)
360	goto out;
361	if(devtab[f->dev]->fstat == nil)
362	goto out;
363	if((err = devtab[f->dev]->fstat(f, &s)) < 0)
364	goto out;
365	err = -ENOTDIR;
366	if((s.mode & ~0777) != S_IFDIR)
367	goto out;
368	err = 0;
369	free(current->root);
370	if(strcmp(f->path, "/") == 0){
371	current->root = nil;
372	} else {
373	current->root = kstrdup(f->path);
374	}
375	out:
376	putfile(f);
377	return err;
378	}
379
380	int
381	fschown(char *path, int uid, int gid, int link)
382	{
383	int err;
384	Udev *dev;
385
386	trace("fschown(%s, %d, %d, %d)", path, uid, gid, link);
387
388	if(fsenter(&err) < 0)
389	return err;
390	err = -EPERM;
391	if((dev = path2dev(path)) && dev->chown)
392	err = dev->chown(path, uid, gid, link);
393	fsleave();
394	return err;
395	}
396
397	int sys_chown(char *name, int uid, int gid)
398	{
399	int err;
400
401	trace("sys_chown(%s, %d, %d)", name, uid, gid);
402
403	if((name = fsfullpath(name)) == nil)
404	return -EFAULT;
405	err = fschown(name, uid, gid, 0);
406	free(name);
407
408	return err;
409	}
410
411	int sys_lchown(char *name, int uid, int gid)
412	{
413	int err;
414
415	trace("sys_lchown(%s, %d, %d)", name, uid, gid);
416
417	if((name = fsfullpath(name)) == nil)
418	return -EFAULT;
419	err = fschown(name, uid, gid, 1);
420	free(name);
421
422	return err;
423	}
424
425	int
426	fsreadlink(char path, char buf, int len)
427	{
428	int err;
429	Udev *dev;
430
431	trace("fsreadlink(%s)", path);
432
433	if(fsenter(&err) < 0)
434	return err;
435	err = -EPERM;
436	if((dev = path2dev(path)) && dev->readlink)
437	err = dev->readlink(path, buf, len);
438	fsleave();
439
440	return err;
441	}
442
443	int sys_readlink(char name, char buf, int len)
444	{
445	int err;
446
447	trace("sys_readlink(%s, %p, %x)", name, buf, len);
448
449	if((name = fsfullpath(name)) == nil)
450	return -EFAULT;
451	err = fsreadlink(name, buf, len);
452	free(name);
453
454	return err;
455	}
456
457	int
458	fsrename(char old, char new)
459	{
460	int err;
461	Udev *dev;
462
463	trace("fsrename(%s, %s)", old, new);
464
465	if(fsenter(&err) < 0)
466	return err;
467	err = -EPERM;
468	if((dev = path2dev(old)) && dev->rename){
469	err = -EXDEV;
470	if(dev == path2dev(new))
471	err = dev->rename(old, new);
472	}
473	fsleave();
474
475	return err;
476	}
477
478
479	int sys_rename(char from, char to)
480	{
481	int err;
482
483	trace("sys_rename(%s, %s)", from, to);
484
485	if((from = fsfullpath(from)) == nil)
486	return -EFAULT;
487	if((to = fsfullpath(to)) == nil){
488	free(from);
489	return -EFAULT;
490	}
491	err = fsrename(from, to);
492	free(from);
493	free(to);
494
495	return err;
496	}
497
498	int
499	fsmkdir(char *path, int mode)
500	{
501	int err;
502	Udev *dev;
503
504	trace("fsmkdir(%s, %#o)", path, mode);
505
506	if(fsenter(&err) < 0)
507	return err;
508
509	err = -EPERM;
510	if((dev = path2dev(path)) && dev->mkdir)
511	err = dev->mkdir(path, mode);
512	fsleave();
513
514	return err;
515	}
516
517	int sys_mkdir(char *name, int mode)
518	{
519	int err;
520
521	trace("sys_mkdir(%s, %#o)", name, mode);
522
523	if((name = fsfullpath(name)) == nil)
524	return -EFAULT;
525	err = fsmkdir(name, mode);
526	free(name);
527
528	return err;
529	}
530
531	int
532	fsutime(char *path, int atime, int mtime)
533	{
534	int err;
535	Udev *dev;
536
537	trace("fsutime(%s, %d, %d)", path, atime, mtime);
538
539	if(fsenter(&err) < 0)
540	return err;
541	err = -EPERM;
542	if((dev = path2dev(path)) && dev->utime)
543	err = dev->utime(path, atime, mtime);
544	fsleave();
545
546	return err;
547	}
548
549	struct linux_utimbuf
550	{
551	long atime;
552	long mtime;
553	};
554
555	int sys_utime(char name, void times)
556	{
557	int err;
558	struct linux_utimbuf *t = times;
559
560	trace("sys_utime(%s, %p)", name, times);
561
562	if((name = fsfullpath(name)) == nil)
563	return -EFAULT;
564	if(t != nil){
565	err = fsutime(name, t->atime, t->mtime);
566	}else{
567	long x = time(0);
568	err = fsutime(name, x, x);
569	}
570	free(name);
571
572	return err;
573	}
574
575	int sys_utimes(char name, void tvp)
576	{
577	int err;
578	struct linux_timeval *t = tvp;
579
580	trace("sys_utimes(%s, %p)", name, tvp);
581
582	if((name = fsfullpath(name)) == nil)
583	return -EFAULT;
584	if(t != nil){
585	err = fsutime(name, t[0].tv_sec, t[1].tv_sec);
586	}else{
587	long x = time(0);
588	err = fsutime(name, x, x);
589	}
590	free(name);
591
592	return err;
593	}
594
595	int
596	fschmod(char *path, int mode)
597	{
598	int err;
599	Udev *dev;
600
601	trace("fschmod(%s, %#o)", path, mode);
602
603	if(fsenter(&err) < 0)
604	return err;
605	err = -EPERM;
606	if((dev = path2dev(path)) && dev->chmod)
607	err = dev->chmod(path, mode);
608	fsleave();
609
610	return err;
611	}
612
613	int sys_chmod(char *name, int mode)
614	{
615	int err;
616
617	trace("sys_chmod(%s, %#o)", name, mode);
618
619	if((name = fsfullpath(name)) == nil)
620	return -EFAULT;
621	err = fschmod(name, mode);
622	free(name);
623
624	return err;
625	}
626
627	int
628	fstruncate(char *path, vlong size)
629	{
630	int err;
631	Udev *dev;
632
633	trace("fstruncate(%s, %llx)", path, size);
634
635	if(fsenter(&err) < 0)
636	return err;
637	err = -EPERM;
638	if((dev = path2dev(path)) && dev->truncate)
639	err = dev->truncate(path, size);
640	fsleave();
641
642	return err;
643	}
644
645	int sys_truncate(char *name, ulong size)
646	{
647	int err;
648
649	trace("sys_truncate(%s, %lux)", name, size);
650
651	if((name = fsfullpath(name)) == nil)
652	return -EFAULT;
653	err = fstruncate(name, size);
654	free(name);
655
656	return err;
657	}
658
659	int
660	fsunlink(char *path, int rmdir)
661	{
662	int err;
663	Udev *dev;
664
665	trace("fsunlink(%s, %d)", path, rmdir);
666
667	if(fsenter(&err) < 0)
668	return err;
669	err = -EPERM;
670	if((dev = path2dev(path)) && dev->unlink)
671	err = dev->unlink(path, rmdir);
672	fsleave();
673
674	return err;
675	}
676
677	int sys_unlink(char *name)
678	{
679	int err;
680
681	trace("sys_unlink(%s)", name);
682
683	if((name = fsfullpath(name)) == nil)
684	return -EFAULT;
685	err = fsunlink(name, 0);
686	free(name);
687
688	return err;
689	}
690
691	int sys_rmdir(char *name)
692	{
693	int err;
694
695	trace("sys_rmdir(%s)", name);
696
697	if((name = fsfullpath(name)) == nil)
698	return -EFAULT;
699	err = fsunlink(name, 1);
700	free(name);
701
702	return err;
703	}
704
705	int
706	fslink(char old, char new, int sym)
707	{
708	int err;
709	Udev *dev;
710
711	trace("fslink(%s, %s, %d)", old, new, sym);
712
713	if(fsenter(&err) < 0)
714	return err;
715	err = -EPERM;
716	if((dev = path2dev(new)) && dev->link){
717	err = -EXDEV;
718	if(sym \|\| dev == path2dev(old))
719	err = dev->link(old, new, sym);
720	}
721	fsleave();
722
723	return err;
724	}
725
726	int sys_link(char old, char new)
727	{
728	int err;
729
730	trace("sys_link(%s, %s)", old, new);
731
732	if((old = fsfullpath(old)) == nil)
733	return -EFAULT;
734	if((new = fsfullpath(new)) == nil){
735	free(old);
736	return -EFAULT;
737	}
738	err = fslink(old, new, 0);
739	free(old);
740	free(new);
741
742	return err;
743	}
744
745	int sys_symlink(char old, char new)
746	{
747	int err;
748
749	trace("sys_symlink(%s, %s)", old, new);
750
751	if((new = fsfullpath(new)) == nil)
752	return -EFAULT;
753	err = fslink(old, new, 1);
754	free(new);
755
756	return err;
757	}
758