source: mainline/uspace/srv/fs/tmpfs/tmpfs_ops.c@ 8ccd2ea

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

Descend vs. descent.
  • Property mode set to 100644
File size: 11.7 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 tmpfs_ops.c
35 * @brief Implementation of VFS operations for the TMPFS file system
36 * server.
37 */
38
39#include "tmpfs.h"
40#include "../../vfs/vfs.h"
41#include <ipc/ipc.h>
42#include <async.h>
43#include <errno.h>
44#include <atomic.h>
45#include <stdlib.h>
46#include <string.h>
47#include <stdio.h>
48#include <dirent.h>
49#include <assert.h>
50#include <sys/types.h>
51#include <libadt/hash_table.h>
52#include <as.h>
53
54#define min(a, b) ((a) < (b) ? (a) : (b))
55#define max(a, b) ((a) > (b) ? (a) : (b))
56
57#define PLB_GET_CHAR(i) (tmpfs_reg.plb_ro[(i) % PLB_SIZE])
58
59#define DENTRIES_BUCKETS 256
60
61/*
62 * Hash table of all directory entries.
63 */
64hash_table_t dentries;
65
66static hash_index_t dentries_hash(unsigned long *key)
67{
68 return *key % DENTRIES_BUCKETS;
69}
70
71static int dentries_compare(unsigned long *key, hash_count_t keys,
72 link_t *item)
73{
74 tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t,
75 dh_link);
76 return dentry->index == *key;
77}
78
79static void dentries_remove_callback(link_t *item)
80{
81}
82
83/** TMPFS dentries hash table operations. */
84hash_table_operations_t dentries_ops = {
85 .hash = dentries_hash,
86 .compare = dentries_compare,
87 .remove_callback = dentries_remove_callback
88};
89
90unsigned tmpfs_next_index = 1;
91
92static void tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)
93{
94 dentry->index = 0;
95 dentry->parent = NULL;
96 dentry->sibling = NULL;
97 dentry->child = NULL;
98 dentry->name = NULL;
99 dentry->type = TMPFS_NONE;
100 dentry->size = 0;
101 dentry->data = NULL;
102 link_initialize(&dentry->dh_link);
103}
104
105/*
106 * For now, we don't distinguish between different dev_handles/instances. All
107 * requests resolve to the only instance, rooted in the following variable.
108 */
109static tmpfs_dentry_t *root;
110
111static bool tmpfs_init(void)
112{
113 if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops))
114 return false;
115
116 root = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
117 if (!root)
118 return false;
119 tmpfs_dentry_initialize(root);
120 root->index = tmpfs_next_index++;
121 root->name = "";
122 root->type = TMPFS_DIRECTORY;
123 hash_table_insert(&dentries, &root->index, &root->dh_link);
124
125 return true;
126}
127
128/** Compare one component of path to a directory entry.
129 *
130 * @param dentry Directory entry to compare the path component with.
131 * @param component Array of characters holding component name.
132 *
133 * @return True on match, false otherwise.
134 */
135static bool match_component(tmpfs_dentry_t *dentry, const char *component)
136{
137 return !strcmp(dentry->name, component);
138}
139
140static unsigned long create_node(tmpfs_dentry_t *dentry,
141 const char *component, int lflag)
142{
143 assert(dentry->type == TMPFS_DIRECTORY);
144 assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
145
146 tmpfs_dentry_t *node = malloc(sizeof(tmpfs_dentry_t));
147 if (!node)
148 return 0;
149 size_t len = strlen(component);
150 char *name = malloc(len + 1);
151 if (!name) {
152 free(node);
153 return 0;
154 }
155 strcpy(name, component);
156
157 tmpfs_dentry_initialize(node);
158 node->index = tmpfs_next_index++;
159 node->name = name;
160 node->parent = dentry;
161 if (lflag & L_DIRECTORY)
162 node->type = TMPFS_DIRECTORY;
163 else
164 node->type = TMPFS_FILE;
165
166 /* Insert the new node into the namespace. */
167 if (dentry->child) {
168 tmpfs_dentry_t *tmp = dentry->child;
169 while (tmp->sibling)
170 tmp = tmp->sibling;
171 tmp->sibling = node;
172 } else {
173 dentry->child = node;
174 }
175
176 /* Insert the new node into the dentry hash table. */
177 hash_table_insert(&dentries, &node->index, &node->dh_link);
178 return node->index;
179}
180
181static int destroy_component(tmpfs_dentry_t *dentry)
182{
183 return EPERM;
184}
185
186void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)
187{
188 unsigned next = IPC_GET_ARG1(*request);
189 unsigned last = IPC_GET_ARG2(*request);
190 int dev_handle = IPC_GET_ARG3(*request);
191 int lflag = IPC_GET_ARG4(*request);
192
193 if (last < next)
194 last += PLB_SIZE;
195
196 /*
197 * Initialize TMPFS.
198 */
199 if (!root && !tmpfs_init()) {
200 ipc_answer_0(rid, ENOMEM);
201 return;
202 }
203
204 tmpfs_dentry_t *dtmp = root->child;
205 tmpfs_dentry_t *dcur = root;
206
207 if (PLB_GET_CHAR(next) == '/')
208 next++; /* eat slash */
209
210 char component[NAME_MAX + 1];
211 int len = 0;
212 while (dtmp && next <= last) {
213
214 /* collect the component */
215 if (PLB_GET_CHAR(next) != '/') {
216 if (len + 1 == NAME_MAX) {
217 /* comopnent length overflow */
218 ipc_answer_0(rid, ENAMETOOLONG);
219 return;
220 }
221 component[len++] = PLB_GET_CHAR(next);
222 next++; /* process next character */
223 if (next <= last)
224 continue;
225 }
226
227 assert(len);
228 component[len] = '\0';
229 next++; /* eat slash */
230 len = 0;
231
232 /* match the component */
233 while (dtmp && !match_component(dtmp, component))
234 dtmp = dtmp->sibling;
235
236 /* handle miss: match amongst siblings */
237 if (!dtmp) {
238 if ((next > last) && (lflag & L_CREATE)) {
239 /* no components left and L_CREATE specified */
240 if (dcur->type != TMPFS_DIRECTORY) {
241 ipc_answer_0(rid, ENOTDIR);
242 return;
243 }
244 unsigned long index = create_node(dcur,
245 component, lflag);
246 if (index > 0) {
247 ipc_answer_4(rid, EOK,
248 tmpfs_reg.fs_handle, dev_handle,
249 index, 0);
250 } else {
251 ipc_answer_0(rid, ENOSPC);
252 }
253 return;
254 }
255 ipc_answer_0(rid, ENOENT);
256 return;
257 }
258
259 /* descend one level */
260 dcur = dtmp;
261 dtmp = dtmp->child;
262 }
263
264 /* handle miss: excessive components */
265 if (!dtmp && next <= last) {
266 if (lflag & L_CREATE) {
267 if (dcur->type != TMPFS_DIRECTORY) {
268 ipc_answer_0(rid, ENOTDIR);
269 return;
270 }
271
272 /* collect next component */
273 while (next <= last) {
274 if (PLB_GET_CHAR(next) == '/') {
275 /* more than one component */
276 ipc_answer_0(rid, ENOENT);
277 return;
278 }
279 if (len + 1 == NAME_MAX) {
280 /* component length overflow */
281 ipc_answer_0(rid, ENAMETOOLONG);
282 return;
283 }
284 component[len++] = PLB_GET_CHAR(next);
285 next++; /* process next character */
286 }
287 assert(len);
288 component[len] = '\0';
289 len = 0;
290
291 unsigned long index;
292 index = create_node(dcur, component, lflag);
293 if (index) {
294 ipc_answer_4(rid, EOK, tmpfs_reg.fs_handle,
295 dev_handle, index, 0);
296 } else {
297 ipc_answer_0(rid, ENOSPC);
298 }
299 return;
300 }
301 ipc_answer_0(rid, ENOENT);
302 return;
303 }
304
305 /* handle hit */
306 if (lflag & L_DESTROY) {
307 int res = destroy_component(dcur);
308 ipc_answer_0(rid, res);
309 return;
310 }
311 if ((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) {
312 ipc_answer_0(rid, EEXIST);
313 return;
314 }
315 if ((lflag & L_FILE) && (dcur->type != TMPFS_FILE)) {
316 ipc_answer_0(rid, EISDIR);
317 return;
318 }
319 if ((lflag & L_DIRECTORY) && (dcur->type != TMPFS_DIRECTORY)) {
320 ipc_answer_0(rid, ENOTDIR);
321 return;
322 }
323
324 ipc_answer_4(rid, EOK, tmpfs_reg.fs_handle, dev_handle, dcur->index,
325 dcur->size);
326}
327
328void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)
329{
330 int dev_handle = IPC_GET_ARG1(*request);
331 unsigned long index = IPC_GET_ARG2(*request);
332 off_t pos = IPC_GET_ARG3(*request);
333
334 /*
335 * Lookup the respective dentry.
336 */
337 link_t *hlp;
338 hlp = hash_table_find(&dentries, &index);
339 if (!hlp) {
340 ipc_answer_0(rid, ENOENT);
341 return;
342 }
343 tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
344 dh_link);
345
346 /*
347 * Receive the read request.
348 */
349 ipc_callid_t callid;
350 size_t len;
351 if (!ipc_data_read_receive(&callid, &len)) {
352 ipc_answer_0(callid, EINVAL);
353 ipc_answer_0(rid, EINVAL);
354 return;
355 }
356
357 size_t bytes;
358 if (dentry->type == TMPFS_FILE) {
359 bytes = max(0, min(dentry->size - pos, len));
360 (void) ipc_data_read_finalize(callid, dentry->data + pos,
361 bytes);
362 } else {
363 int i;
364 tmpfs_dentry_t *cur = dentry->child;
365
366 assert(dentry->type == TMPFS_DIRECTORY);
367
368 /*
369 * Yes, we really use O(n) algorithm here.
370 * If it bothers someone, it could be fixed by introducing a
371 * hash table.
372 */
373 for (i = 0, cur = dentry->child; i < pos && cur; i++,
374 cur = cur->sibling)
375 ;
376
377 if (!cur) {
378 ipc_answer_0(callid, ENOENT);
379 ipc_answer_1(rid, ENOENT, 0);
380 return;
381 }
382
383 (void) ipc_data_read_finalize(callid, cur->name,
384 strlen(cur->name) + 1);
385 bytes = 1;
386 }
387
388 /*
389 * Answer the VFS_READ call.
390 */
391 ipc_answer_1(rid, EOK, bytes);
392}
393
394void tmpfs_write(ipc_callid_t rid, ipc_call_t *request)
395{
396 int dev_handle = IPC_GET_ARG1(*request);
397 unsigned long index = IPC_GET_ARG2(*request);
398 off_t pos = IPC_GET_ARG3(*request);
399
400 /*
401 * Lookup the respective dentry.
402 */
403 link_t *hlp;
404 hlp = hash_table_find(&dentries, &index);
405 if (!hlp) {
406 ipc_answer_0(rid, ENOENT);
407 return;
408 }
409 tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
410 dh_link);
411
412 /*
413 * Receive the write request.
414 */
415 ipc_callid_t callid;
416 size_t len;
417 if (!ipc_data_write_receive(&callid, &len)) {
418 ipc_answer_0(callid, EINVAL);
419 ipc_answer_0(rid, EINVAL);
420 return;
421 }
422
423 /*
424 * Check whether the file needs to grow.
425 */
426 if (pos + len <= dentry->size) {
427 /* The file size is not changing. */
428 (void) ipc_data_write_finalize(callid, dentry->data + pos, len);
429 ipc_answer_2(rid, EOK, len, dentry->size);
430 return;
431 }
432 size_t delta = (pos + len) - dentry->size;
433 /*
434 * At this point, we are deliberately extremely straightforward and
435 * simply realloc the contents of the file on every write that grows the
436 * file. In the end, the situation might not be as bad as it may look:
437 * our heap allocator can save us and just grow the block whenever
438 * possible.
439 */
440 void *newdata = realloc(dentry->data, dentry->size + delta);
441 if (!newdata) {
442 ipc_answer_0(callid, ENOMEM);
443 ipc_answer_2(rid, EOK, 0, dentry->size);
444 return;
445 }
446 /* Clear any newly allocated memory in order to emulate gaps. */
447 memset(newdata + dentry->size, 0, delta);
448 dentry->size += delta;
449 dentry->data = newdata;
450 (void) ipc_data_write_finalize(callid, dentry->data + pos, len);
451 ipc_answer_2(rid, EOK, len, dentry->size);
452}
453
454void tmpfs_truncate(ipc_callid_t rid, ipc_call_t *request)
455{
456 int dev_handle = IPC_GET_ARG1(*request);
457 unsigned long index = IPC_GET_ARG2(*request);
458 size_t size = IPC_GET_ARG3(*request);
459
460 /*
461 * Lookup the respective dentry.
462 */
463 link_t *hlp;
464 hlp = hash_table_find(&dentries, &index);
465 if (!hlp) {
466 ipc_answer_0(rid, ENOENT);
467 return;
468 }
469 tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
470 dh_link);
471
472 if (size == dentry->size) {
473 ipc_answer_0(rid, EOK);
474 return;
475 }
476
477 void *newdata = realloc(dentry->data, size);
478 if (!newdata) {
479 ipc_answer_0(rid, ENOMEM);
480 return;
481 }
482 if (size > dentry->size) {
483 size_t delta = size - dentry->size;
484 memset(newdata + dentry->size, 0, delta);
485 }
486 dentry->size = size;
487 dentry->data = newdata;
488 ipc_answer_0(rid, EOK);
489}
490
491/**
492 * @}
493 */
Note: See TracBrowser for help on using the repository browser.