source: mainline/uspace/srv/fs/minixfs/mfs_ops.c@ e5cebc9

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since e5cebc9 was 58c36ac, checked in by Maurizio Lombardi <m.lombardi85@…>, 14 years ago

Return the error code if put_inode() failed.
  • Property mode set to 100644
File size: 17.5 KB
Line 
1/*
2 * Copyright (c) 2011 Maurizio Lombardi
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#include <stdio.h>
34#include <stdlib.h>
35#include <assert.h>
36#include <fibril_synch.h>
37#include <errno.h>
38#include "mfs.h"
39#include "mfs_utils.h"
40
41static bool check_magic_number(uint16_t magic, bool *native,
42 mfs_version_t *version, bool *longfilenames);
43static int mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
44 fs_index_t index);
45
46static int mfs_node_put(fs_node_t *fsnode);
47static int mfs_node_open(fs_node_t *fsnode);
48static fs_index_t mfs_index_get(fs_node_t *fsnode);
49static unsigned mfs_lnkcnt_get(fs_node_t *fsnode);
50static char mfs_plb_get_char(unsigned pos);
51static bool mfs_is_directory(fs_node_t *fsnode);
52static bool mfs_is_file(fs_node_t *fsnode);
53static int mfs_has_children(bool *has_children, fs_node_t *fsnode);
54static int mfs_root_get(fs_node_t **rfn, devmap_handle_t handle);
55static devmap_handle_t mfs_device_get(fs_node_t *fsnode);
56static aoff64_t mfs_size_get(fs_node_t *node);
57static int mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component);
58static int mfs_create_node(fs_node_t **rfn, devmap_handle_t handle, int flags);
59static int mfs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name);
60
61static int mfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle,
62 fs_index_t index);
63
64
65static LIST_INITIALIZE(inst_list);
66static FIBRIL_MUTEX_INITIALIZE(inst_list_mutex);
67
68libfs_ops_t mfs_libfs_ops = {
69 .size_get = mfs_size_get,
70 .root_get = mfs_root_get,
71 .device_get = mfs_device_get,
72 .is_directory = mfs_is_directory,
73 .is_file = mfs_is_file,
74 .node_get = mfs_node_get,
75 .node_put = mfs_node_put,
76 .node_open = mfs_node_open,
77 .index_get = mfs_index_get,
78 .match = mfs_match,
79 .create = mfs_create_node,
80 .link = mfs_link,
81 .plb_get_char = mfs_plb_get_char,
82 .has_children = mfs_has_children,
83 .lnkcnt_get = mfs_lnkcnt_get
84};
85
86void mfs_mounted(ipc_callid_t rid, ipc_call_t *request)
87{
88 devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
89 enum cache_mode cmode;
90 struct mfs_superblock *sb;
91 struct mfs3_superblock *sb3;
92 struct mfs_sb_info *sbi;
93 struct mfs_instance *instance;
94 bool native, longnames;
95 mfs_version_t version;
96 uint16_t magic;
97
98 /* Accept the mount options */
99 char *opts;
100 int rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
101
102 if (rc != EOK) {
103 mfsdebug("Can't accept async data write\n");
104 async_answer_0(rid, rc);
105 return;
106 }
107
108 /* Check for option enabling write through. */
109 if (str_cmp(opts, "wtcache") == 0)
110 cmode = CACHE_MODE_WT;
111 else
112 cmode = CACHE_MODE_WB;
113
114 free(opts);
115
116 /* initialize libblock */
117 rc = block_init(devmap_handle, 1024);
118 if (rc != EOK) {
119 mfsdebug("libblock initialization failed\n");
120 async_answer_0(rid, rc);
121 return;
122 }
123
124 /*Allocate space for generic MFS superblock*/
125 sbi = malloc(sizeof(*sbi));
126
127 if (!sbi) {
128 async_answer_0(rid, ENOMEM);
129 return;
130 }
131
132 /*Allocate space for filesystem instance*/
133 instance = malloc(sizeof(*instance));
134
135 if (!instance) {
136 async_answer_0(rid, ENOMEM);
137 return;
138 }
139
140 sb = malloc(MFS_SUPERBLOCK_SIZE);
141
142 if (!sb) {
143 async_answer_0(rid, ENOMEM);
144 return;
145 }
146
147 /* Read the superblock */
148 rc = block_read_direct(devmap_handle, MFS_SUPERBLOCK << 1, 1, sb);
149 if (rc != EOK) {
150 block_fini(devmap_handle);
151 async_answer_0(rid, rc);
152 return;
153 }
154
155 sb3 = (struct mfs3_superblock *) sb;
156
157 if (check_magic_number(sb->s_magic, &native, &version, &longnames)) {
158 /*This is a V1 or V2 Minix filesystem*/
159 magic = sb->s_magic;
160 goto recognized;
161 }
162
163 if (!check_magic_number(sb3->s_magic, &native, &version, &longnames)) {
164 mfsdebug("magic number not recognized\n");
165 block_fini(devmap_handle);
166 async_answer_0(rid, ENOTSUP);
167 return;
168 }
169
170 /*This is a V3 Minix filesystem*/
171
172 magic = sb3->s_magic;
173
174recognized:
175
176 mfsdebug("magic number recognized = %04x\n", magic);
177
178 /*Fill superblock info structure*/
179
180 sbi->fs_version = version;
181 sbi->long_names = longnames;
182 sbi->native = native;
183 sbi->magic = magic;
184 sbi->isearch = 0;
185 sbi->zsearch = 0;
186
187 if (version == MFS_VERSION_V3) {
188 sbi->ninodes = conv32(native, sb3->s_ninodes);
189 sbi->ibmap_blocks = conv16(native, sb3->s_ibmap_blocks);
190 sbi->zbmap_blocks = conv16(native, sb3->s_zbmap_blocks);
191 sbi->firstdatazone = conv16(native, sb3->s_first_data_zone);
192 sbi->log2_zone_size = conv16(native, sb3->s_log2_zone_size);
193 sbi->max_file_size = conv32(native, sb3->s_max_file_size);
194 sbi->nzones = conv32(native, sb3->s_nzones);
195 sbi->block_size = conv16(native, sb3->s_block_size);
196 sbi->ino_per_block = V3_INODES_PER_BLOCK(sbi->block_size);
197 sbi->dirsize = MFS3_DIRSIZE;
198 sbi->max_name_len = MFS3_MAX_NAME_LEN;
199 } else {
200 sbi->ninodes = conv16(native, sb->s_ninodes);
201 sbi->ibmap_blocks = conv16(native, sb->s_ibmap_blocks);
202 sbi->zbmap_blocks = conv16(native, sb->s_zbmap_blocks);
203 sbi->firstdatazone = conv16(native, sb->s_first_data_zone);
204 sbi->log2_zone_size = conv16(native, sb->s_log2_zone_size);
205 sbi->max_file_size = conv32(native, sb->s_max_file_size);
206 sbi->block_size = MFS_BLOCKSIZE;
207 if (version == MFS_VERSION_V2) {
208 sbi->nzones = conv32(native, sb->s_nzones2);
209 sbi->ino_per_block = V2_INODES_PER_BLOCK;
210 } else {
211 sbi->nzones = conv16(native, sb->s_nzones);
212 sbi->ino_per_block = V1_INODES_PER_BLOCK;
213 }
214 sbi->dirsize = longnames ? MFSL_DIRSIZE : MFS_DIRSIZE;
215 sbi->max_name_len = longnames ? MFS_L_MAX_NAME_LEN :
216 MFS_MAX_NAME_LEN;
217 }
218 sbi->itable_off = 2 + sbi->ibmap_blocks + sbi->zbmap_blocks;
219
220 free(sb);
221
222 rc = block_cache_init(devmap_handle, sbi->block_size, 0, cmode);
223
224 if (rc != EOK) {
225 block_fini(devmap_handle);
226 async_answer_0(rid, EINVAL);
227 mfsdebug("block cache initialization failed\n");
228 return;
229 }
230
231 /*Initialize the instance structure and add it to the list*/
232 link_initialize(&instance->link);
233 instance->handle = devmap_handle;
234 instance->sbi = sbi;
235
236 fibril_mutex_lock(&inst_list_mutex);
237 list_append(&instance->link, &inst_list);
238 fibril_mutex_unlock(&inst_list_mutex);
239
240 mfsdebug("mount successful\n");
241
242 async_answer_0(rid, EOK);
243}
244
245void mfs_mount(ipc_callid_t rid, ipc_call_t *request)
246{
247 libfs_mount(&mfs_libfs_ops, mfs_reg.fs_handle, rid, request);
248}
249
250devmap_handle_t mfs_device_get(fs_node_t *fsnode)
251{
252 struct mfs_node *node = fsnode->data;
253 return node->instance->handle;
254}
255
256static int mfs_create_node(fs_node_t **rfn, devmap_handle_t handle, int flags)
257{
258 int r;
259 struct mfs_instance *inst;
260 struct mfs_node *mnode;
261 fs_node_t *fsnode;
262 uint32_t inum;
263
264 mfsdebug("create_node()\n");
265
266 r = mfs_instance_get(handle, &inst);
267 if (r != EOK)
268 return r;
269
270 if (flags & L_DIRECTORY) {
271 /*Not yet supported*/
272 return ENOTSUP;
273 }
274
275 /*Alloc a new inode*/
276 r = mfs_alloc_bit(inst, &inum, BMAP_INODE);
277 if (r != EOK)
278 return r;
279
280 struct mfs_ino_info *ino_i;
281
282 ino_i = malloc(sizeof(*ino_i));
283 if (!ino_i) {
284 r = ENOMEM;
285 goto out_err;
286 }
287
288 mnode = malloc(sizeof(*mnode));
289 if (!mnode) {
290 r = ENOMEM;
291 goto out_err_1;
292 }
293
294 fsnode = malloc(sizeof(fs_node_t));
295 if (!fsnode) {
296 r = ENOMEM;
297 goto out_err_2;
298 }
299
300 ino_i->i_mode = S_IFREG;
301 ino_i->i_nlinks = 1;
302 ino_i->i_uid = 0;
303 ino_i->i_gid = 0;
304 ino_i->i_size = 0;
305 ino_i->i_atime = 0;
306 ino_i->i_mtime = 0;
307 ino_i->i_ctime = 0;
308
309 memset(ino_i->i_dzone, 0, sizeof(uint32_t) * V2_NR_DIRECT_ZONES);
310 memset(ino_i->i_izone, 0, sizeof(uint32_t) * V2_NR_INDIRECT_ZONES);
311
312 mfsdebug("new node idx = %d\n", (int) inum);
313
314 ino_i->index = inum;
315 ino_i->dirty = true;
316 mnode->ino_i = ino_i;
317 mnode->instance = inst;
318
319 r = put_inode(mnode);
320 if (r != EOK)
321 goto out_err_2;
322
323 fs_node_initialize(fsnode);
324 fsnode->data = mnode;
325 *rfn = fsnode;
326
327 return EOK;
328
329out_err_2:
330 free(mnode);
331out_err_1:
332 free(ino_i);
333out_err:
334 return r;
335}
336
337static int mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
338{
339 struct mfs_node *mnode = pfn->data;
340 struct mfs_ino_info *ino_i = mnode->ino_i;
341 struct mfs_dentry_info *d_info;
342 int r;
343
344 mfsdebug("mfs_match()\n");
345
346 if (!S_ISDIR(ino_i->i_mode))
347 return ENOTDIR;
348
349 struct mfs_sb_info *sbi = mnode->instance->sbi;
350 const size_t comp_size = str_size(component);
351
352 int i = 2;
353 while (1) {
354 r = read_directory_entry(mnode, &d_info, i++);
355 if (r != EOK)
356 return r;
357
358 if (!d_info) {
359 /*Reached the end of the directory entry list*/
360 break;
361 }
362
363 if (!d_info->d_inum) {
364 /*This entry is not used*/
365 free(d_info);
366 continue;
367 }
368
369 if (!bcmp(component, d_info->d_name, min(sbi->max_name_len,
370 comp_size))) {
371 /*Hit!*/
372 mfs_node_core_get(rfn, mnode->instance,
373 d_info->d_inum);
374 free(d_info);
375 goto found;
376 }
377 free(d_info);
378 }
379 *rfn = NULL;
380found:
381 return EOK;
382}
383
384static aoff64_t mfs_size_get(fs_node_t *node)
385{
386 assert(node);
387
388 const struct mfs_node *mnode = node->data;
389 assert(mnode);
390 assert(mnode->ino_i);
391
392 return mnode->ino_i->i_size;
393}
394
395void mfs_stat(ipc_callid_t rid, ipc_call_t *request)
396{
397 mfsdebug("mfs_stat()\n");
398 libfs_stat(&mfs_libfs_ops, mfs_reg.fs_handle, rid, request);
399}
400
401static int mfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle,
402 fs_index_t index)
403{
404 int rc;
405 struct mfs_instance *instance;
406
407 rc = mfs_instance_get(devmap_handle, &instance);
408
409 if (rc != EOK)
410 return rc;
411
412 return mfs_node_core_get(rfn, instance, index);
413}
414
415static int mfs_node_put(fs_node_t *fsnode)
416{
417 struct mfs_node *mnode = fsnode->data;
418
419 put_inode(mnode);
420 free(mnode->ino_i);
421 free(mnode);
422
423 return EOK;
424}
425
426static int mfs_node_open(fs_node_t *fsnode)
427{
428 /*
429 * Opening a file is stateless, nothing
430 * to be done here.
431 */
432 return EOK;
433}
434
435static fs_index_t mfs_index_get(fs_node_t *fsnode)
436{
437 struct mfs_node *mnode = fsnode->data;
438
439 assert(mnode->ino_i);
440 return mnode->ino_i->index;
441}
442
443static unsigned mfs_lnkcnt_get(fs_node_t *fsnode)
444{
445 unsigned rc;
446 struct mfs_node *mnode = fsnode->data;
447
448 assert(mnode);
449 assert(mnode->ino_i);
450
451 rc = mnode->ino_i->i_nlinks;
452 return rc;
453}
454
455static int mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
456 fs_index_t index)
457{
458 fs_node_t *node = NULL;
459 struct mfs_node *mnode = NULL;
460 int rc;
461
462 node = malloc(sizeof(fs_node_t));
463 if (!node) {
464 rc = ENOMEM;
465 goto out_err;
466 }
467
468 fs_node_initialize(node);
469
470 mnode = malloc(sizeof(*mnode));
471 if (!mnode) {
472 rc = ENOMEM;
473 goto out_err;
474 }
475
476 struct mfs_ino_info *ino_i;
477
478 rc = get_inode(inst, &ino_i, index);
479 if (rc != EOK)
480 goto out_err;
481
482 ino_i->index = index;
483 mnode->ino_i = ino_i;
484
485 mnode->instance = inst;
486 node->data = mnode;
487 *rfn = node;
488
489 mfsdebug("node_get_core(%d) OK\n", (int) index);
490
491 return EOK;
492
493out_err:
494 if (node)
495 free(node);
496 if (mnode)
497 free(mnode);
498 return rc;
499}
500
501static bool mfs_is_directory(fs_node_t *fsnode)
502{
503 const struct mfs_node *node = fsnode->data;
504 return S_ISDIR(node->ino_i->i_mode);
505}
506
507static bool mfs_is_file(fs_node_t *fsnode)
508{
509 struct mfs_node *node = fsnode->data;
510 return S_ISREG(node->ino_i->i_mode);
511}
512
513static int mfs_root_get(fs_node_t **rfn, devmap_handle_t handle)
514{
515 int rc = mfs_node_get(rfn, handle, MFS_ROOT_INO);
516 return rc;
517}
518
519void mfs_lookup(ipc_callid_t rid, ipc_call_t *request)
520{
521 libfs_lookup(&mfs_libfs_ops, mfs_reg.fs_handle, rid, request);
522}
523
524static char mfs_plb_get_char(unsigned pos)
525{
526 return mfs_reg.plb_ro[pos % PLB_SIZE];
527}
528
529static int mfs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
530{
531 struct mfs_node *parent = pfn->data;
532 struct mfs_node *child = cfn->data;
533
534 mfsdebug("mfs_link() %d\n", (int) child->ino_i->index);
535
536 int r = insert_dentry(parent, name, child->ino_i->index);
537
538 return r;
539}
540
541static int mfs_has_children(bool *has_children, fs_node_t *fsnode)
542{
543 struct mfs_node *mnode = fsnode->data;
544 int r;
545
546 *has_children = false;
547
548 mfsdebug("mfs_has_children()\n");
549
550 if (!S_ISDIR(mnode->ino_i->i_mode))
551 goto out;
552
553 struct mfs_dentry_info *d_info;
554
555 /* The first two dentries are always . and .. */
556 int i = 2;
557 while (1) {
558 r = read_directory_entry(mnode, &d_info, i++);
559 if (r != EOK)
560 return r;
561
562 if (!d_info) {
563 /*Reached the end of the dentries list*/
564 break;
565 }
566
567 if (d_info->d_inum) {
568 /*A valid entry has been found*/
569 *has_children = true;
570 free(d_info);
571 break;
572 }
573
574 free(d_info);
575 }
576
577out:
578
579 if (*has_children) {
580 mfsdebug("Has children\n");
581 } else {
582 mfsdebug("Has not children\n");
583 }
584
585 return EOK;
586}
587
588void
589mfs_read(ipc_callid_t rid, ipc_call_t *request)
590{
591 int rc;
592 devmap_handle_t handle = (devmap_handle_t) IPC_GET_ARG1(*request);
593 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
594 aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request),
595 IPC_GET_ARG4(*request));
596 fs_node_t *fn;
597
598 mfsdebug("mfs_read()\n");
599
600 rc = mfs_node_get(&fn, handle, index);
601 if (rc != EOK) {
602 async_answer_0(rid, rc);
603 return;
604 }
605 if (!fn) {
606 async_answer_0(rid, ENOENT);
607 return;
608 }
609
610 struct mfs_node *mnode;
611 struct mfs_ino_info *ino_i;
612 size_t len, bytes = 0;
613 ipc_callid_t callid;
614
615 mnode = fn->data;
616 ino_i = mnode->ino_i;
617
618 if (!async_data_read_receive(&callid, &len)) {
619 rc = EINVAL;
620 goto out_error;
621 }
622
623 if (S_ISDIR(ino_i->i_mode)) {
624 aoff64_t spos = pos;
625 struct mfs_dentry_info *d_info;
626
627 while (1) {
628 rc = read_directory_entry(mnode, &d_info, pos);
629 if (rc != EOK)
630 goto out_error;
631
632 if (!d_info) {
633 /*Reached the end of the dentries list*/
634 break;
635 }
636
637 if (d_info->d_inum) {
638 /*Dentry found!*/
639 mfsdebug("DENTRY FOUND %s!!\n", d_info->d_name);
640 goto found;
641 }
642
643 free(d_info);
644 pos++;
645 }
646
647 rc = mfs_node_put(fn);
648 async_answer_0(callid, rc != EOK ? rc : ENOENT);
649 async_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
650 return;
651found:
652 async_data_read_finalize(callid, d_info->d_name,
653 str_size(d_info->d_name) + 1);
654 bytes = ((pos - spos) + 1);
655 } else {
656 struct mfs_sb_info *sbi = mnode->instance->sbi;
657
658 if (pos >= (size_t) ino_i->i_size) {
659 /*Trying to read beyond the end of file*/
660 bytes = 0;
661 (void) async_data_read_finalize(callid, NULL, 0);
662 goto out_success;
663 }
664
665 bytes = min(len, sbi->block_size - pos % sbi->block_size);
666 bytes = min(bytes, ino_i->i_size - pos);
667
668 uint32_t zone;
669 block_t *b;
670
671 rc = read_map(&zone, mnode, pos);
672 if (rc != EOK)
673 goto out_error;
674
675 if (zone == 0) {
676 /*sparse file*/
677 uint8_t *buf = malloc(sbi->block_size);
678 if (!buf) {
679 rc = ENOMEM;
680 goto out_error;
681 }
682 memset(buf, 0, sizeof(sbi->block_size));
683 async_data_read_finalize(callid,
684 buf + pos % sbi->block_size, bytes);
685 free(buf);
686 goto out_success;
687 }
688
689 rc = block_get(&b, handle, zone, BLOCK_FLAGS_NONE);
690 if (rc != EOK)
691 goto out_error;
692
693 async_data_read_finalize(callid, b->data +
694 pos % sbi->block_size, bytes);
695
696 rc = block_put(b);
697 if (rc != EOK) {
698 mfs_node_put(fn);
699 async_answer_0(rid, rc);
700 return;
701 }
702 }
703out_success:
704 rc = mfs_node_put(fn);
705 async_answer_1(rid, rc, (sysarg_t)bytes);
706 return;
707out_error: ;
708 int tmp = mfs_node_put(fn);
709 async_answer_0(callid, tmp != EOK ? tmp : rc);
710 async_answer_0(rid, tmp != EOK ? tmp : rc);
711}
712
713int mfs_instance_get(devmap_handle_t handle, struct mfs_instance **instance)
714{
715 link_t *link;
716 struct mfs_instance *instance_ptr;
717
718 fibril_mutex_lock(&inst_list_mutex);
719
720 for (link = inst_list.next; link != &inst_list; link = link->next) {
721 instance_ptr = list_get_instance(link, struct mfs_instance,
722 link);
723
724 if (instance_ptr->handle == handle) {
725 *instance = instance_ptr;
726 fibril_mutex_unlock(&inst_list_mutex);
727 return EOK;
728 }
729 }
730
731 mfsdebug("Instance not found\n");
732
733 fibril_mutex_unlock(&inst_list_mutex);
734 return EINVAL;
735}
736
737static bool check_magic_number(uint16_t magic, bool *native,
738 mfs_version_t *version, bool *longfilenames)
739{
740 bool rc = false;
741 *longfilenames = false;
742
743 if (magic == MFS_MAGIC_V1 || magic == MFS_MAGIC_V1R) {
744 *native = magic == MFS_MAGIC_V1;
745 *version = MFS_VERSION_V1;
746 rc = true;
747 } else if (magic == MFS_MAGIC_V1L || magic == MFS_MAGIC_V1LR) {
748 *native = magic == MFS_MAGIC_V1L;
749 *version = MFS_VERSION_V1;
750 *longfilenames = true;
751 rc = true;
752 } else if (magic == MFS_MAGIC_V2 || magic == MFS_MAGIC_V2R) {
753 *native = magic == MFS_MAGIC_V2;
754 *version = MFS_VERSION_V2;
755 rc = true;
756 } else if (magic == MFS_MAGIC_V2L || magic == MFS_MAGIC_V2LR) {
757 *native = magic == MFS_MAGIC_V2L;
758 *version = MFS_VERSION_V2;
759 *longfilenames = true;
760 rc = true;
761 } else if (magic == MFS_MAGIC_V3 || magic == MFS_MAGIC_V3R) {
762 *native = magic == MFS_MAGIC_V3;
763 *version = MFS_VERSION_V3;
764 rc = true;
765 }
766
767 return rc;
768}
769
770void
771mfs_close(ipc_callid_t rid, ipc_call_t *request)
772{
773 async_answer_0(rid, EOK);
774}
775
776void
777mfs_open_node(ipc_callid_t rid, ipc_call_t *request)
778{
779 libfs_open_node(&mfs_libfs_ops, mfs_reg.fs_handle, rid, request);
780}
781
782/**
783 * @}
784 */
785
Note: See TracBrowser for help on using the repository browser.