Subversion Repositories HelenOS

Rev

Rev 2710 | Rev 2735 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2671 jermar 1
/*
2684 jermar 2
 * Copyright (c) 2008 Jakub Jermar 
2671 jermar 3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
29
/** @addtogroup libc
30
 * @{
31
 */
32
/** @file
33
 */
34
 
35
#include <vfs.h>
2694 jermar 36
#include <stdlib.h>
2674 jermar 37
#include <unistd.h>
2694 jermar 38
#include <dirent.h>
2674 jermar 39
#include <fcntl.h>
2707 jermar 40
#include <sys/stat.h>
41
#include <sys/types.h>
2671 jermar 42
#include <ipc/ipc.h>
43
#include <ipc/services.h>
44
#include <async.h>
45
#include <atomic.h>
46
#include <futex.h>
47
#include <errno.h>
48
#include <string.h>
49
#include "../../srv/vfs/vfs.h"
50
 
51
int vfs_phone = -1;
52
atomic_t vfs_phone_futex = FUTEX_INITIALIZER;
53
 
54
static int vfs_connect(void)
55
{
56
	if (vfs_phone < 0)
57
		vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
58
	return vfs_phone;
59
}
60
 
61
int mount(const char *fs_name, const char *mp, const char *dev)
62
{
63
	int res;
64
	ipcarg_t rc;
65
	aid_t req;
66
 
67
	int dev_handle = 0;	/* TODO */
68
 
69
	futex_down(&vfs_phone_futex);
70
	async_serialize_start();
71
	if (vfs_phone < 0) {
72
		res = vfs_connect();
73
		if (res < 0) {
74
			async_serialize_end();
75
			futex_up(&vfs_phone_futex);
76
			return res;
77
		}
78
	}
79
	req = async_send_1(vfs_phone, VFS_MOUNT, dev_handle, NULL);
2678 jermar 80
	rc = ipc_data_write_start(vfs_phone, (void *)fs_name, strlen(fs_name));
2671 jermar 81
	if (rc != EOK) {
82
		async_wait_for(req, NULL);
83
		async_serialize_end();
84
		futex_up(&vfs_phone_futex);
85
		return (int) rc;
86
	}
2678 jermar 87
	rc = ipc_data_write_start(vfs_phone, (void *)mp, strlen(mp));
2671 jermar 88
	if (rc != EOK) {
89
		async_wait_for(req, NULL);
90
		async_serialize_end();
91
		futex_up(&vfs_phone_futex);
92
		return (int) rc;
93
	}
94
	async_wait_for(req, &rc);
95
	async_serialize_end();
96
	futex_up(&vfs_phone_futex);
97
	return (int) rc;
98
}
99
 
2700 jermar 100
static int _open(const char *path, int lflag, int oflag, ...)
2671 jermar 101
{
102
	int res;
103
	ipcarg_t rc;
104
	ipc_call_t answer;
105
	aid_t req;
106
 
107
	futex_down(&vfs_phone_futex);
108
	async_serialize_start();
109
	if (vfs_phone < 0) {
110
		res = vfs_connect();
111
		if (res < 0) {
112
			async_serialize_end();
113
			futex_up(&vfs_phone_futex);
114
			return res;
115
		}
116
	}
2700 jermar 117
	req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);
2693 jermar 118
	rc = ipc_data_write_start(vfs_phone, path, strlen(path));
2671 jermar 119
	if (rc != EOK) {
120
		async_wait_for(req, NULL);
121
		async_serialize_end();
122
		futex_up(&vfs_phone_futex);
123
		return (int) rc;
124
	}
125
	async_wait_for(req, &rc);
126
	async_serialize_end();
127
	futex_up(&vfs_phone_futex);
128
	return (int) IPC_GET_ARG1(answer);
129
}
130
 
2700 jermar 131
int open(const char *path, int oflag, ...)
132
{
133
	return _open(path, L_FILE, oflag);
134
}
135
 
2707 jermar 136
int close(int fildes)
137
{
2734 jermar 138
	int res;
139
	ipcarg_t rc;
140
 
141
	futex_down(&vfs_phone_futex);
142
	async_serialize_start();
143
	if (vfs_phone < 0) {
144
		res = vfs_connect();
145
		if (res < 0) {
146
			async_serialize_end();
147
			futex_up(&vfs_phone_futex);
148
			return res;
149
		}
150
	}
151
 
152
	rc = async_req_1_0(vfs_phone, VFS_CLOSE, fildes);
153
 
154
	async_serialize_end();
155
	futex_up(&vfs_phone_futex);
156
 
157
	return (int)rc;
2707 jermar 158
}
159
 
2671 jermar 160
ssize_t read(int fildes, void *buf, size_t nbyte) 
161
{
162
	int res;
163
	ipcarg_t rc;
164
	ipc_call_t answer;
165
	aid_t req;
166
 
167
	futex_down(&vfs_phone_futex);
168
	async_serialize_start();
169
	if (vfs_phone < 0) {
170
		res = vfs_connect();
171
		if (res < 0) {
172
			async_serialize_end();
173
			futex_up(&vfs_phone_futex);
174
			return res;
175
		}
176
	}
2674 jermar 177
	req = async_send_1(vfs_phone, VFS_READ, fildes, &answer);
2678 jermar 178
	if (ipc_data_read_start(vfs_phone, (void *)buf, nbyte) != EOK) {
2671 jermar 179
		async_wait_for(req, NULL);
180
		async_serialize_end();
181
		futex_up(&vfs_phone_futex);
182
		return (ssize_t) rc;
183
	}
184
	async_wait_for(req, &rc);
185
	async_serialize_end();
186
	futex_up(&vfs_phone_futex);
2710 jermar 187
	if (rc == EOK)
188
		return (ssize_t) IPC_GET_ARG1(answer);
189
	else
190
		return -1;
2671 jermar 191
}
192
 
