Subversion Repositories HelenOS

Rev

Rev 2684 | Rev 2694 | 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>
2674 jermar 36
#include <unistd.h>
37
#include <fcntl.h>
2671 jermar 38
#include <ipc/ipc.h>
39
#include <ipc/services.h>
40
#include <async.h>
41
#include <atomic.h>
42
#include <futex.h>
43
#include <errno.h>
44
#include <string.h>
45
#include "../../srv/vfs/vfs.h"
46
 
47
int vfs_phone = -1;
48
atomic_t vfs_phone_futex = FUTEX_INITIALIZER;
49
 
50
static int vfs_connect(void)
51
{
52
    if (vfs_phone < 0)
53
        vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
54
    return vfs_phone;
55
}
56
 
57
int mount(const char *fs_name, const char *mp, const char *dev)
58
{
59
    int res;
60
    ipcarg_t rc;
61
    aid_t req;
62
 
63
    int dev_handle = 0; /* TODO */
64
 
65
    futex_down(&vfs_phone_futex);
66
    async_serialize_start();
67
    if (vfs_phone < 0) {
68
        res = vfs_connect();
69
        if (res < 0) {
70
            async_serialize_end();
71
            futex_up(&vfs_phone_futex);
72
            return res;
73
        }
74
    }
75
    req = async_send_1(vfs_phone, VFS_MOUNT, dev_handle, NULL);
2678 jermar 76
    rc = ipc_data_write_start(vfs_phone, (void *)fs_name, strlen(fs_name));
2671 jermar 77
    if (rc != EOK) {
78
        async_wait_for(req, NULL);
79
        async_serialize_end();
80
        futex_up(&vfs_phone_futex);
81
        return (int) rc;
82
    }
2678 jermar 83
    rc = ipc_data_write_start(vfs_phone, (void *)mp, strlen(mp));
2671 jermar 84
    if (rc != EOK) {
85
        async_wait_for(req, NULL);
86
        async_serialize_end();
87
        futex_up(&vfs_phone_futex);
88
        return (int) rc;
89
    }
90
    async_wait_for(req, &rc);
91
    async_serialize_end();
92
    futex_up(&vfs_phone_futex);
93
    return (int) rc;
94
}
95
 
96
 
2693 jermar 97
int open(const char *path, int oflag, ...)
2671 jermar 98
{
99
    int res;
100
    ipcarg_t rc;
101
    ipc_call_t answer;
102
    aid_t req;
103
 
104
    futex_down(&vfs_phone_futex);
105
    async_serialize_start();
106
    if (vfs_phone < 0) {
107
        res = vfs_connect();
108
        if (res < 0) {
109
            async_serialize_end();
110
            futex_up(&vfs_phone_futex);
111
            return res;
112
        }
113
    }
114
    req = async_send_2(vfs_phone, VFS_OPEN, oflag, 0, &answer);
2693 jermar 115
    rc = ipc_data_write_start(vfs_phone, path, strlen(path));
2671 jermar 116
    if (rc != EOK) {
117
        async_wait_for(req, NULL);
118
        async_serialize_end();
119
        futex_up(&vfs_phone_futex);
120
        return (int) rc;
121
    }
122
    async_wait_for(req, &rc);
123
    async_serialize_end();
124
    futex_up(&vfs_phone_futex);
125
    return (int) IPC_GET_ARG1(answer);
126
}
127
 
128
ssize_t read(int fildes, void *buf, size_t nbyte)
129
{
130
    int res;
131
    ipcarg_t rc;
132
    ipc_call_t answer;
133
    aid_t req;
134
 
135
    futex_down(&vfs_phone_futex);
136
    async_serialize_start();
137
    if (vfs_phone < 0) {
138
        res = vfs_connect();
139
        if (res < 0) {
140
            async_serialize_end();
141
            futex_up(&vfs_phone_futex);
142
            return res;
143
        }
144
    }
2674 jermar 145
    req = async_send_1(vfs_phone, VFS_READ, fildes, &answer);
2678 jermar 146
    if (ipc_data_read_start(vfs_phone, (void *)buf, nbyte) != EOK) {
2671 jermar 147
        async_wait_for(req, NULL);
148
        async_serialize_end();
149
        futex_up(&vfs_phone_futex);
150
        return (ssize_t) rc;
151
    }
152
    async_wait_for(req, &rc);
153
    async_serialize_end();
154
    futex_up(&vfs_phone_futex);
155
    return (ssize_t) IPC_GET_ARG1(answer);
156
}
157
 
2674 jermar 158
ssize_t write(int fildes, const void *buf, size_t nbyte)
159
{
160
    int res;
161
    ipcarg_t rc;
162
    ipc_call_t answer;
163
    aid_t req;
164
 
165
    futex_down(&vfs_phone_futex);
166
    async_serialize_start();
167
    if (vfs_phone < 0) {
168
        res = vfs_connect();
169
        if (res < 0) {
170
            async_serialize_end();
171
            futex_up(&vfs_phone_futex);
172
            return res;
173
        }
174
    }
175
    req = async_send_1(vfs_phone, VFS_WRITE, fildes, &answer);
2678 jermar 176
    if (ipc_data_write_start(vfs_phone, (void *)buf, nbyte) != EOK) {
2674 jermar 177
        async_wait_for(req, NULL);
178
        async_serialize_end();
179
        futex_up(&vfs_phone_futex);
180
        return (ssize_t) rc;
181
    }
182
    async_wait_for(req, &rc);
183
    async_serialize_end();
184
    futex_up(&vfs_phone_futex);
185
    return (ssize_t) IPC_GET_ARG1(answer);
186
}
2684 jermar 187
 
188
off_t lseek(int fildes, off_t offset, int whence)
189
{
190
    int res;
191
    ipcarg_t rc;
192
 
193
    futex_down(&vfs_phone_futex);
194
    async_serialize_start();
195
    if (vfs_phone < 0) {
196
        res = vfs_connect();
197
        if (res < 0) {
198
            async_serialize_end();
199
            futex_up(&vfs_phone_futex);
200
            return res;
201
        }
202
    }
203
 
204
    off_t newoffs;
205
    rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence,
206
        &newoffs);
207
 
208
    async_serialize_end();
209
    futex_up(&vfs_phone_futex);
210
 
211
    if (rc != EOK)
212
        return (off_t) -1;
213
 
214
    return newoffs;
215
}
216
 
2693 jermar 217
int ftruncate(int fildes, off_t length)
218
{
219
    int res;
220
    ipcarg_t rc;
221
 
222
    futex_down(&vfs_phone_futex);
223
    async_serialize_start();
224
    if (vfs_phone < 0) {
225
        res = vfs_connect();
226
        if (res < 0) {
227
            async_serialize_end();
228
            futex_up(&vfs_phone_futex);
229
            return res;
230
        }
231
    }
232
    rc = async_req_2_0(vfs_phone, VFS_TRUNCATE, fildes, length);
233
    async_serialize_end();
234
    futex_up(&vfs_phone_futex);
235
    return (int) rc;
236
}
237
 
2671 jermar 238
/** @}
239
 */