WebSVN – HelenOS – Diff – //trunk/uspace/lib/libc/generic/vfs/vfs.c



futex_t vfs_phone_futex = FUTEX_INITIALIZER;
 
futex_t cwd_futex = FUTEX_INITIALIZER;
DIR *cwd_dir = NULL;
char *cwd_path = NULL;
size_t cwd_size = 0;
 
char *absolutize(const char *path, size_t *retlen)
{
    char *ncwd_path;
    char *ncwd_path_nc;
 
    futex_down(&cwd_futex);
    size_t size = str_size(path);
    if (*path != '/') {
        if (!cwd_path) {
            futex_up(&cwd_futex);
            return NULL;
        }
        ncwd_path_nc = malloc(cwd_size + 1 + size + 1);
        if (!ncwd_path_nc) {
            futex_up(&cwd_futex);
            return NULL;
        }
        str_ncpy(ncwd_path_nc, cwd_path, cwd_size + 1 + size + 1);
        ncwd_path_nc[cwd_size] = '/';
        ncwd_path_nc[cwd_size + 1] = '\0';
    } else {
        ncwd_path_nc = malloc(size + 1);
        if (!ncwd_path_nc) {
            futex_up(&cwd_futex);
            return NULL;
        }
        ncwd_path_nc[0] = '\0';

   
    ipc_call_t answer;
    aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0,
        &answer);
   
    ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
   
    if (retval != EOK) {
        async_wait_for(req, NULL);
        ipc_hangup(phone);
        return retval;

   
    res = device_get_handle(dev, &dev_handle, flags);
    if (res != EOK)
        return res;
   
    size_t mpa_size;
    char *mpa = absolutize(mp, &mpa_size);
    if (!mpa)
        return ENOMEM;
   
    futex_down(&vfs_phone_futex);
    async_serialize_start();
    vfs_connect();
   
    req = async_send_2(vfs_phone, VFS_MOUNT, dev_handle, flags, NULL);
    rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_size);
    if (rc != EOK) {
        async_wait_for(req, NULL);
        async_serialize_end();
        futex_up(&vfs_phone_futex);
        free(mpa);
        return (int) rc;
    }
   
    rc = ipc_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
    if (rc != EOK) {
        async_wait_for(req, NULL);
        async_serialize_end();
        futex_up(&vfs_phone_futex);
        free(mpa);

{
    ipcarg_t rc;
    ipc_call_t answer;
    aid_t req;
   
    size_t pa_size;
    char *pa = absolutize(path, &pa_size);
    if (!pa)
        return ENOMEM;
   
    futex_down(&vfs_phone_futex);
    async_serialize_start();
    vfs_connect();
   
    req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);
    rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    if (rc != EOK) {
        async_wait_for(req, NULL);
        async_serialize_end();
        futex_up(&vfs_phone_futex);
        free(pa);

int mkdir(const char *path, mode_t mode)
{
    ipcarg_t rc;
    aid_t req;
   
    size_t pa_size;
    char *pa = absolutize(path, &pa_size);
    if (!pa)
        return ENOMEM;
   
    futex_down(&vfs_phone_futex);
    async_serialize_start();
    vfs_connect();
   
    req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL);
    rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    if (rc != EOK) {
        async_wait_for(req, NULL);
        async_serialize_end();
        futex_up(&vfs_phone_futex);
        free(pa);

static int _unlink(const char *path, int lflag)
{
    ipcarg_t rc;
    aid_t req;
   
    size_t pa_size;
    char *pa = absolutize(path, &pa_size);
    if (!pa)
        return ENOMEM;
 
    futex_down(&vfs_phone_futex);
    async_serialize_start();
    vfs_connect();
   
    req = async_send_0(vfs_phone, VFS_UNLINK, NULL);
    rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    if (rc != EOK) {
        async_wait_for(req, NULL);
        async_serialize_end();
        futex_up(&vfs_phone_futex);
        free(pa);

int rename(const char *old, const char *new)
{
    ipcarg_t rc;
    aid_t req;
   
    size_t olda_size;
    char *olda = absolutize(old, &olda_size);
    if (!olda)
        return ENOMEM;
 
    size_t newa_size;
    char *newa = absolutize(new, &newa_size);
    if (!newa) {
        free(olda);
        return ENOMEM;
    }
 
    futex_down(&vfs_phone_futex);
    async_serialize_start();
    vfs_connect();
   
    req = async_send_0(vfs_phone, VFS_RENAME, NULL);
    rc = ipc_data_write_start(vfs_phone, olda, olda_size);
    if (rc != EOK) {
        async_wait_for(req, NULL);
        async_serialize_end();
        futex_up(&vfs_phone_futex);
        free(olda);
        free(newa);
        return (int) rc;
    }
    rc = ipc_data_write_start(vfs_phone, newa, newa_size);
    if (rc != EOK) {
        async_wait_for(req, NULL);
        async_serialize_end();
        futex_up(&vfs_phone_futex);
        free(olda);

    return rc;
}
 
int chdir(const char *path)
{
    size_t pa_size;
    char *pa = absolutize(path, &pa_size);
    if (!pa)
        return ENOMEM;
 
    DIR *d = opendir(pa);
    if (!d) {

    if (cwd_dir) {
        closedir(cwd_dir);
        cwd_dir = NULL;
        free(cwd_path);
        cwd_path = NULL;
        cwd_size = 0;
    }
    cwd_dir = d;
    cwd_path = pa;
    cwd_size = pa_size;
    futex_up(&cwd_futex);
    return EOK;
}
 
char *getcwd(char *buf, size_t size)
{
    if (!size)
        return NULL;
    futex_down(&cwd_futex);
    if (size < cwd_size + 1) {
        futex_up(&cwd_futex);
        return NULL;
    }
    strcpy(buf, cwd_path);
    futex_up(&cwd_futex);

Rev 4002	Rev 4256
Line 55...	Line 55...
55	futex_t vfs_phone_futex = FUTEX_INITIALIZER;	55	futex_t vfs_phone_futex = FUTEX_INITIALIZER;
56		56
57	futex_t cwd_futex = FUTEX_INITIALIZER;	57	futex_t cwd_futex = FUTEX_INITIALIZER;
58	DIR *cwd_dir = NULL;	58	DIR *cwd_dir = NULL;
59	char *cwd_path = NULL;	59	char *cwd_path = NULL;
60	size_t cwd_len = 0;	60	size_t cwd_size = 0;
61		61
62	char absolutize(const char path, size_t *retlen)	62	char absolutize(const char path, size_t *retlen)
63	{	63	{
64	char *ncwd_path;	64	char *ncwd_path;
65	char *ncwd_path_nc;	65	char *ncwd_path_nc;
66		66
67	futex_down(&cwd_futex);	67	futex_down(&cwd_futex);
68	size_t len = strlen(path);	68	size_t size = str_size(path);
69	if (*path != '/') {	69	if (*path != '/') {
70	if (!cwd_path) {	70	if (!cwd_path) {
71	futex_up(&cwd_futex);	71	futex_up(&cwd_futex);
72	return NULL;	72	return NULL;
73	}	73	}
74	ncwd_path_nc = malloc(cwd_len + 1 + len + 1);	74	ncwd_path_nc = malloc(cwd_size + 1 + size + 1);
75	if (!ncwd_path_nc) {	75	if (!ncwd_path_nc) {
76	futex_up(&cwd_futex);	76	futex_up(&cwd_futex);
77	return NULL;	77	return NULL;
78	}	78	}
79	strcpy(ncwd_path_nc, cwd_path);	79	str_ncpy(ncwd_path_nc, cwd_path, cwd_size + 1 + size + 1);
80	ncwd_path_nc[cwd_len] = '/';	80	ncwd_path_nc[cwd_size] = '/';
81	ncwd_path_nc[cwd_len + 1] = '\0';	81	ncwd_path_nc[cwd_size + 1] = '\0';
82	} else {	82	} else {
83	ncwd_path_nc = malloc(len + 1);	83	ncwd_path_nc = malloc(size + 1);
84	if (!ncwd_path_nc) {	84	if (!ncwd_path_nc) {
85	futex_up(&cwd_futex);	85	futex_up(&cwd_futex);
86	return NULL;	86	return NULL;
87	}	87	}
88	ncwd_path_nc[0] = '\0';	88	ncwd_path_nc[0] = '\0';
Line 130...	Line 130...
130		130
131	ipc_call_t answer;	131	ipc_call_t answer;
132	aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0,	132	aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0,
133	&answer);	133	&answer);
134		134
135	ipcarg_t retval = ipc_data_write_start(phone, name, strlen(name) + 1);	135	ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
136		136
137	if (retval != EOK) {	137	if (retval != EOK) {
138	async_wait_for(req, NULL);	138	async_wait_for(req, NULL);
139	ipc_hangup(phone);	139	ipc_hangup(phone);
140	return retval;	140	return retval;
Line 164...	Line 164...
164		164
165	res = device_get_handle(dev, &dev_handle, flags);	165	res = device_get_handle(dev, &dev_handle, flags);
166	if (res != EOK)	166	if (res != EOK)
167	return res;	167	return res;
168		168
169	size_t mpa_len;	169	size_t mpa_size;
170	char *mpa = absolutize(mp, &mpa_len);	170	char *mpa = absolutize(mp, &mpa_size);
171	if (!mpa)	171	if (!mpa)
172	return ENOMEM;	172	return ENOMEM;
173		173
174	futex_down(&vfs_phone_futex);	174	futex_down(&vfs_phone_futex);
175	async_serialize_start();	175	async_serialize_start();
176	vfs_connect();	176	vfs_connect();
177		177
178	req = async_send_2(vfs_phone, VFS_MOUNT, dev_handle, flags, NULL);	178	req = async_send_2(vfs_phone, VFS_MOUNT, dev_handle, flags, NULL);
179	rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_len);	179	rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_size);
180	if (rc != EOK) {	180	if (rc != EOK) {
181	async_wait_for(req, NULL);	181	async_wait_for(req, NULL);
182	async_serialize_end();	182	async_serialize_end();
183	futex_up(&vfs_phone_futex);	183	futex_up(&vfs_phone_futex);
184	free(mpa);	184	free(mpa);
185	return (int) rc;	185	return (int) rc;
186	}	186	}
187		187
188	rc = ipc_data_write_start(vfs_phone, (void *) fs_name, strlen(fs_name));	188	rc = ipc_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
189	if (rc != EOK) {	189	if (rc != EOK) {
190	async_wait_for(req, NULL);	190	async_wait_for(req, NULL);
191	async_serialize_end();	191	async_serialize_end();
192	futex_up(&vfs_phone_futex);	192	futex_up(&vfs_phone_futex);
193	free(mpa);	193	free(mpa);
Line 206...	Line 206...
206	{	206	{
207	ipcarg_t rc;	207	ipcarg_t rc;
208	ipc_call_t answer;	208	ipc_call_t answer;
209	aid_t req;	209	aid_t req;
210		210
211	size_t pa_len;	211	size_t pa_size;
212	char *pa = absolutize(path, &pa_len);	212	char *pa = absolutize(path, &pa_size);
213	if (!pa)	213	if (!pa)
214	return ENOMEM;	214	return ENOMEM;
215		215
216	futex_down(&vfs_phone_futex);	216	futex_down(&vfs_phone_futex);
217	async_serialize_start();	217	async_serialize_start();
218	vfs_connect();	218	vfs_connect();
219		219
220	req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);	220	req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);
221	rc = ipc_data_write_start(vfs_phone, pa, pa_len);	221	rc = ipc_data_write_start(vfs_phone, pa, pa_size);
222	if (rc != EOK) {	222	if (rc != EOK) {
223	async_wait_for(req, NULL);	223	async_wait_for(req, NULL);
224	async_serialize_end();	224	async_serialize_end();
225	futex_up(&vfs_phone_futex);	225	futex_up(&vfs_phone_futex);
226	free(pa);	226	free(pa);
Line 382...	Line 382...
382	int mkdir(const char *path, mode_t mode)	382	int mkdir(const char *path, mode_t mode)
383	{	383	{
384	ipcarg_t rc;	384	ipcarg_t rc;
385	aid_t req;	385	aid_t req;
386		386
387	size_t pa_len;	387	size_t pa_size;
388	char *pa = absolutize(path, &pa_len);	388	char *pa = absolutize(path, &pa_size);
389	if (!pa)	389	if (!pa)
390	return ENOMEM;	390	return ENOMEM;
391		391
392	futex_down(&vfs_phone_futex);	392	futex_down(&vfs_phone_futex);
393	async_serialize_start();	393	async_serialize_start();
394	vfs_connect();	394	vfs_connect();
395		395
396	req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL);	396	req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL);
397	rc = ipc_data_write_start(vfs_phone, pa, pa_len);	397	rc = ipc_data_write_start(vfs_phone, pa, pa_size);
398	if (rc != EOK) {	398	if (rc != EOK) {
399	async_wait_for(req, NULL);	399	async_wait_for(req, NULL);
400	async_serialize_end();	400	async_serialize_end();
401	futex_up(&vfs_phone_futex);	401	futex_up(&vfs_phone_futex);
402	free(pa);	402	free(pa);
Line 412...	Line 412...
412	static int _unlink(const char *path, int lflag)	412	static int _unlink(const char *path, int lflag)
413	{	413	{
414	ipcarg_t rc;	414	ipcarg_t rc;
415	aid_t req;	415	aid_t req;
416		416
417	size_t pa_len;	417	size_t pa_size;
418	char *pa = absolutize(path, &pa_len);	418	char *pa = absolutize(path, &pa_size);
419	if (!pa)	419	if (!pa)
420	return ENOMEM;	420	return ENOMEM;
421		421
422	futex_down(&vfs_phone_futex);	422	futex_down(&vfs_phone_futex);
423	async_serialize_start();	423	async_serialize_start();
424	vfs_connect();	424	vfs_connect();
425		425
426	req = async_send_0(vfs_phone, VFS_UNLINK, NULL);	426	req = async_send_0(vfs_phone, VFS_UNLINK, NULL);
427	rc = ipc_data_write_start(vfs_phone, pa, pa_len);	427	rc = ipc_data_write_start(vfs_phone, pa, pa_size);
428	if (rc != EOK) {	428	if (rc != EOK) {
429	async_wait_for(req, NULL);	429	async_wait_for(req, NULL);
430	async_serialize_end();	430	async_serialize_end();
431	futex_up(&vfs_phone_futex);	431	futex_up(&vfs_phone_futex);
432	free(pa);	432	free(pa);
Line 452...	Line 452...
452	int rename(const char old, const char new)	452	int rename(const char old, const char new)
453	{	453	{
454	ipcarg_t rc;	454	ipcarg_t rc;
455	aid_t req;	455	aid_t req;
456		456
457	size_t olda_len;	457	size_t olda_size;
458	char *olda = absolutize(old, &olda_len);	458	char *olda = absolutize(old, &olda_size);
459	if (!olda)	459	if (!olda)
460	return ENOMEM;	460	return ENOMEM;
461		461
462	size_t newa_len;	462	size_t newa_size;
463	char *newa = absolutize(new, &newa_len);	463	char *newa = absolutize(new, &newa_size);
464	if (!newa) {	464	if (!newa) {
465	free(olda);	465	free(olda);
466	return ENOMEM;	466	return ENOMEM;
467	}	467	}
468		468
469	futex_down(&vfs_phone_futex);	469	futex_down(&vfs_phone_futex);
470	async_serialize_start();	470	async_serialize_start();
471	vfs_connect();	471	vfs_connect();
472		472
473	req = async_send_0(vfs_phone, VFS_RENAME, NULL);	473	req = async_send_0(vfs_phone, VFS_RENAME, NULL);
474	rc = ipc_data_write_start(vfs_phone, olda, olda_len);	474	rc = ipc_data_write_start(vfs_phone, olda, olda_size);
475	if (rc != EOK) {	475	if (rc != EOK) {
476	async_wait_for(req, NULL);	476	async_wait_for(req, NULL);
477	async_serialize_end();	477	async_serialize_end();
478	futex_up(&vfs_phone_futex);	478	futex_up(&vfs_phone_futex);
479	free(olda);	479	free(olda);
480	free(newa);	480	free(newa);
481	return (int) rc;	481	return (int) rc;
482	}	482	}
483	rc = ipc_data_write_start(vfs_phone, newa, newa_len);	483	rc = ipc_data_write_start(vfs_phone, newa, newa_size);
484	if (rc != EOK) {	484	if (rc != EOK) {
485	async_wait_for(req, NULL);	485	async_wait_for(req, NULL);
486	async_serialize_end();	486	async_serialize_end();
487	futex_up(&vfs_phone_futex);	487	futex_up(&vfs_phone_futex);
488	free(olda);	488	free(olda);
Line 497...	Line 497...
497	return rc;	497	return rc;
498	}	498	}
499		499
500	int chdir(const char *path)	500	int chdir(const char *path)
501	{	501	{
502	size_t pa_len;	502	size_t pa_size;
503	char *pa = absolutize(path, &pa_len);	503	char *pa = absolutize(path, &pa_size);
504	if (!pa)	504	if (!pa)
505	return ENOMEM;	505	return ENOMEM;
506		506
507	DIR *d = opendir(pa);	507	DIR *d = opendir(pa);
508	if (!d) {	508	if (!d) {
Line 514...	Line 514...
514	if (cwd_dir) {	514	if (cwd_dir) {
515	closedir(cwd_dir);	515	closedir(cwd_dir);
516	cwd_dir = NULL;	516	cwd_dir = NULL;
517	free(cwd_path);	517	free(cwd_path);
518	cwd_path = NULL;	518	cwd_path = NULL;
519	cwd_len = 0;	519	cwd_size = 0;
520	}	520	}
521	cwd_dir = d;	521	cwd_dir = d;
522	cwd_path = pa;	522	cwd_path = pa;
523	cwd_len = pa_len;	523	cwd_size = pa_size;
524	futex_up(&cwd_futex);	524	futex_up(&cwd_futex);
525	return EOK;	525	return EOK;
526	}	526	}
527		527
528	char getcwd(char buf, size_t size)	528	char getcwd(char buf, size_t size)
529	{	529	{
530	if (!size)	530	if (!size)
531	return NULL;	531	return NULL;
532	futex_down(&cwd_futex);	532	futex_down(&cwd_futex);
533	if (size < cwd_len + 1) {	533	if (size < cwd_size + 1) {
534	futex_up(&cwd_futex);	534	futex_up(&cwd_futex);
535	return NULL;	535	return NULL;
536	}	536	}
537	strcpy(buf, cwd_path);	537	strcpy(buf, cwd_path);
538	futex_up(&cwd_futex);	538	futex_up(&cwd_futex);

Subversion Repositories HelenOS

(root)//trunk/uspace/lib/libc/generic/vfs/vfs.c – Rev 4002 → 4256