2674 jermar 193
ssize_t write(int fildes, const void *buf, size_t nbyte) 
194
{
195
	int res;
196
	ipcarg_t rc;
197
	ipc_call_t answer;
198
	aid_t req;
199
 
200
	futex_down(&vfs_phone_futex);
201
	async_serialize_start();
202
	if (vfs_phone < 0) {
203
		res = vfs_connect();
204
		if (res < 0) {
205
			async_serialize_end();
206
			futex_up(&vfs_phone_futex);
207
			return res;
208
		}
209
	}
210
	req = async_send_1(vfs_phone, VFS_WRITE, fildes, &answer);
2678 jermar 211
	if (ipc_data_write_start(vfs_phone, (void *)buf, nbyte) != EOK) {
2674 jermar 212
		async_wait_for(req, NULL);
213
		async_serialize_end();
214
		futex_up(&vfs_phone_futex);
215
		return (ssize_t) rc;
216
	}
217
	async_wait_for(req, &rc);
218
	async_serialize_end();
219
	futex_up(&vfs_phone_futex);
2710 jermar 220
	if (rc == EOK)
221
		return (ssize_t) IPC_GET_ARG1(answer);
222
	else
223
		return -1;
2674 jermar 224
}
2684 jermar 225
 
226
off_t lseek(int fildes, off_t offset, int whence)
227
{
228
	int res;
229
	ipcarg_t rc;
230
 
231
	futex_down(&vfs_phone_futex);
232
	async_serialize_start();
233
	if (vfs_phone < 0) {
234
		res = vfs_connect();
235
		if (res < 0) {
236
			async_serialize_end();
237
			futex_up(&vfs_phone_futex);
238
			return res;
239
		}
240
	}
241
 
242
	off_t newoffs;
243
	rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence,
2707 jermar 244
	    (ipcarg_t)&newoffs);
2684 jermar 245
 
246
	async_serialize_end();
247
	futex_up(&vfs_phone_futex);
248
 
249
	if (rc != EOK)
250
		return (off_t) -1;
251
 
252
	return newoffs;
253
}
254
 
2693 jermar 255
int ftruncate(int fildes, off_t length)
256
{
257
	int res;
258
	ipcarg_t rc;
259
 
260
	futex_down(&vfs_phone_futex);
261
	async_serialize_start();
262
	if (vfs_phone < 0) {
263
		res = vfs_connect();
264
		if (res < 0) {
265
			async_serialize_end();
266
			futex_up(&vfs_phone_futex);
267
			return res;
268
		}
269
	}
270
	rc = async_req_2_0(vfs_phone, VFS_TRUNCATE, fildes, length);
271
	async_serialize_end();
272
	futex_up(&vfs_phone_futex);
273
	return (int) rc;
274
}
275
 
2694 jermar 276
DIR *opendir(const char *dirname)
277
{
278
	DIR *dirp = malloc(sizeof(DIR));
279
	if (!dirp)
280
		return NULL;
2700 jermar 281
	dirp->fd = _open(dirname, L_DIRECTORY, 0);
2699 jermar 282
	if (dirp->fd < 0) {
2694 jermar 283
		free(dirp);
284
		return NULL;
285
	}
286
	return dirp;
287
}
288
 
289
struct dirent *readdir(DIR *dirp)
290
{
2699 jermar 291
	ssize_t len = read(dirp->fd, &dirp->res.d_name[0], NAME_MAX + 1);
292
	if (len <= 0)
293
		return NULL;
294
	return &dirp->res;
2694 jermar 295
}
296
 
297
void rewinddir(DIR *dirp)
298
{
2699 jermar 299
	(void) lseek(dirp->fd, 0, SEEK_SET);
2694 jermar 300
}
301
 
302
int closedir(DIR *dirp)
303
{
304
	(void) close(dirp->fd);
305
	free(dirp);
306
	return 0;
307
}
308
 
2707 jermar 309
int mkdir(const char *path, mode_t mode)
2694 jermar 310
{
2707 jermar 311
	int res;
312
	ipcarg_t rc;
313
	ipc_call_t answer;
314
	aid_t req;
315
 
316
	futex_down(&vfs_phone_futex);
317
	async_serialize_start();
318
	if (vfs_phone < 0) {
319
		res = vfs_connect();
320
		if (res < 0) {
321
			async_serialize_end();
322
			futex_up(&vfs_phone_futex);
323
			return res;
324
		}
325
	}
326
	req = async_send_1(vfs_phone, VFS_MKDIR, mode, &answer);
327
	rc = ipc_data_write_start(vfs_phone, path, strlen(path));
328
	if (rc != EOK) {
329
		async_wait_for(req, NULL);
330
		async_serialize_end();
331
		futex_up(&vfs_phone_futex);
332
		return (int) rc;
333
	}
334
	async_wait_for(req, &rc);
335
	async_serialize_end();
336
	futex_up(&vfs_phone_futex);
337
	return EOK; 
2694 jermar 338
}
339
 
2671 jermar 340
/** @}
341
 */