WebSVN – HelenOS – Diff – /trunk/uspace/srv/fs/fat/fat_ops.c


/*
 * Copyright (c) 2008 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup fs
 * @{
 */
 
/**
 * @file    fat_ops.c
 * @brief   Implementation of VFS operations for the FAT file system server.
 */
 
#include "fat.h"
#include "../../vfs/vfs.h"
#include <libfs.h>
#include <ipc/ipc.h>
#include <async.h>
#include <errno.h>
#include <string.h>
#include <byteorder.h>
 
#define FAT_NAME_LEN        8
#define FAT_EXT_LEN     3
 
#define FAT_PAD         ' ' 
 
#define FAT_DENTRY_UNUSED   0x00
#define FAT_DENTRY_E5_ESC   0x05
#define FAT_DENTRY_DOT      0x2e
#define FAT_DENTRY_ERASED   0xe5
 
static void dentry_name_canonify(fat_dentry_t *d, char *buf)
{
    int i;
 
    for (i = 0; i < FAT_NAME_LEN; i++) {
        if (d->name[i] == FAT_PAD) {
            buf++;
            break;
        }
        if (d->name[i] == FAT_DENTRY_E5_ESC)
            *buf++ = 0xe5;
        else
            *buf++ = d->name[i];
    }
    if (d->ext[0] != FAT_PAD)
        *buf++ = '.';
    for (i = 0; i < FAT_EXT_LEN; i++) {
        if (d->ext[i] == FAT_PAD) {
            *buf = '\0';
            return;
        }
        if (d->ext[i] == FAT_DENTRY_E5_ESC)
            *buf++ = 0xe5;
        else
            *buf++ = d->ext[i];
    }
}
 
static fat_dentry_t *fat_dentry_get(fat_node_t *dirnode, unsigned idx)
{
    return NULL;    /* TODO */
}
 
static void fat_dentry_put(fat_dentry_t *dentry)
{
    /* TODO */
}
 
static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
{
    return NULL;    /* TODO */
}
 
static void *fat_match(void *prnt, const char *component)
{
    fat_node_t *parentp = (fat_node_t *)prnt;
    char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
    unsigned i;
    unsigned dentries;
    fat_dentry_t *d;
 
    dentries = parentp->size / sizeof(fat_dentry_t);
    for (i = 0; i < dentries; i++) {
        d = fat_dentry_get(parentp, i);
        if (d->attr & FAT_ATTR_VOLLABEL) {
            /* volume label entry */
            fat_dentry_put(d);
            continue;
        }
        if (d->name[0] == FAT_DENTRY_ERASED) {
            /* not-currently-used entry */
            fat_dentry_put(d);
            continue;
        }
        if (d->name[0] == FAT_DENTRY_UNUSED) {
            /* never used entry */
            fat_dentry_put(d);
            break;
        }
        if (d->name[0] == FAT_DENTRY_DOT) {
            /*
             * Most likely '.' or '..'.
             * It cannot occur in a regular file name.
             */
            fat_dentry_put(d);
            continue;
        }
       
        dentry_name_canonify(d, name);
        if (strcmp(name, component) == 0) {
            /* hit */
            void *node = fat_node_get(parentp->dev_handle,
                (fs_index_t)uint16_t_le2host(d->firstc));
            fat_dentry_put(d);
            return node;
 
        } else {
            /* miss */
            fat_dentry_put(d);
        }
    }
 
    return NULL;
}
 
/** libfs operations */
libfs_ops_t fat_libfs_ops = {
    .match = fat_match,
    .node_get = fat_node_get,
    .create = NULL,
    .destroy = NULL,
    .link = NULL,
    .unlink = NULL,
    .index_get = NULL,
    .size_get = NULL,
    .lnkcnt_get = NULL,
    .has_children = NULL,
    .root_get = NULL,
    .plb_get_char = NULL,
    .is_directory = NULL,
    .is_file = NULL
};
 
void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
{
    libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
}
 
/**
 * @}
 */
 

