source: mainline/uspace/lib/libc/generic/vfs.c@ 6c441cf8

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 6c441cf8 was 07e01e6, checked in by Jakub Jermar <jakub@…>, 18 years ago

Prevent read() and write() from returning an uninitialized error return value.
  • Property mode set to 100644
File size: 8.1 KB
Line 
1/*
2 * Copyright (c) 2008 Jakub 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>
36#include <stdlib.h>
37#include <unistd.h>
38#include <dirent.h>
39#include <fcntl.h>
40#include <sys/stat.h>
41#include <sys/types.h>
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
51int vfs_phone = -1;
52atomic_t vfs_phone_futex = FUTEX_INITIALIZER;
53
54static 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
61int 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);
80 rc = ipc_data_write_start(vfs_phone, (void *)fs_name, strlen(fs_name));
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 }
87 rc = ipc_data_write_start(vfs_phone, (void *)mp, strlen(mp));
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
100static int _open(const char *path, int lflag, int oflag, ...)
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 }
117 req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);
118 rc = ipc_data_write_start(vfs_phone, path, strlen(path));
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
131int open(const char *path, int oflag, ...)
132{
133 return _open(path, L_FILE, oflag);
134}
135
136int close(int fildes)
137{
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;
158}
159
160ssize_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 }
177 req = async_send_1(vfs_phone, VFS_READ, fildes, &answer);
178 rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
179 if (rc != EOK) {
180 async_wait_for(req, NULL);
181 async_serialize_end();
182 futex_up(&vfs_phone_futex);
183 return (ssize_t) rc;
184 }
185 async_wait_for(req, &rc);
186 async_serialize_end();
187 futex_up(&vfs_phone_futex);
188 if (rc == EOK)
189 return (ssize_t) IPC_GET_ARG1(answer);
190 else
191 return -1;
192}
193
194ssize_t write(int fildes, const void *buf, size_t nbyte)
195{
196 int res;
197 ipcarg_t rc;
198 ipc_call_t answer;
199 aid_t req;
200
201 futex_down(&vfs_phone_futex);
202 async_serialize_start();
203 if (vfs_phone < 0) {
204 res = vfs_connect();
205 if (res < 0) {
206 async_serialize_end();
207 futex_up(&vfs_phone_futex);
208 return res;
209 }
210 }
211 req = async_send_1(vfs_phone, VFS_WRITE, fildes, &answer);
212 rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
213 if (rc != EOK) {
214 async_wait_for(req, NULL);
215 async_serialize_end();
216 futex_up(&vfs_phone_futex);
217 return (ssize_t) rc;
218 }
219 async_wait_for(req, &rc);
220 async_serialize_end();
221 futex_up(&vfs_phone_futex);
222 if (rc == EOK)
223 return (ssize_t) IPC_GET_ARG1(answer);
224 else
225 return -1;
226}
227
228off_t lseek(int fildes, off_t offset, int whence)
229{
230 int res;
231 ipcarg_t rc;
232
233 futex_down(&vfs_phone_futex);
234 async_serialize_start();
235 if (vfs_phone < 0) {
236 res = vfs_connect();
237 if (res < 0) {
238 async_serialize_end();
239 futex_up(&vfs_phone_futex);
240 return res;
241 }
242 }
243
244 off_t newoffs;
245 rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence,
246 (ipcarg_t)&newoffs);
247
248 async_serialize_end();
249 futex_up(&vfs_phone_futex);
250
251 if (rc != EOK)
252 return (off_t) -1;
253
254 return newoffs;
255}
256
257int ftruncate(int fildes, off_t length)
258{
259 int res;
260 ipcarg_t rc;
261
262 futex_down(&vfs_phone_futex);
263 async_serialize_start();
264 if (vfs_phone < 0) {
265 res = vfs_connect();
266 if (res < 0) {
267 async_serialize_end();
268 futex_up(&vfs_phone_futex);
269 return res;
270 }
271 }
272 rc = async_req_2_0(vfs_phone, VFS_TRUNCATE, fildes, length);
273 async_serialize_end();
274 futex_up(&vfs_phone_futex);
275 return (int) rc;
276}
277
278DIR *opendir(const char *dirname)
279{
280 DIR *dirp = malloc(sizeof(DIR));
281 if (!dirp)
282 return NULL;
283 dirp->fd = _open(dirname, L_DIRECTORY, 0);
284 if (dirp->fd < 0) {
285 free(dirp);
286 return NULL;
287 }
288 return dirp;
289}
290
291struct dirent *readdir(DIR *dirp)
292{
293 ssize_t len = read(dirp->fd, &dirp->res.d_name[0], NAME_MAX + 1);
294 if (len <= 0)
295 return NULL;
296 return &dirp->res;
297}
298
299void rewinddir(DIR *dirp)
300{
301 (void) lseek(dirp->fd, 0, SEEK_SET);
302}
303
304int closedir(DIR *dirp)
305{
306 (void) close(dirp->fd);
307 free(dirp);
308 return 0;
309}
310
311int mkdir(const char *path, mode_t mode)
312{
313 int res;
314 ipcarg_t rc;
315 aid_t req;
316
317 futex_down(&vfs_phone_futex);
318 async_serialize_start();
319 if (vfs_phone < 0) {
320 res = vfs_connect();
321 if (res < 0) {
322 async_serialize_end();
323 futex_up(&vfs_phone_futex);
324 return res;
325 }
326 }
327 req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL);
328 rc = ipc_data_write_start(vfs_phone, path, strlen(path));
329 if (rc != EOK) {
330 async_wait_for(req, NULL);
331 async_serialize_end();
332 futex_up(&vfs_phone_futex);
333 return (int) rc;
334 }
335 async_wait_for(req, &rc);
336 async_serialize_end();
337 futex_up(&vfs_phone_futex);
338 return EOK;
339}
340
341static int _unlink(const char *path, int lflag)
342{
343 int res;
344 ipcarg_t rc;
345 aid_t req;
346
347 futex_down(&vfs_phone_futex);
348 async_serialize_start();
349 if (vfs_phone < 0) {
350 res = vfs_connect();
351 if (res < 0) {
352 async_serialize_end();
353 futex_up(&vfs_phone_futex);
354 return res;
355 }
356 }
357 req = async_send_0(vfs_phone, VFS_UNLINK, NULL);
358 rc = ipc_data_write_start(vfs_phone, path, strlen(path));
359 if (rc != EOK) {
360 async_wait_for(req, NULL);
361 async_serialize_end();
362 futex_up(&vfs_phone_futex);
363 return (int) rc;
364 }
365 async_wait_for(req, &rc);
366 async_serialize_end();
367 futex_up(&vfs_phone_futex);
368 return EOK;
369}
370
371int unlink(const char *path)
372{
373 return _unlink(path, L_NONE);
374}
375
376int rmdir(const char *path)
377{
378 return _unlink(path, L_DIRECTORY);
379}
380
381/** @}
382 */
Note: See TracBrowser for help on using the repository browser.