source: mainline/uspace/srv/vfs/vfs_file.c@ e2ab36f1

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

Track client data by client task ID instead of client task hash.
  • Property mode set to 100644
File size: 10.1 KB
Line 
1/*
2 * Copyright (c) 2007 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_file.c
35 * @brief Various operations on files have their home in this file.
36 */
37
38#include <errno.h>
39#include <stdlib.h>
40#include <str.h>
41#include <assert.h>
42#include <bool.h>
43#include <fibril.h>
44#include <fibril_synch.h>
45#include <adt/list.h>
46#include <task.h>
47#include "vfs.h"
48
49#define VFS_DATA ((vfs_client_data_t *) async_get_client_data())
50#define FILES (VFS_DATA->files)
51
52typedef struct {
53 fibril_mutex_t lock;
54 fibril_condvar_t cv;
55 list_t passed_handles;
56 vfs_file_t **files;
57} vfs_client_data_t;
58
59typedef struct {
60 link_t link;
61 int handle;
62} vfs_boxed_handle_t;
63
64static int _vfs_fd_free(vfs_client_data_t *, int);
65
66/** Initialize the table of open files. */
67static bool vfs_files_init(vfs_client_data_t *vfs_data)
68{
69 fibril_mutex_lock(&vfs_data->lock);
70 if (!vfs_data->files) {
71 vfs_data->files = malloc(MAX_OPEN_FILES * sizeof(vfs_file_t *));
72 if (!vfs_data->files) {
73 fibril_mutex_unlock(&vfs_data->lock);
74 return false;
75 }
76 memset(vfs_data->files, 0, MAX_OPEN_FILES * sizeof(vfs_file_t *));
77 }
78 fibril_mutex_unlock(&vfs_data->lock);
79 return true;
80}
81
82/** Cleanup the table of open files. */
83static void vfs_files_done(vfs_client_data_t *vfs_data)
84{
85 int i;
86
87 if (!vfs_data->files)
88 return;
89
90 for (i = 0; i < MAX_OPEN_FILES; i++) {
91 if (vfs_data->files[i])
92 (void) _vfs_fd_free(vfs_data, i);
93 }
94
95 free(vfs_data->files);
96
97 while (!list_empty(&vfs_data->passed_handles)) {
98 link_t *lnk;
99 vfs_boxed_handle_t *bh;
100
101 lnk = list_first(&vfs_data->passed_handles);
102 list_remove(lnk);
103
104 bh = list_get_instance(lnk, vfs_boxed_handle_t, link);
105 free(bh);
106 }
107}
108
109void *vfs_client_data_create(void)
110{
111 vfs_client_data_t *vfs_data;
112
113 vfs_data = malloc(sizeof(vfs_client_data_t));
114 if (vfs_data) {
115 fibril_mutex_initialize(&vfs_data->lock);
116 fibril_condvar_initialize(&vfs_data->cv);
117 list_initialize(&vfs_data->passed_handles);
118 vfs_data->files = NULL;
119 }
120
121 return vfs_data;
122}
123
124void vfs_client_data_destroy(void *data)
125{
126 vfs_client_data_t *vfs_data = (vfs_client_data_t *) data;
127
128 vfs_files_done(vfs_data);
129 free(vfs_data);
130}
131
132/** Close the file in the endpoint FS server. */
133static int vfs_file_close_remote(vfs_file_t *file)
134{
135 assert(!file->refcnt);
136
137 async_exch_t *exch = vfs_exchange_grab(file->node->fs_handle);
138
139 ipc_call_t answer;
140 aid_t msg = async_send_2(exch, VFS_OUT_CLOSE, file->node->service_id,
141 file->node->index, &answer);
142
143 vfs_exchange_release(exch);
144
145 sysarg_t rc;
146 async_wait_for(msg, &rc);
147
148 return IPC_GET_ARG1(answer);
149}
150
151/** Increment reference count of VFS file structure.
152 *
153 * @param file File structure that will have reference count
154 * incremented.
155 */
156static void vfs_file_addref(vfs_client_data_t *vfs_data, vfs_file_t *file)
157{
158 assert(fibril_mutex_is_locked(&vfs_data->lock));
159
160 file->refcnt++;
161}
162
163/** Decrement reference count of VFS file structure.
164 *
165 * @param file File structure that will have reference count
166 * decremented.
167 */
168static int vfs_file_delref(vfs_client_data_t *vfs_data, vfs_file_t *file)
169{
170 int rc = EOK;
171
172 assert(fibril_mutex_is_locked(&vfs_data->lock));
173
174 if (file->refcnt-- == 1) {
175 /*
176 * Lost the last reference to a file, need to close it in the
177 * endpoint FS and drop our reference to the underlying VFS node.
178 */
179 rc = vfs_file_close_remote(file);
180 vfs_node_delref(file->node);
181 free(file);
182 }
183
184 return rc;
185}
186
187static int _vfs_fd_alloc(vfs_client_data_t *vfs_data, bool desc)
188{
189 if (!vfs_files_init(vfs_data))
190 return ENOMEM;
191
192 unsigned int i;
193 if (desc)
194 i = MAX_OPEN_FILES - 1;
195 else
196 i = 0;
197
198 fibril_mutex_lock(&vfs_data->lock);
199 while (true) {
200 if (!vfs_data->files[i]) {
201 vfs_data->files[i] = (vfs_file_t *) malloc(sizeof(vfs_file_t));
202 if (!vfs_data->files[i]) {
203 fibril_mutex_unlock(&vfs_data->lock);
204 return ENOMEM;
205 }
206
207 memset(vfs_data->files[i], 0, sizeof(vfs_file_t));
208 fibril_mutex_initialize(&vfs_data->files[i]->lock);
209 vfs_file_addref(vfs_data, vfs_data->files[i]);
210 fibril_mutex_unlock(&vfs_data->lock);
211 return (int) i;
212 }
213
214 if (desc) {
215 if (i == 0)
216 break;
217
218 i--;
219 } else {
220 if (i == MAX_OPEN_FILES - 1)
221 break;
222
223 i++;
224 }
225 }
226 fibril_mutex_unlock(&vfs_data->lock);
227
228 return EMFILE;
229}
230
231/** Allocate a file descriptor.
232 *
233 * @param desc If true, look for an available file descriptor
234 * in a descending order.
235 *
236 * @return First available file descriptor or a negative error
237 * code.
238 */
239int vfs_fd_alloc(bool desc)
240{
241 return _vfs_fd_alloc(VFS_DATA, desc);
242}
243
244static int _vfs_fd_free(vfs_client_data_t *vfs_data, int fd)
245{
246 int rc;
247
248 if (!vfs_files_init(vfs_data))
249 return ENOMEM;
250
251 fibril_mutex_lock(&vfs_data->lock);
252 if ((fd < 0) || (fd >= MAX_OPEN_FILES) || !vfs_data->files[fd]) {
253 fibril_mutex_unlock(&vfs_data->lock);
254 return EBADF;
255 }
256
257 rc = vfs_file_delref(vfs_data, vfs_data->files[fd]);
258 vfs_data->files[fd] = NULL;
259 fibril_mutex_unlock(&vfs_data->lock);
260
261 return rc;
262}
263
264/** Release file descriptor.
265 *
266 * @param fd File descriptor being released.
267 *
268 * @return EOK on success or EBADF if fd is an invalid file
269 * descriptor.
270 */
271int vfs_fd_free(int fd)
272{
273 return _vfs_fd_free(VFS_DATA, fd);
274}
275
276/** Assign a file to a file descriptor.
277 *
278 * @param file File to assign.
279 * @param fd File descriptor to assign to.
280 *
281 * @return EOK on success or EINVAL if fd is an invalid or already
282 * used file descriptor.
283 *
284 */
285int vfs_fd_assign(vfs_file_t *file, int fd)
286{
287 if (!vfs_files_init(VFS_DATA))
288 return ENOMEM;
289
290 fibril_mutex_lock(&VFS_DATA->lock);
291 if ((fd < 0) || (fd >= MAX_OPEN_FILES) || (FILES[fd] != NULL)) {
292 fibril_mutex_unlock(&VFS_DATA->lock);
293 return EINVAL;
294 }
295
296 FILES[fd] = file;
297 vfs_file_addref(VFS_DATA, FILES[fd]);
298 fibril_mutex_unlock(&VFS_DATA->lock);
299
300 return EOK;
301}
302
303static vfs_file_t *_vfs_file_get(vfs_client_data_t *vfs_data, int fd)
304{
305 if (!vfs_files_init(vfs_data))
306 return NULL;
307
308 fibril_mutex_lock(&vfs_data->lock);
309 if ((fd >= 0) && (fd < MAX_OPEN_FILES)) {
310 vfs_file_t *file = vfs_data->files[fd];
311 if (file != NULL) {
312 vfs_file_addref(vfs_data, file);
313 fibril_mutex_unlock(&vfs_data->lock);
314 return file;
315 }
316 }
317 fibril_mutex_unlock(&vfs_data->lock);
318
319 return NULL;
320}
321
322/** Find VFS file structure for a given file descriptor.
323 *
324 * @param fd File descriptor.
325 *
326 * @return VFS file structure corresponding to fd.
327 */
328vfs_file_t *vfs_file_get(int fd)
329{
330 return _vfs_file_get(VFS_DATA, fd);
331}
332
333static void _vfs_file_put(vfs_client_data_t *vfs_data, vfs_file_t *file)
334{
335 fibril_mutex_lock(&vfs_data->lock);
336 vfs_file_delref(vfs_data, file);
337 fibril_mutex_unlock(&vfs_data->lock);
338}
339
340/** Stop using a file structure.
341 *
342 * @param file VFS file structure.
343 */
344void vfs_file_put(vfs_file_t *file)
345{
346 _vfs_file_put(VFS_DATA, file);
347}
348
349void vfs_pass_handle(task_id_t donor_id, task_id_t acceptor_id, int donor_fd)
350{
351 vfs_client_data_t *donor_data = NULL;
352 vfs_client_data_t *acceptor_data = NULL;
353 vfs_file_t *donor_file = NULL;
354 vfs_file_t *acceptor_file = NULL;
355 vfs_boxed_handle_t *bh;
356 int acceptor_fd;
357
358 acceptor_data = async_get_client_data_by_id(acceptor_id);
359 if (!acceptor_data)
360 return;
361
362 bh = malloc(sizeof(vfs_boxed_handle_t));
363 assert(bh);
364
365 link_initialize(&bh->link);
366 bh->handle = -1;
367
368 donor_data = async_get_client_data_by_id(donor_id);
369 if (!donor_data)
370 goto out;
371
372 donor_file = _vfs_file_get(donor_data, donor_fd);
373 if (!donor_file)
374 goto out;
375
376 acceptor_fd = _vfs_fd_alloc(acceptor_data, false);
377 if (acceptor_fd < 0)
378 goto out;
379
380 bh->handle = acceptor_fd;
381
382 /*
383 * Add a new reference to the underlying VFS node.
384 */
385 vfs_node_addref(donor_file->node);
386 (void) vfs_open_node_remote(donor_file->node);
387
388 acceptor_file = _vfs_file_get(acceptor_data, acceptor_fd);
389 assert(acceptor_file);
390
391 /*
392 * Inherit attributes from the donor.
393 */
394 acceptor_file->node = donor_file->node;
395 acceptor_file->append = donor_file->append;
396 acceptor_file->pos = donor_file->pos;
397
398out:
399 fibril_mutex_lock(&acceptor_data->lock);
400 list_append(&bh->link, &acceptor_data->passed_handles);
401 fibril_condvar_broadcast(&acceptor_data->cv);
402 fibril_mutex_unlock(&acceptor_data->lock);
403
404 if (donor_data)
405 async_put_client_data_by_id(donor_id);
406 if (acceptor_data)
407 async_put_client_data_by_id(acceptor_id);
408 if (donor_file)
409 _vfs_file_put(donor_data, donor_file);
410 if (acceptor_file)
411 _vfs_file_put(acceptor_data, acceptor_file);
412
413}
414
415int vfs_wait_handle_internal(void)
416{
417 vfs_client_data_t *vfs_data = VFS_DATA;
418 int fd;
419
420 fibril_mutex_lock(&vfs_data->lock);
421 while (list_empty(&vfs_data->passed_handles))
422 fibril_condvar_wait(&vfs_data->cv, &vfs_data->lock);
423 link_t *lnk = list_first(&vfs_data->passed_handles);
424 list_remove(lnk);
425 fibril_mutex_unlock(&vfs_data->lock);
426
427 vfs_boxed_handle_t *bh = list_get_instance(lnk, vfs_boxed_handle_t, link);
428 fd = bh->handle;
429 free(bh);
430
431 return fd;
432}
433
434/**
435 * @}
436 */
Note: See TracBrowser for help on using the repository browser.