Rev 2796	Rev 2798
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 fat_ops.c	34	* @file fat_ops.c
35	* @brief Implementation of VFS operations for the FAT file system server.	35	* @brief Implementation of VFS operations for the FAT file system server.
36	*/	36	*/
37		37
38	#include "fat.h"	38	#include "fat.h"
39	#include "../../vfs/vfs.h"	39	#include "../../vfs/vfs.h"
40	#include <libfs.h>	40	#include <libfs.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 <string.h>	44	#include <string.h>
45	#include <endian.h>	45	#include <byteorder.h>
46		46
47	#define FAT_NAME_LEN 8	47	#define FAT_NAME_LEN 8
48	#define FAT_EXT_LEN 3	48	#define FAT_EXT_LEN 3
49		49
50	#define FAT_PAD ' '	50	#define FAT_PAD ' '
51		51
52	#define FAT_DENTRY_UNUSED 0x00	52	#define FAT_DENTRY_UNUSED 0x00
53	#define FAT_DENTRY_E5_ESC 0x05	53	#define FAT_DENTRY_E5_ESC 0x05
54	#define FAT_DENTRY_DOT 0x2e	54	#define FAT_DENTRY_DOT 0x2e
55	#define FAT_DENTRY_ERASED 0xe5	55	#define FAT_DENTRY_ERASED 0xe5
56		56
57	static void dentry_name_canonify(fat_dentry_t d, char buf)	57	static void dentry_name_canonify(fat_dentry_t d, char buf)
58	{	58	{
59	int i;	59	int i;
60		60
61	for (i = 0; i < FAT_NAME_LEN; i++) {	61	for (i = 0; i < FAT_NAME_LEN; i++) {
62	if (d->name[i] == FAT_PAD) {	62	if (d->name[i] == FAT_PAD) {
63	buf++;	63	buf++;
64	break;	64	break;
65	}	65	}
66	if (d->name[i] == FAT_DENTRY_E5_ESC)	66	if (d->name[i] == FAT_DENTRY_E5_ESC)
67	*buf++ = 0xe5;	67	*buf++ = 0xe5;
68	else	68	else
69	*buf++ = d->name[i];	69	*buf++ = d->name[i];
70	}	70	}
71	if (d->ext[0] != FAT_PAD)	71	if (d->ext[0] != FAT_PAD)
72	*buf++ = '.';	72	*buf++ = '.';
73	for (i = 0; i < FAT_EXT_LEN; i++) {	73	for (i = 0; i < FAT_EXT_LEN; i++) {
74	if (d->ext[i] == FAT_PAD) {	74	if (d->ext[i] == FAT_PAD) {
75	*buf = '\0';	75	*buf = '\0';
76	return;	76	return;
77	}	77	}
78	if (d->ext[i] == FAT_DENTRY_E5_ESC)	78	if (d->ext[i] == FAT_DENTRY_E5_ESC)
79	*buf++ = 0xe5;	79	*buf++ = 0xe5;
80	else	80	else
81	*buf++ = d->ext[i];	81	*buf++ = d->ext[i];
82	}	82	}
83	}	83	}
84		84
85	static fat_dentry_t fat_dentry_get(fat_node_t dirnode, unsigned idx)	85	static fat_dentry_t fat_dentry_get(fat_node_t dirnode, unsigned idx)
86	{	86	{
87	return NULL; /* TODO */	87	return NULL; /* TODO */
88	}	88	}
89		89
90	static void fat_dentry_put(fat_dentry_t *dentry)	90	static void fat_dentry_put(fat_dentry_t *dentry)
91	{	91	{
92	/* TODO */	92	/* TODO */
93	}	93	}
94		94
95	static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)	95	static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
96	{	96	{
97	return NULL; /* TODO */	97	return NULL; /* TODO */
98	}	98	}
99		99
100	static void fat_match(void prnt, const char *component)	100	static void fat_match(void prnt, const char *component)
101	{	101	{
102	fat_node_t parentp = (fat_node_t )prnt;	102	fat_node_t parentp = (fat_node_t )prnt;
103	char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];	103	char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
104	unsigned i;	104	unsigned i;
105	unsigned dentries;	105	unsigned dentries;
106	fat_dentry_t *d;	106	fat_dentry_t *d;
107		107
108	dentries = parentp->size / sizeof(fat_dentry_t);	108	dentries = parentp->size / sizeof(fat_dentry_t);
109	for (i = 0; i < dentries; i++) {	109	for (i = 0; i < dentries; i++) {
110	d = fat_dentry_get(parentp, i);	110	d = fat_dentry_get(parentp, i);
111	if (d->attr & FAT_ATTR_VOLLABEL) {	111	if (d->attr & FAT_ATTR_VOLLABEL) {
112	/* volume label entry */	112	/* volume label entry */
113	fat_dentry_put(d);	113	fat_dentry_put(d);
114	continue;	114	continue;
115	}	115	}
116	if (d->name[0] == FAT_DENTRY_ERASED) {	116	if (d->name[0] == FAT_DENTRY_ERASED) {
117	/* not-currently-used entry */	117	/* not-currently-used entry */
118	fat_dentry_put(d);	118	fat_dentry_put(d);
119	continue;	119	continue;
120	}	120	}
121	if (d->name[0] == FAT_DENTRY_UNUSED) {	121	if (d->name[0] == FAT_DENTRY_UNUSED) {
122	/* never used entry */	122	/* never used entry */
123	fat_dentry_put(d);	123	fat_dentry_put(d);
124	break;	124	break;
125	}	125	}
126	if (d->name[0] == FAT_DENTRY_DOT) {	126	if (d->name[0] == FAT_DENTRY_DOT) {
127	/*	127	/*
128	* Most likely '.' or '..'.	128	* Most likely '.' or '..'.
129	* It cannot occur in a regular file name.	129	* It cannot occur in a regular file name.
130	*/	130	*/
131	fat_dentry_put(d);	131	fat_dentry_put(d);
132	continue;	132	continue;
133	}	133	}
134		134
135	dentry_name_canonify(d, name);	135	dentry_name_canonify(d, name);
136	if (strcmp(name, component) == 0) {	136	if (strcmp(name, component) == 0) {
137	/* hit */	137	/* hit */
138	void *node = fat_node_get(parentp->dev_handle,	138	void *node = fat_node_get(parentp->dev_handle,
139	(fs_index_t)uint16_t_le2host(d->firstc));	139	(fs_index_t)uint16_t_le2host(d->firstc));
140	fat_dentry_put(d);	140	fat_dentry_put(d);
141	return node;	141	return node;
142		142
143	} else {	143	} else {
144	/* miss */	144	/* miss */
145	fat_dentry_put(d);	145	fat_dentry_put(d);
146	}	146	}
147	}	147	}
148		148
149	return NULL;	149	return NULL;
150	}	150	}
151		151
152	/** libfs operations */	152	/** libfs operations */
153	libfs_ops_t fat_libfs_ops = {	153	libfs_ops_t fat_libfs_ops = {
154	.match = fat_match,	154	.match = fat_match,
155	.node_get = fat_node_get,	155	.node_get = fat_node_get,
156	.create = NULL,	156	.create = NULL,
157	.destroy = NULL,	157	.destroy = NULL,
158	.link = NULL,	158	.link = NULL,
159	.unlink = NULL,	159	.unlink = NULL,
160	.index_get = NULL,	160	.index_get = NULL,
161	.size_get = NULL,	161	.size_get = NULL,
162	.lnkcnt_get = NULL,	162	.lnkcnt_get = NULL,
163	.has_children = NULL,	163	.has_children = NULL,
164	.root_get = NULL,	164	.root_get = NULL,
165	.plb_get_char = NULL,	165	.plb_get_char = NULL,
166	.is_directory = NULL,	166	.is_directory = NULL,
167	.is_file = NULL	167	.is_file = NULL
168	};	168	};
169		169
170	void fat_lookup(ipc_callid_t rid, ipc_call_t *request)	170	void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
171	{	171	{
172	libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);	172	libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
173	}	173	}
174		174
175	/**	175	/**
176	* @}	176	* @}
177	*/	177	*/
178		178

Subversion Repositories HelenOS

(root)/trunk/uspace/srv/fs/fat/fat_ops.c – Rev 2796 → 2798