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];
    }
}
 
/* TODO and also move somewhere else */
typedef struct {
    void *data;
} block_t;
 
static block_t *block_get(dev_handle_t dev_handle, off_t offset)
{
    return NULL;    /* TODO */
}
 
static block_t *fat_block_get(fat_node_t *node, off_t offset) {
    return NULL;    /* TODO */
}
 
static void block_put(block_t *block)
{
    /* TODO */
}
 
static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
{
    return NULL;    /* TODO */
}
 
#define BS_BLOCK    0
 
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, j;
    unsigned bps;       /* bytes per sector */
    unsigned dps;       /* dentries per sector */
    unsigned blocks;
    fat_dentry_t *d;
    block_t *bb;
    block_t *b;
 
 
    bb = block_get(parentp->dev_handle, BS_BLOCK);
    if (!bb)
        return NULL;
    bps = uint16_t_le2host(((fat_bs_t *)bb->data)->bps);
 
 
    block_put(bb);
    dps = bps / sizeof(fat_dentry_t);
    blocks = parentp->size / bps + (parentp->size % bps != 0);
    for (i = 0; i < blocks; i++) {
        unsigned dentries;
       
        b = fat_block_get(parentp, i);
        if (!b)
            return NULL;
 
        dentries = (i == blocks - 1) ?
            parentp->size % sizeof(fat_dentry_t) :
            dps;
        for (j = 0; j < dentries; j++) {
            d = ((fat_dentry_t *)b->data) + j;
            if (d->attr & FAT_ATTR_VOLLABEL) {
                /* volume label entry */
                continue;
            }
            if (d->name[0] == FAT_DENTRY_ERASED) {
                /* not-currently-used entry */
                continue;
            }
            if (d->name[0] == FAT_DENTRY_UNUSED) {
                /* never used entry */
                block_put(b);
                return NULL;
            }
            if (d->name[0] == FAT_DENTRY_DOT) {
                /*
                 * Most likely '.' or '..'.
                 * It cannot occur in a regular file name.
                 */
                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));
                block_put(b);
                return node;
            }
        }
        block_put(b);
    }
 
    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 2822	Rev 2828
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 <byteorder.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	/* TODO and also move somewhere else */	85	/* TODO and also move somewhere else */
86	typedef struct {	86	typedef struct {
87	void *data;	87	void *data;
88	} block_t;	88	} block_t;
89		89
90	static block_t *block_get(dev_handle_t dev_handle, off_t offset)	90	static block_t *block_get(dev_handle_t dev_handle, off_t offset)
91	{	91	{
92	return NULL; /* TODO */	92	return NULL; /* TODO */
93	}	93	}
94		94
95	static block_t fat_block_get(fat_node_t node, off_t offset) {	95	static block_t fat_block_get(fat_node_t node, off_t offset) {
96	return NULL; /* TODO */	96	return NULL; /* TODO */
97	}	97	}
98		98
99	static void block_put(block_t *block)	99	static void block_put(block_t *block)
100	{	100	{
101	/* TODO */	101	/* TODO */
102	}	102	}
103		103
104	static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)	104	static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
105	{	105	{
106	return NULL; /* TODO */	106	return NULL; /* TODO */
107	}	107	}
108		108
109	#define BS_BLOCK 0	109	#define BS_BLOCK 0
110		110
111	static void fat_match(void prnt, const char *component)	111	static void fat_match(void prnt, const char *component)
112	{	112	{
113	fat_node_t parentp = (fat_node_t )prnt;	113	fat_node_t parentp = (fat_node_t )prnt;
114	char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];	114	char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
115	unsigned i, j;	115	unsigned i, j;
-		116	unsigned bps; /* bytes per sector */
116	unsigned dps; /* dentries per sector */	117	unsigned dps; /* dentries per sector */
117	unsigned blocks;	118	unsigned blocks;
118	fat_dentry_t *d;	119	fat_dentry_t *d;
119	block_t *bb;	120	block_t *bb;
120	block_t *b;	121	block_t *b;
121	fat_bs_t *bs;	-
122		122
123	bb = block_get(parentp->dev_handle, BS_BLOCK);	123	bb = block_get(parentp->dev_handle, BS_BLOCK);
124	if (!bb)	124	if (!bb)
125	return NULL;	125	return NULL;
126	bs = (fat_bs_t *)bb->data;	126	bps = uint16_t_le2host(((fat_bs_t *)bb->data)->bps);
127	dps = bs->bps / sizeof(fat_dentry_t);	-
128	blocks = parentp->size / bs->bps + (parentp->size % bs->bps != 0);	-
129	block_put(bb);	127	block_put(bb);
-		128	dps = bps / sizeof(fat_dentry_t);
-		129	blocks = parentp->size / bps + (parentp->size % bps != 0);
130	for (i = 0; i < blocks; i++) {	130	for (i = 0; i < blocks; i++) {
131	unsigned dentries;	131	unsigned dentries;
132		132
133	b = fat_block_get(parentp, i);	133	b = fat_block_get(parentp, i);
134	if (!b)	134	if (!b)
135	return NULL;	135	return NULL;
136		136
137	dentries = (i == blocks - 1) ?	137	dentries = (i == blocks - 1) ?
138	parentp->size % sizeof(fat_dentry_t) :	138	parentp->size % sizeof(fat_dentry_t) :
139	dps;	139	dps;
140	for (j = 0; j < dentries; j++) {	140	for (j = 0; j < dentries; j++) {
141	d = ((fat_dentry_t *)b->data) + j;	141	d = ((fat_dentry_t *)b->data) + j;
142	if (d->attr & FAT_ATTR_VOLLABEL) {	142	if (d->attr & FAT_ATTR_VOLLABEL) {
143	/* volume label entry */	143	/* volume label entry */
144	continue;	144	continue;
145	}	145	}
146	if (d->name[0] == FAT_DENTRY_ERASED) {	146	if (d->name[0] == FAT_DENTRY_ERASED) {
147	/* not-currently-used entry */	147	/* not-currently-used entry */
148	continue;	148	continue;
149	}	149	}
150	if (d->name[0] == FAT_DENTRY_UNUSED) {	150	if (d->name[0] == FAT_DENTRY_UNUSED) {
151	/* never used entry */	151	/* never used entry */
152	block_put(b);	152	block_put(b);
153	return NULL;	153	return NULL;
154	}	154	}
155	if (d->name[0] == FAT_DENTRY_DOT) {	155	if (d->name[0] == FAT_DENTRY_DOT) {
156	/*	156	/*
157	* Most likely '.' or '..'.	157	* Most likely '.' or '..'.
158	* It cannot occur in a regular file name.	158	* It cannot occur in a regular file name.
159	*/	159	*/
160	continue;	160	continue;
161	}	161	}
162		162
163	dentry_name_canonify(d, name);	163	dentry_name_canonify(d, name);
164	if (strcmp(name, component) == 0) {	164	if (strcmp(name, component) == 0) {
165	/* hit */	165	/* hit */
166	void *node = fat_node_get(parentp->dev_handle,	166	void *node = fat_node_get(parentp->dev_handle,
167	(fs_index_t)uint16_t_le2host(d->firstc));	167	(fs_index_t)uint16_t_le2host(d->firstc));
168	block_put(b);	168	block_put(b);
169	return node;	169	return node;
170	}	170	}
171	}	171	}
172	block_put(b);	172	block_put(b);
173	}	173	}
174		174
175	return NULL;	175	return NULL;
176	}	176	}
177		177
178	/** libfs operations */	178	/** libfs operations */
179	libfs_ops_t fat_libfs_ops = {	179	libfs_ops_t fat_libfs_ops = {
180	.match = fat_match,	180	.match = fat_match,
181	.node_get = fat_node_get,	181	.node_get = fat_node_get,
182	.create = NULL,	182	.create = NULL,
183	.destroy = NULL,	183	.destroy = NULL,
184	.link = NULL,	184	.link = NULL,
185	.unlink = NULL,	185	.unlink = NULL,
186	.index_get = NULL,	186	.index_get = NULL,
187	.size_get = NULL,	187	.size_get = NULL,
188	.lnkcnt_get = NULL,	188	.lnkcnt_get = NULL,
189	.has_children = NULL,	189	.has_children = NULL,
190	.root_get = NULL,	190	.root_get = NULL,
191	.plb_get_char = NULL,	191	.plb_get_char = NULL,
192	.is_directory = NULL,	192	.is_directory = NULL,
193	.is_file = NULL	193	.is_file = NULL
194	};	194	};
195		195
196	void fat_lookup(ipc_callid_t rid, ipc_call_t *request)	196	void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
197	{	197	{
198	libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);	198	libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
199	}	199	}
200		200
201	/**	201	/**
202	* @}	202	* @}
203	*/	203	*/
204		204

Subversion Repositories HelenOS

(root)/trunk/uspace/srv/fs/fat/fat_ops.c @ 3573 – Rev 2822 → 2828