Rev 2742 | Rev 2756 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 2742 | Rev 2747 | ||
---|---|---|---|
1 | /* |
1 | /* |
2 | * Copyright (c) 2008 Jakub Jermar |
2 | * Copyright (c) 2008 Jakub Jermar |
3 | * All rights reserved. |
3 | * All rights reserved. |
4 | * |
4 | * |
5 | * Redistribution and use in source and binary forms, with or without |
5 | * Redistribution and use in source and binary forms, with or without |
6 | * modification, are permitted provided that the following conditions |
6 | * modification, are permitted provided that the following conditions |
7 | * are met: |
7 | * are met: |
8 | * |
8 | * |
9 | * - Redistributions of source code must retain the above copyright |
9 | * - Redistributions of source code must retain the above copyright |
10 | * notice, this list of conditions and the following disclaimer. |
10 | * notice, this list of conditions and the following disclaimer. |
11 | * - Redistributions in binary form must reproduce the above copyright |
11 | * - Redistributions in binary form must reproduce the above copyright |
12 | * notice, this list of conditions and the following disclaimer in the |
12 | * notice, this list of conditions and the following disclaimer in the |
13 | * documentation and/or other materials provided with the distribution. |
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 |
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. |
15 | * derived from this software without specific prior written permission. |
16 | * |
16 | * |
17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
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 |
18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
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 |
23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
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 |
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. |
26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
27 | */ |
27 | */ |
28 | 28 | ||
29 | /** @addtogroup fs |
29 | /** @addtogroup fs |
30 | * @{ |
30 | * @{ |
31 | */ |
31 | */ |
32 | 32 | ||
33 | /** |
33 | /** |
34 | * @file tmpfs_ops.c |
34 | * @file tmpfs_ops.c |
35 | * @brief Implementation of VFS operations for the TMPFS file system |
35 | * @brief Implementation of VFS operations for the TMPFS file system |
36 | * server. |
36 | * server. |
37 | */ |
37 | */ |
38 | 38 | ||
39 | #include "tmpfs.h" |
39 | #include "tmpfs.h" |
40 | #include "../../vfs/vfs.h" |
40 | #include "../../vfs/vfs.h" |
41 | #include <ipc/ipc.h> |
41 | #include <ipc/ipc.h> |
42 | #include <async.h> |
42 | #include <async.h> |
43 | #include <errno.h> |
43 | #include <errno.h> |
44 | #include <atomic.h> |
44 | #include <atomic.h> |
45 | #include <stdlib.h> |
45 | #include <stdlib.h> |
46 | #include <string.h> |
46 | #include <string.h> |
47 | #include <stdio.h> |
47 | #include <stdio.h> |
48 | #include <dirent.h> |
- | |
49 | #include <assert.h> |
48 | #include <assert.h> |
50 | #include <sys/types.h> |
49 | #include <sys/types.h> |
51 | #include <libadt/hash_table.h> |
50 | #include <libadt/hash_table.h> |
52 | #include <as.h> |
51 | #include <as.h> |
- | 52 | #include <libfs.h> |
|
53 | 53 | ||
54 | #define min(a, b) ((a) < (b) ? (a) : (b)) |
54 | #define min(a, b) ((a) < (b) ? (a) : (b)) |
55 | #define max(a, b) ((a) > (b) ? (a) : (b)) |
55 | #define max(a, b) ((a) > (b) ? (a) : (b)) |
56 | 56 | ||
57 | #define PLB_GET_CHAR(i) (tmpfs_reg.plb_ro[(i) % PLB_SIZE]) |
- | |
58 | - | ||
59 | #define DENTRIES_BUCKETS 256 |
57 | #define DENTRIES_BUCKETS 256 |
60 | 58 | ||
- | 59 | /* |
|
61 | #define TMPFS_GET_INDEX(x) (((tmpfs_dentry_t *)(x))->index) |
60 | * For now, we don't distinguish between different dev_handles/instances. All |
- | 61 | * requests resolve to the only instance, rooted in the following variable. |
|
- | 62 | */ |
|
62 | #define TMPFS_GET_LNKCNT(x) 1 |
63 | static tmpfs_dentry_t *root; |
- | 64 | ||
- | 65 | /* |
|
- | 66 | * Implementation of the libfs interface. |
|
- | 67 | */ |
|
63 | 68 | ||
64 | /* Forward declarations of static functions. */ |
69 | /* Forward declarations of static functions. */ |
- | 70 | static bool tmpfs_match(void *, const char *); |
|
65 | static void *create_node(int); |
71 | static void *tmpfs_create_node(int); |
66 | static bool link_node(void *, void *, const char *); |
72 | static bool tmpfs_link_node(void *, void *, const char *); |
67 | static int unlink_node(void *); |
73 | static int tmpfs_unlink_node(void *); |
68 | static void destroy_node(void *); |
74 | static void tmpfs_destroy_node(void *); |
- | 75 | ||
- | 76 | /* Implementation of helper functions. */ |
|
- | 77 | static unsigned long tmpfs_index_get(void *nodep) |
|
- | 78 | { |
|
- | 79 | return ((tmpfs_dentry_t *) nodep)->index; |
|
- | 80 | } |
|
- | 81 | ||
- | 82 | static unsigned long tmpfs_size_get(void *nodep) |
|
- | 83 | { |
|
- | 84 | return ((tmpfs_dentry_t *) nodep)->size; |
|
- | 85 | } |
|
- | 86 | ||
- | 87 | static unsigned tmpfs_lnkcnt_get(void *nodep) |
|
- | 88 | { |
|
- | 89 | return 1; |
|
- | 90 | } |
|
- | 91 | ||
- | 92 | static void *tmpfs_child_get(void *nodep) |
|
- | 93 | { |
|
- | 94 | return ((tmpfs_dentry_t *) nodep)->child; |
|
- | 95 | } |
|
- | 96 | ||
- | 97 | static void *tmpfs_sibling_get(void *nodep) |
|
- | 98 | { |
|
- | 99 | return ((tmpfs_dentry_t *) nodep)->sibling; |
|
- | 100 | } |
|
- | 101 | ||
- | 102 | static void *tmpfs_root_get(void) |
|
- | 103 | { |
|
- | 104 | return root; |
|
- | 105 | } |
|
- | 106 | ||
- | 107 | static char tmpfs_plb_get_char(unsigned pos) |
|
- | 108 | { |
|
- | 109 | return tmpfs_reg.plb_ro[pos % PLB_SIZE]; |
|
- | 110 | } |
|
- | 111 | ||
- | 112 | static bool tmpfs_is_directory(void *nodep) |
|
- | 113 | { |
|
- | 114 | return ((tmpfs_dentry_t *) nodep)->type == TMPFS_DIRECTORY; |
|
- | 115 | } |
|
- | 116 | ||
- | 117 | static bool tmpfs_is_file(void *nodep) |
|
- | 118 | { |
|
- | 119 | return ((tmpfs_dentry_t *) nodep)->type == TMPFS_FILE; |
|
- | 120 | } |
|
- | 121 | ||
- | 122 | /** libfs operations */ |
|
- | 123 | libfs_ops_t tmpfs_libfs_ops = { |
|
- | 124 | .match = tmpfs_match, |
|
- | 125 | .create = tmpfs_create_node, |
|
- | 126 | .destroy = tmpfs_destroy_node, |
|
- | 127 | .link = tmpfs_link_node, |
|
- | 128 | .unlink = tmpfs_unlink_node, |
|
- | 129 | .index_get = tmpfs_index_get, |
|
- | 130 | .size_get = tmpfs_size_get, |
|
- | 131 | .lnkcnt_get = tmpfs_lnkcnt_get, |
|
- | 132 | .child_get = tmpfs_child_get, |
|
- | 133 | .sibling_get = tmpfs_sibling_get, |
|
- | 134 | .root_get = tmpfs_root_get, |
|
- | 135 | .plb_get_char = tmpfs_plb_get_char, |
|
- | 136 | .is_directory = tmpfs_is_directory, |
|
- | 137 | .is_file = tmpfs_is_file |
|
- | 138 | }; |
|
69 | 139 | ||
70 | /** Hash table of all directory entries. */ |
140 | /** Hash table of all directory entries. */ |
71 | hash_table_t dentries; |
141 | hash_table_t dentries; |
72 | 142 | ||
- | 143 | /* Implementation of hash table interface. */ |
|
73 | static hash_index_t dentries_hash(unsigned long *key) |
144 | static hash_index_t dentries_hash(unsigned long *key) |
74 | { |
145 | { |
75 | return *key % DENTRIES_BUCKETS; |
146 | return *key % DENTRIES_BUCKETS; |
76 | } |
147 | } |
77 | 148 | ||
78 | static int dentries_compare(unsigned long *key, hash_count_t keys, |
149 | static int dentries_compare(unsigned long *key, hash_count_t keys, |
79 | link_t *item) |
150 | link_t *item) |
80 | { |
151 | { |
81 | tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t, |
152 | tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t, |
82 | dh_link); |
153 | dh_link); |
83 | return dentry->index == *key; |
154 | return dentry->index == *key; |
84 | } |
155 | } |
85 | 156 | ||
86 | static void dentries_remove_callback(link_t *item) |
157 | static void dentries_remove_callback(link_t *item) |
87 | { |
158 | { |
88 | } |
159 | } |
89 | 160 | ||
90 | /** TMPFS dentries hash table operations. */ |
161 | /** TMPFS dentries hash table operations. */ |
91 | hash_table_operations_t dentries_ops = { |
162 | hash_table_operations_t dentries_ops = { |
92 | .hash = dentries_hash, |
163 | .hash = dentries_hash, |
93 | .compare = dentries_compare, |
164 | .compare = dentries_compare, |
94 | .remove_callback = dentries_remove_callback |
165 | .remove_callback = dentries_remove_callback |
95 | }; |
166 | }; |
96 | 167 | ||
97 | unsigned tmpfs_next_index = 1; |
168 | unsigned tmpfs_next_index = 1; |
98 | 169 | ||
99 | static void tmpfs_dentry_initialize(tmpfs_dentry_t *dentry) |
170 | static void tmpfs_dentry_initialize(tmpfs_dentry_t *dentry) |
100 | { |
171 | { |
101 | dentry->index = 0; |
172 | dentry->index = 0; |
102 | dentry->parent = NULL; |
173 | dentry->parent = NULL; |
103 | dentry->sibling = NULL; |
174 | dentry->sibling = NULL; |
104 | dentry->child = NULL; |
175 | dentry->child = NULL; |
105 | dentry->name = NULL; |
176 | dentry->name = NULL; |
106 | dentry->type = TMPFS_NONE; |
177 | dentry->type = TMPFS_NONE; |
107 | dentry->size = 0; |
178 | dentry->size = 0; |
108 | dentry->data = NULL; |
179 | dentry->data = NULL; |
109 | link_initialize(&dentry->dh_link); |
180 | link_initialize(&dentry->dh_link); |
110 | } |
181 | } |
111 | 182 | ||
112 | /* |
- | |
113 | * For now, we don't distinguish between different dev_handles/instances. All |
- | |
114 | * requests resolve to the only instance, rooted in the following variable. |
- | |
115 | */ |
- | |
116 | static tmpfs_dentry_t *root; |
- | |
117 | - | ||
118 | static bool tmpfs_init(void) |
183 | static bool tmpfs_init(void) |
119 | { |
184 | { |
120 | if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops)) |
185 | if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops)) |
121 | return false; |
186 | return false; |
122 | root = (tmpfs_dentry_t *) create_node(L_DIRECTORY); |
187 | root = (tmpfs_dentry_t *) tmpfs_create_node(L_DIRECTORY); |
123 | return root != NULL; |
188 | return root != NULL; |
124 | } |
189 | } |
125 | 190 | ||
126 | /** Compare one component of path to a directory entry. |
191 | /** Compare one component of path to a directory entry. |
127 | * |
192 | * |
128 | * @param nodep Node to compare the path component with. |
193 | * @param nodep Node to compare the path component with. |
129 | * @param component Array of characters holding component name. |
194 | * @param component Array of characters holding component name. |
130 | * |
195 | * |
131 | * @return True on match, false otherwise. |
196 | * @return True on match, false otherwise. |
132 | */ |
197 | */ |
133 | static bool match_component(void *nodep, const char *component) |
198 | bool tmpfs_match(void *nodep, const char *component) |
134 | { |
199 | { |
135 | tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) nodep; |
200 | tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) nodep; |
136 | 201 | ||
137 | return !strcmp(dentry->name, component); |
202 | return !strcmp(dentry->name, component); |
138 | } |
203 | } |
139 | 204 | ||
140 | void *create_node(int lflag) |
205 | void *tmpfs_create_node(int lflag) |
141 | { |
206 | { |
142 | assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY)); |
207 | assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY)); |
143 | 208 | ||
144 | tmpfs_dentry_t *node = malloc(sizeof(tmpfs_dentry_t)); |
209 | tmpfs_dentry_t *node = malloc(sizeof(tmpfs_dentry_t)); |
145 | if (!node) |
210 | if (!node) |
146 | return NULL; |
211 | return NULL; |
147 | 212 | ||
148 | tmpfs_dentry_initialize(node); |
213 | tmpfs_dentry_initialize(node); |
149 | node->index = tmpfs_next_index++; |
214 | node->index = tmpfs_next_index++; |
150 | if (lflag & L_DIRECTORY) |
215 | if (lflag & L_DIRECTORY) |
151 | node->type = TMPFS_DIRECTORY; |
216 | node->type = TMPFS_DIRECTORY; |
152 | else |
217 | else |
153 | node->type = TMPFS_FILE; |
218 | node->type = TMPFS_FILE; |
154 | 219 | ||
155 | /* Insert the new node into the dentry hash table. */ |
220 | /* Insert the new node into the dentry hash table. */ |
156 | hash_table_insert(&dentries, &node->index, &node->dh_link); |
221 | hash_table_insert(&dentries, &node->index, &node->dh_link); |
157 | return (void *) node; |
222 | return (void *) node; |
158 | } |
223 | } |
159 | 224 | ||
160 | bool link_node(void *prnt, void *chld, const char *nm) |
225 | bool tmpfs_link_node(void *prnt, void *chld, const char *nm) |
161 | { |
226 | { |
162 | tmpfs_dentry_t *parentp = (tmpfs_dentry_t *) prnt; |
227 | tmpfs_dentry_t *parentp = (tmpfs_dentry_t *) prnt; |
163 | tmpfs_dentry_t *childp = (tmpfs_dentry_t *) chld; |
228 | tmpfs_dentry_t *childp = (tmpfs_dentry_t *) chld; |
164 | 229 | ||
165 | assert(parentp->type == TMPFS_DIRECTORY); |
230 | assert(parentp->type == TMPFS_DIRECTORY); |
166 | 231 | ||
167 | size_t len = strlen(nm); |
232 | size_t len = strlen(nm); |
168 | char *name = malloc(len + 1); |
233 | char *name = malloc(len + 1); |
169 | if (!name) |
234 | if (!name) |
170 | return false; |
235 | return false; |
171 | strcpy(name, nm); |
236 | strcpy(name, nm); |
172 | childp->name = name; |
237 | childp->name = name; |
173 | 238 | ||
174 | /* Insert the new node into the namespace. */ |
239 | /* Insert the new node into the namespace. */ |
175 | if (parentp->child) { |
240 | if (parentp->child) { |
176 | tmpfs_dentry_t *tmp = parentp->child; |
241 | tmpfs_dentry_t *tmp = parentp->child; |
177 | while (tmp->sibling) |
242 | while (tmp->sibling) |
178 | tmp = tmp->sibling; |
243 | tmp = tmp->sibling; |
179 | tmp->sibling = childp; |
244 | tmp->sibling = childp; |
180 | } else { |
245 | } else { |
181 | parentp->child = childp; |
246 | parentp->child = childp; |
182 | } |
247 | } |
183 | childp->parent = parentp; |
248 | childp->parent = parentp; |
184 | 249 | ||
185 | return true; |
250 | return true; |
186 | } |
251 | } |
187 | 252 | ||
188 | int unlink_node(void *nodeptr) |
253 | int tmpfs_unlink_node(void *nodeptr) |
189 | { |
254 | { |
190 | tmpfs_dentry_t *dentry = (tmpfs_dentry_t *)nodeptr; |
255 | tmpfs_dentry_t *dentry = (tmpfs_dentry_t *)nodeptr; |
191 | 256 | ||
192 | if (dentry->child) |
257 | if (dentry->child) |
193 | return ENOTEMPTY; |
258 | return ENOTEMPTY; |
194 | 259 | ||
195 | if (!dentry->parent) |
260 | if (!dentry->parent) |
196 | return EBUSY; |
261 | return EBUSY; |
197 | 262 | ||
198 | if (dentry->parent->child == dentry) { |
263 | if (dentry->parent->child == dentry) { |
199 | dentry->parent->child = dentry->sibling; |
264 | dentry->parent->child = dentry->sibling; |
200 | } else { |
265 | } else { |
201 | /* TODO: consider doubly linked list for organizing siblings. */ |
266 | /* TODO: consider doubly linked list for organizing siblings. */ |
202 | tmpfs_dentry_t *tmp = dentry->parent->child; |
267 | tmpfs_dentry_t *tmp = dentry->parent->child; |
203 | while (tmp->sibling != dentry) |
268 | while (tmp->sibling != dentry) |
204 | tmp = tmp->sibling; |
269 | tmp = tmp->sibling; |
205 | tmp->sibling = dentry->sibling; |
270 | tmp->sibling = dentry->sibling; |
206 | } |
271 | } |
207 | dentry->sibling = NULL; |
272 | dentry->sibling = NULL; |
208 | dentry->parent = NULL; |
273 | dentry->parent = NULL; |
209 | 274 | ||
210 | free(dentry->name); |
275 | free(dentry->name); |
211 | dentry->name = NULL; |
276 | dentry->name = NULL; |
212 | 277 | ||
213 | return EOK; |
278 | return EOK; |
214 | } |
279 | } |
215 | 280 | ||
216 | void destroy_node(void *nodep) |
281 | void tmpfs_destroy_node(void *nodep) |
217 | { |
282 | { |
218 | tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) nodep; |
283 | tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) nodep; |
219 | 284 | ||
220 | assert(!dentry->child); |
285 | assert(!dentry->child); |
221 | assert(!dentry->sibling); |
286 | assert(!dentry->sibling); |
222 | 287 | ||
223 | unsigned long index = dentry->index; |
288 | unsigned long index = dentry->index; |
224 | hash_table_remove(&dentries, &index, 1); |
289 | hash_table_remove(&dentries, &index, 1); |
225 | 290 | ||
226 | if (dentry->type == TMPFS_FILE) |
291 | if (dentry->type == TMPFS_FILE) |
227 | free(dentry->data); |
292 | free(dentry->data); |
228 | free(dentry); |
293 | free(dentry); |
229 | } |
294 | } |
230 | 295 | ||
231 | void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request) |
296 | void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request) |
232 | { |
297 | { |
233 | unsigned next = IPC_GET_ARG1(*request); |
- | |
234 | unsigned last = IPC_GET_ARG2(*request); |
- | |
235 | int dev_handle = IPC_GET_ARG3(*request); |
- | |
236 | int lflag = IPC_GET_ARG4(*request); |
- | |
237 | - | ||
238 | if (last < next) |
- | |
239 | last += PLB_SIZE; |
- | |
240 | - | ||
241 | /* |
- | |
242 | * Initialize TMPFS. |
298 | /* Initialize TMPFS. */ |
243 | */ |
- | |
244 | if (!root && !tmpfs_init()) { |
299 | if (!root && !tmpfs_init()) { |
245 | ipc_answer_0(rid, ENOMEM); |
300 | ipc_answer_0(rid, ENOMEM); |
246 | return; |
301 | return; |
247 | } |
302 | } |
248 | - | ||
249 | tmpfs_dentry_t *dtmp = root->child; |
- | |
250 | tmpfs_dentry_t *dcur = root; |
- | |
251 | - | ||
252 | if (PLB_GET_CHAR(next) == '/') |
- | |
253 | next++; /* eat slash */ |
- | |
254 | - | ||
255 | char component[NAME_MAX + 1]; |
- | |
256 | int len = 0; |
- | |
257 | while (dtmp && next <= last) { |
- | |
258 | - | ||
259 | /* collect the component */ |
- | |
260 | if (PLB_GET_CHAR(next) != '/') { |
- | |
261 | if (len + 1 == NAME_MAX) { |
- | |
262 | /* comopnent length overflow */ |
- | |
263 | ipc_answer_0(rid, ENAMETOOLONG); |
- | |
264 | return; |
- | |
265 | } |
- | |
266 | component[len++] = PLB_GET_CHAR(next); |
- | |
267 | next++; /* process next character */ |
- | |
268 | if (next <= last) |
- | |
269 | continue; |
- | |
270 | } |
- | |
271 | - | ||
272 | assert(len); |
- | |
273 | component[len] = '\0'; |
- | |
274 | next++; /* eat slash */ |
- | |
275 | len = 0; |
- | |
276 | - | ||
277 | /* match the component */ |
- | |
278 | while (dtmp && !match_component(dtmp, component)) |
- | |
279 | dtmp = dtmp->sibling; |
- | |
280 | - | ||
281 | /* handle miss: match amongst siblings */ |
- | |
282 | if (!dtmp) { |
- | |
283 | if ((next > last) && (lflag & L_CREATE)) { |
- | |
284 | /* no components left and L_CREATE specified */ |
- | |
285 | if (dcur->type != TMPFS_DIRECTORY) { |
- | |
286 | ipc_answer_0(rid, ENOTDIR); |
- | |
287 | return; |
- | |
288 | } |
- | |
289 | void *nodep = create_node(lflag); |
- | |
290 | if (nodep) { |
- | |
291 | if (!link_node(dcur, nodep, |
- | |
292 | component)) { |
- | |
293 | destroy_node(nodep); |
- | |
294 | ipc_answer_0(rid, ENOSPC); |
- | |
295 | } else { |
- | |
296 | ipc_answer_5(rid, EOK, |
- | |
297 | tmpfs_reg.fs_handle, |
- | |
298 | dev_handle, |
- | |
299 | TMPFS_GET_INDEX(nodep), 0, |
- | |
300 | TMPFS_GET_LNKCNT(nodep)); |
- | |
301 | } |
- | |
302 | } else { |
- | |
303 | ipc_answer_0(rid, ENOSPC); |
- | |
304 | } |
- | |
305 | return; |
- | |
306 | } |
- | |
307 | ipc_answer_0(rid, ENOENT); |
- | |
308 | return; |
- | |
309 | } |
- | |
310 | - | ||
311 | /* descend one level */ |
- | |
312 | dcur = dtmp; |
- | |
313 | dtmp = dtmp->child; |
- | |
314 | } |
- | |
315 | - | ||
316 | /* handle miss: excessive components */ |
- | |
317 | if (!dtmp && next <= last) { |
- | |
318 | if (lflag & L_CREATE) { |
- | |
319 | if (dcur->type != TMPFS_DIRECTORY) { |
- | |
320 | ipc_answer_0(rid, ENOTDIR); |
- | |
321 | return; |
- | |
322 | } |
- | |
323 | - | ||
324 | /* collect next component */ |
- | |
325 | while (next <= last) { |
- | |
326 | if (PLB_GET_CHAR(next) == '/') { |
- | |
327 | /* more than one component */ |
- | |
328 | ipc_answer_0(rid, ENOENT); |
- | |
329 | return; |
- | |
330 | } |
- | |
331 | if (len + 1 == NAME_MAX) { |
- | |
332 | /* component length overflow */ |
- | |
333 | ipc_answer_0(rid, ENAMETOOLONG); |
- | |
334 | return; |
- | |
335 | } |
- | |
336 | component[len++] = PLB_GET_CHAR(next); |
- | |
337 | next++; /* process next character */ |
- | |
338 | } |
- | |
339 | assert(len); |
- | |
340 | component[len] = '\0'; |
- | |
341 | len = 0; |
- | |
342 | - | ||
343 | void *nodep = create_node(lflag); |
- | |
344 | if (nodep) { |
- | |
345 | if (!link_node(dcur, nodep, component)) { |
- | |
346 | destroy_node(nodep); |
- | |
347 | ipc_answer_0(rid, ENOSPC); |
- | |
348 | } else { |
- | |
349 | ipc_answer_5(rid, EOK, |
- | |
350 | tmpfs_reg.fs_handle, |
- | |
351 | dev_handle, TMPFS_GET_INDEX(nodep), |
- | |
352 | 0, TMPFS_GET_LNKCNT(nodep)); |
- | |
353 | } |
- | |
354 | } else { |
- | |
355 | ipc_answer_0(rid, ENOSPC); |
- | |
356 | } |
- | |
357 | return; |
- | |
358 | } |
- | |
359 | ipc_answer_0(rid, ENOENT); |
- | |
360 | return; |
- | |
361 | } |
- | |
362 | - | ||
363 | /* handle hit */ |
- | |
364 | if (lflag & L_DESTROY) { |
- | |
365 | unsigned old_lnkcnt = TMPFS_GET_LNKCNT(dcur); |
- | |
366 | int res = unlink_node(dcur); |
- | |
367 | ipc_answer_5(rid, (ipcarg_t)res, tmpfs_reg.fs_handle, |
- | |
368 | dev_handle, dcur->index, dcur->size, old_lnkcnt); |
- | |
369 | return; |
- | |
370 | } |
- | |
371 | if ((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) { |
- | |
372 | ipc_answer_0(rid, EEXIST); |
- | |
373 | return; |
- | |
374 | } |
- | |
375 | if ((lflag & L_FILE) && (dcur->type != TMPFS_FILE)) { |
- | |
376 | ipc_answer_0(rid, EISDIR); |
- | |
377 | return; |
- | |
378 | } |
- | |
379 | if ((lflag & L_DIRECTORY) && (dcur->type != TMPFS_DIRECTORY)) { |
- | |
380 | ipc_answer_0(rid, ENOTDIR); |
- | |
381 | return; |
- | |
382 | } |
- | |
383 | - | ||
384 | ipc_answer_5(rid, EOK, tmpfs_reg.fs_handle, dev_handle, dcur->index, |
303 | libfs_lookup(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request); |
385 | dcur->size, TMPFS_GET_LNKCNT(dcur)); |
- | |
386 | } |
304 | } |
387 | 305 | ||
388 | void tmpfs_read(ipc_callid_t rid, ipc_call_t *request) |
306 | void tmpfs_read(ipc_callid_t rid, ipc_call_t *request) |
389 | { |
307 | { |
390 | int dev_handle = IPC_GET_ARG1(*request); |
308 | int dev_handle = IPC_GET_ARG1(*request); |
391 | unsigned long index = IPC_GET_ARG2(*request); |
309 | unsigned long index = IPC_GET_ARG2(*request); |
392 | off_t pos = IPC_GET_ARG3(*request); |
310 | off_t pos = IPC_GET_ARG3(*request); |
393 | 311 | ||
394 | /* |
312 | /* |
395 | * Lookup the respective dentry. |
313 | * Lookup the respective dentry. |
396 | */ |
314 | */ |
397 | link_t *hlp; |
315 | link_t *hlp; |
398 | hlp = hash_table_find(&dentries, &index); |
316 | hlp = hash_table_find(&dentries, &index); |
399 | if (!hlp) { |
317 | if (!hlp) { |
400 | ipc_answer_0(rid, ENOENT); |
318 | ipc_answer_0(rid, ENOENT); |
401 | return; |
319 | return; |
402 | } |
320 | } |
403 | tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t, |
321 | tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t, |
404 | dh_link); |
322 | dh_link); |
405 | 323 | ||
406 | /* |
324 | /* |
407 | * Receive the read request. |
325 | * Receive the read request. |
408 | */ |
326 | */ |
409 | ipc_callid_t callid; |
327 | ipc_callid_t callid; |
410 | size_t len; |
328 | size_t len; |
411 | if (!ipc_data_read_receive(&callid, &len)) { |
329 | if (!ipc_data_read_receive(&callid, &len)) { |
412 | ipc_answer_0(callid, EINVAL); |
330 | ipc_answer_0(callid, EINVAL); |
413 | ipc_answer_0(rid, EINVAL); |
331 | ipc_answer_0(rid, EINVAL); |
414 | return; |
332 | return; |
415 | } |
333 | } |
416 | 334 | ||
417 | size_t bytes; |
335 | size_t bytes; |
418 | if (dentry->type == TMPFS_FILE) { |
336 | if (dentry->type == TMPFS_FILE) { |
419 | bytes = max(0, min(dentry->size - pos, len)); |
337 | bytes = max(0, min(dentry->size - pos, len)); |
420 | (void) ipc_data_read_finalize(callid, dentry->data + pos, |
338 | (void) ipc_data_read_finalize(callid, dentry->data + pos, |
421 | bytes); |
339 | bytes); |
422 | } else { |
340 | } else { |
423 | int i; |
341 | int i; |
424 | tmpfs_dentry_t *cur; |
342 | tmpfs_dentry_t *cur; |
425 | 343 | ||
426 | assert(dentry->type == TMPFS_DIRECTORY); |
344 | assert(dentry->type == TMPFS_DIRECTORY); |
427 | 345 | ||
428 | /* |
346 | /* |
429 | * Yes, we really use O(n) algorithm here. |
347 | * Yes, we really use O(n) algorithm here. |
430 | * If it bothers someone, it could be fixed by introducing a |
348 | * If it bothers someone, it could be fixed by introducing a |
431 | * hash table. |
349 | * hash table. |
432 | */ |
350 | */ |
433 | for (i = 0, cur = dentry->child; i < pos && cur; i++, |
351 | for (i = 0, cur = dentry->child; i < pos && cur; i++, |
434 | cur = cur->sibling) |
352 | cur = cur->sibling) |
435 | ; |
353 | ; |
436 | 354 | ||
437 | if (!cur) { |
355 | if (!cur) { |
438 | ipc_answer_0(callid, ENOENT); |
356 | ipc_answer_0(callid, ENOENT); |
439 | ipc_answer_1(rid, ENOENT, 0); |
357 | ipc_answer_1(rid, ENOENT, 0); |
440 | return; |
358 | return; |
441 | } |
359 | } |
442 | 360 | ||
443 | (void) ipc_data_read_finalize(callid, cur->name, |
361 | (void) ipc_data_read_finalize(callid, cur->name, |
444 | strlen(cur->name) + 1); |
362 | strlen(cur->name) + 1); |
445 | bytes = 1; |
363 | bytes = 1; |
446 | } |
364 | } |
447 | 365 | ||
448 | /* |
366 | /* |
449 | * Answer the VFS_READ call. |
367 | * Answer the VFS_READ call. |
450 | */ |
368 | */ |
451 | ipc_answer_1(rid, EOK, bytes); |
369 | ipc_answer_1(rid, EOK, bytes); |
452 | } |
370 | } |
453 | 371 | ||
454 | void tmpfs_write(ipc_callid_t rid, ipc_call_t *request) |
372 | void tmpfs_write(ipc_callid_t rid, ipc_call_t *request) |
455 | { |
373 | { |
456 | int dev_handle = IPC_GET_ARG1(*request); |
374 | int dev_handle = IPC_GET_ARG1(*request); |
457 | unsigned long index = IPC_GET_ARG2(*request); |
375 | unsigned long index = IPC_GET_ARG2(*request); |
458 | off_t pos = IPC_GET_ARG3(*request); |
376 | off_t pos = IPC_GET_ARG3(*request); |
459 | 377 | ||
460 | /* |
378 | /* |
461 | * Lookup the respective dentry. |
379 | * Lookup the respective dentry. |
462 | */ |
380 | */ |
463 | link_t *hlp; |
381 | link_t *hlp; |
464 | hlp = hash_table_find(&dentries, &index); |
382 | hlp = hash_table_find(&dentries, &index); |
465 | if (!hlp) { |
383 | if (!hlp) { |
466 | ipc_answer_0(rid, ENOENT); |
384 | ipc_answer_0(rid, ENOENT); |
467 | return; |
385 | return; |
468 | } |
386 | } |
469 | tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t, |
387 | tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t, |
470 | dh_link); |
388 | dh_link); |
471 | 389 | ||
472 | /* |
390 | /* |
473 | * Receive the write request. |
391 | * Receive the write request. |
474 | */ |
392 | */ |
475 | ipc_callid_t callid; |
393 | ipc_callid_t callid; |
476 | size_t len; |
394 | size_t len; |
477 | if (!ipc_data_write_receive(&callid, &len)) { |
395 | if (!ipc_data_write_receive(&callid, &len)) { |
478 | ipc_answer_0(callid, EINVAL); |
396 | ipc_answer_0(callid, EINVAL); |
479 | ipc_answer_0(rid, EINVAL); |
397 | ipc_answer_0(rid, EINVAL); |
480 | return; |
398 | return; |
481 | } |
399 | } |
482 | 400 | ||
483 | /* |
401 | /* |
484 | * Check whether the file needs to grow. |
402 | * Check whether the file needs to grow. |
485 | */ |
403 | */ |
486 | if (pos + len <= dentry->size) { |
404 | if (pos + len <= dentry->size) { |
487 | /* The file size is not changing. */ |
405 | /* The file size is not changing. */ |
488 | (void) ipc_data_write_finalize(callid, dentry->data + pos, len); |
406 | (void) ipc_data_write_finalize(callid, dentry->data + pos, len); |
489 | ipc_answer_2(rid, EOK, len, dentry->size); |
407 | ipc_answer_2(rid, EOK, len, dentry->size); |
490 | return; |
408 | return; |
491 | } |
409 | } |
492 | size_t delta = (pos + len) - dentry->size; |
410 | size_t delta = (pos + len) - dentry->size; |
493 | /* |
411 | /* |
494 | * At this point, we are deliberately extremely straightforward and |
412 | * At this point, we are deliberately extremely straightforward and |
495 | * simply realloc the contents of the file on every write that grows the |
413 | * simply realloc the contents of the file on every write that grows the |
496 | * file. In the end, the situation might not be as bad as it may look: |
414 | * file. In the end, the situation might not be as bad as it may look: |
497 | * our heap allocator can save us and just grow the block whenever |
415 | * our heap allocator can save us and just grow the block whenever |
498 | * possible. |
416 | * possible. |
499 | */ |
417 | */ |
500 | void *newdata = realloc(dentry->data, dentry->size + delta); |
418 | void *newdata = realloc(dentry->data, dentry->size + delta); |
501 | if (!newdata) { |
419 | if (!newdata) { |
502 | ipc_answer_0(callid, ENOMEM); |
420 | ipc_answer_0(callid, ENOMEM); |
503 | ipc_answer_2(rid, EOK, 0, dentry->size); |
421 | ipc_answer_2(rid, EOK, 0, dentry->size); |
504 | return; |
422 | return; |
505 | } |
423 | } |
506 | /* Clear any newly allocated memory in order to emulate gaps. */ |
424 | /* Clear any newly allocated memory in order to emulate gaps. */ |
507 | memset(newdata + dentry->size, 0, delta); |
425 | memset(newdata + dentry->size, 0, delta); |
508 | dentry->size += delta; |
426 | dentry->size += delta; |
509 | dentry->data = newdata; |
427 | dentry->data = newdata; |
510 | (void) ipc_data_write_finalize(callid, dentry->data + pos, len); |
428 | (void) ipc_data_write_finalize(callid, dentry->data + pos, len); |
511 | ipc_answer_2(rid, EOK, len, dentry->size); |
429 | ipc_answer_2(rid, EOK, len, dentry->size); |
512 | } |
430 | } |
513 | 431 | ||
514 | void tmpfs_truncate(ipc_callid_t rid, ipc_call_t *request) |
432 | void tmpfs_truncate(ipc_callid_t rid, ipc_call_t *request) |
515 | { |
433 | { |
516 | int dev_handle = IPC_GET_ARG1(*request); |
434 | int dev_handle = IPC_GET_ARG1(*request); |
517 | unsigned long index = IPC_GET_ARG2(*request); |
435 | unsigned long index = IPC_GET_ARG2(*request); |
518 | size_t size = IPC_GET_ARG3(*request); |
436 | size_t size = IPC_GET_ARG3(*request); |
519 | 437 | ||
520 | /* |
438 | /* |
521 | * Lookup the respective dentry. |
439 | * Lookup the respective dentry. |
522 | */ |
440 | */ |
523 | link_t *hlp; |
441 | link_t *hlp; |
524 | hlp = hash_table_find(&dentries, &index); |
442 | hlp = hash_table_find(&dentries, &index); |
525 | if (!hlp) { |
443 | if (!hlp) { |
526 | ipc_answer_0(rid, ENOENT); |
444 | ipc_answer_0(rid, ENOENT); |
527 | return; |
445 | return; |
528 | } |
446 | } |
529 | tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t, |
447 | tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t, |
530 | dh_link); |
448 | dh_link); |
531 | 449 | ||
532 | if (size == dentry->size) { |
450 | if (size == dentry->size) { |
533 | ipc_answer_0(rid, EOK); |
451 | ipc_answer_0(rid, EOK); |
534 | return; |
452 | return; |
535 | } |
453 | } |
536 | 454 | ||
537 | void *newdata = realloc(dentry->data, size); |
455 | void *newdata = realloc(dentry->data, size); |
538 | if (!newdata) { |
456 | if (!newdata) { |
539 | ipc_answer_0(rid, ENOMEM); |
457 | ipc_answer_0(rid, ENOMEM); |
540 | return; |
458 | return; |
541 | } |
459 | } |
542 | if (size > dentry->size) { |
460 | if (size > dentry->size) { |
543 | size_t delta = size - dentry->size; |
461 | size_t delta = size - dentry->size; |
544 | memset(newdata + dentry->size, 0, delta); |
462 | memset(newdata + dentry->size, 0, delta); |
545 | } |
463 | } |
546 | dentry->size = size; |
464 | dentry->size = size; |
547 | dentry->data = newdata; |
465 | dentry->data = newdata; |
548 | ipc_answer_0(rid, EOK); |
466 | ipc_answer_0(rid, EOK); |
549 | } |
467 | } |
550 | 468 | ||
551 | void tmpfs_destroy(ipc_callid_t rid, ipc_call_t *request) |
469 | void tmpfs_destroy(ipc_callid_t rid, ipc_call_t *request) |
552 | { |
470 | { |
553 | int dev_handle = IPC_GET_ARG1(*request); |
471 | int dev_handle = IPC_GET_ARG1(*request); |
554 | unsigned long index = IPC_GET_ARG2(*request); |
472 | unsigned long index = IPC_GET_ARG2(*request); |
555 | 473 | ||
556 | link_t *hlp; |
474 | link_t *hlp; |
557 | hlp = hash_table_find(&dentries, &index); |
475 | hlp = hash_table_find(&dentries, &index); |
558 | if (!hlp) { |
476 | if (!hlp) { |
559 | ipc_answer_0(rid, ENOENT); |
477 | ipc_answer_0(rid, ENOENT); |
560 | return; |
478 | return; |
561 | } |
479 | } |
562 | tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t, |
480 | tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t, |
563 | dh_link); |
481 | dh_link); |
564 | destroy_node(dentry); |
482 | tmpfs_destroy_node(dentry); |
565 | ipc_answer_0(rid, EOK); |
483 | ipc_answer_0(rid, EOK); |
566 | } |
484 | } |
567 | 485 | ||
568 | /** |
486 | /** |
569 | * @} |
487 | * @} |
570 | */ |
488 | */ |
571 | 489 |