source: mainline/uspace/srv/vfs/vfs_register.c@ 4979403

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

Allow more instances of the same FS to be used.
(Thanks to Maurizio Lombardi.)

  • Property mode set to 100644
File size: 8.6 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 fs
30 * @{
31 */
32
33/**
34 * @file vfs_register.c
35 * @brief
36 */
37
38#include <ipc/services.h>
39#include <async.h>
40#include <fibril.h>
41#include <fibril_synch.h>
42#include <errno.h>
43#include <stdio.h>
44#include <stdlib.h>
45#include <str.h>
46#include <ctype.h>
47#include <bool.h>
48#include <adt/list.h>
49#include <as.h>
50#include <assert.h>
51#include <atomic.h>
52#include "vfs.h"
53
54FIBRIL_CONDVAR_INITIALIZE(fs_list_cv);
55FIBRIL_MUTEX_INITIALIZE(fs_list_lock);
56LIST_INITIALIZE(fs_list);
57
58atomic_t fs_handle_next = {
59 .count = 1
60};
61
62/** Verify the VFS info structure.
63 *
64 * @param info Info structure to be verified.
65 *
66 * @return Non-zero if the info structure is sane, zero otherwise.
67 *
68 */
69static bool vfs_info_sane(vfs_info_t *info)
70{
71 int i;
72
73 /*
74 * Check if the name is non-empty and is composed solely of ASCII
75 * characters [a-z]+[a-z0-9_-]*.
76 */
77 if (!islower(info->name[0])) {
78 dprintf("The name doesn't start with a lowercase character.\n");
79 return false;
80 }
81
82 for (i = 1; i < FS_NAME_MAXLEN; i++) {
83 if (!(islower(info->name[i]) || isdigit(info->name[i])) &&
84 (info->name[i] != '-') && (info->name[i] != '_')) {
85 if (info->name[i] == '\0') {
86 break;
87 } else {
88 dprintf("The name contains illegal "
89 "characters.\n");
90 return false;
91 }
92 }
93 }
94
95 /*
96 * This check is not redundant. It ensures that the name is
97 * NULL-terminated, even if FS_NAME_MAXLEN characters are used.
98 */
99 if (info->name[i] != '\0') {
100 dprintf("The name is not properly NULL-terminated.\n");
101 return false;
102 }
103
104 return true;
105}
106
107/** VFS_REGISTER protocol function.
108 *
109 * @param rid Hash of the call with the request.
110 * @param request Call structure with the request.
111 *
112 */
113void vfs_register(ipc_callid_t rid, ipc_call_t *request)
114{
115 dprintf("Processing VFS_REGISTER request received from %p.\n",
116 request->in_phone_hash);
117
118 vfs_info_t *vfs_info;
119 int rc = async_data_write_accept((void **) &vfs_info, false,
120 sizeof(vfs_info_t), sizeof(vfs_info_t), 0, NULL);
121
122 if (rc != EOK) {
123 dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n",
124 rc);
125 async_answer_0(rid, rc);
126 return;
127 }
128
129 /*
130 * Allocate and initialize a buffer for the fs_info structure.
131 */
132 fs_info_t *fs_info = (fs_info_t *) malloc(sizeof(fs_info_t));
133 if (!fs_info) {
134 dprintf("Could not allocate memory for FS info.\n");
135 async_answer_0(rid, ENOMEM);
136 return;
137 }
138
139 link_initialize(&fs_info->fs_link);
140 fs_info->vfs_info = *vfs_info;
141 free(vfs_info);
142
143 dprintf("VFS info delivered.\n");
144
145 if (!vfs_info_sane(&fs_info->vfs_info)) {
146 free(fs_info);
147 async_answer_0(rid, EINVAL);
148 return;
149 }
150
151 fibril_mutex_lock(&fs_list_lock);
152
153 /*
154 * Check for duplicit registrations.
155 */
156 if (fs_name_to_handle(fs_info->vfs_info.instance,
157 fs_info->vfs_info.name, false)) {
158 /*
159 * We already register a fs like this.
160 */
161 dprintf("FS is already registered.\n");
162 fibril_mutex_unlock(&fs_list_lock);
163 free(fs_info);
164 async_answer_0(rid, EEXISTS);
165 return;
166 }
167
168 /*
169 * Add fs_info to the list of registered FS's.
170 */
171 dprintf("Inserting FS into the list of registered file systems.\n");
172 list_append(&fs_info->fs_link, &fs_list);
173
174 /*
175 * Now we want the client to send us the IPC_M_CONNECT_TO_ME call so
176 * that a callback connection is created and we have a phone through
177 * which to forward VFS requests to it.
178 */
179 fs_info->sess = async_callback_receive(EXCHANGE_PARALLEL);
180 if (!fs_info->sess) {
181 dprintf("Callback connection expected\n");
182 list_remove(&fs_info->fs_link);
183 fibril_mutex_unlock(&fs_list_lock);
184 free(fs_info);
185 async_answer_0(rid, EINVAL);
186 return;
187 }
188
189 dprintf("Callback connection to FS created.\n");
190
191 /*
192 * The client will want us to send him the address space area with PLB.
193 */
194
195 size_t size;
196 ipc_callid_t callid;
197 if (!async_share_in_receive(&callid, &size)) {
198 dprintf("Unexpected call, method = %d\n", IPC_GET_IMETHOD(call));
199 list_remove(&fs_info->fs_link);
200 fibril_mutex_unlock(&fs_list_lock);
201 async_hangup(fs_info->sess);
202 free(fs_info);
203 async_answer_0(callid, EINVAL);
204 async_answer_0(rid, EINVAL);
205 return;
206 }
207
208 /*
209 * We can only send the client address space area PLB_SIZE bytes long.
210 */
211 if (size != PLB_SIZE) {
212 dprintf("Client suggests wrong size of PFB, size = %d\n", size);
213 list_remove(&fs_info->fs_link);
214 fibril_mutex_unlock(&fs_list_lock);
215 async_hangup(fs_info->sess);
216 free(fs_info);
217 async_answer_0(callid, EINVAL);
218 async_answer_0(rid, EINVAL);
219 return;
220 }
221
222 /*
223 * Commit to read-only sharing the PLB with the client.
224 */
225 (void) async_share_in_finalize(callid, plb,
226 AS_AREA_READ | AS_AREA_CACHEABLE);
227
228 dprintf("Sharing PLB.\n");
229
230 /*
231 * That was it. The FS has been registered.
232 * In reply to the VFS_REGISTER request, we assign the client file
233 * system a global file system handle.
234 */
235 fs_info->fs_handle = (fs_handle_t) atomic_postinc(&fs_handle_next);
236 async_answer_1(rid, EOK, (sysarg_t) fs_info->fs_handle);
237
238 fibril_condvar_broadcast(&fs_list_cv);
239 fibril_mutex_unlock(&fs_list_lock);
240
241 dprintf("\"%.*s\" filesystem successfully registered, handle=%d.\n",
242 FS_NAME_MAXLEN, fs_info->vfs_info.name, fs_info->fs_handle);
243}
244
245/** Begin an exchange for a given file system handle
246 *
247 * @param handle File system handle.
248 *
249 * @return Exchange for a multi-call request.
250 * @return NULL if no such file exists.
251 *
252 */
253async_exch_t *vfs_exchange_grab(fs_handle_t handle)
254{
255 /*
256 * For now, we don't try to be very clever and very fast.
257 * We simply lookup the session in fs_list and
258 * begin an exchange.
259 */
260 fibril_mutex_lock(&fs_list_lock);
261
262 list_foreach(fs_list, cur) {
263 fs_info_t *fs = list_get_instance(cur, fs_info_t, fs_link);
264
265 if (fs->fs_handle == handle) {
266 fibril_mutex_unlock(&fs_list_lock);
267
268 assert(fs->sess);
269 async_exch_t *exch = async_exchange_begin(fs->sess);
270
271 assert(exch);
272 return exch;
273 }
274 }
275
276 fibril_mutex_unlock(&fs_list_lock);
277
278 return NULL;
279}
280
281/** End VFS server exchange.
282 *
283 * @param exch VFS server exchange.
284 *
285 */
286void vfs_exchange_release(async_exch_t *exch)
287{
288 async_exchange_end(exch);
289}
290
291/** Convert file system name to its handle.
292 *
293 * @param name File system name.
294 * @param lock If true, the function will lock and unlock the
295 * fs_list_lock.
296 *
297 * @return File system handle or zero if file system not found.
298 *
299 */
300fs_handle_t fs_name_to_handle(unsigned int instance, char *name, bool lock)
301{
302 int handle = 0;
303
304 if (lock)
305 fibril_mutex_lock(&fs_list_lock);
306
307 list_foreach(fs_list, cur) {
308 fs_info_t *fs = list_get_instance(cur, fs_info_t, fs_link);
309 if (str_cmp(fs->vfs_info.name, name) == 0 &&
310 instance == fs->vfs_info.instance) {
311 handle = fs->fs_handle;
312 break;
313 }
314 }
315
316 if (lock)
317 fibril_mutex_unlock(&fs_list_lock);
318
319 return handle;
320}
321
322/** Find the VFS info structure.
323 *
324 * @param handle FS handle for which the VFS info structure is sought.
325 *
326 * @return VFS info structure on success or NULL otherwise.
327 *
328 */
329vfs_info_t *fs_handle_to_info(fs_handle_t handle)
330{
331 vfs_info_t *info = NULL;
332
333 fibril_mutex_lock(&fs_list_lock);
334 list_foreach(fs_list, cur) {
335 fs_info_t *fs = list_get_instance(cur, fs_info_t, fs_link);
336 if (fs->fs_handle == handle) {
337 info = &fs->vfs_info;
338 break;
339 }
340 }
341 fibril_mutex_unlock(&fs_list_lock);
342
343 return info;
344}
345
346/**
347 * @}
348 */
Note: See TracBrowser for help on using the repository browser.