WebSVN – HelenOS – Diff – /branches/dynload/uspace/srv/fs/fat/fat_fat.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_fat.c
 * @brief   Functions that manipulate the file allocation tables.
 */
 
#include "fat_fat.h"
#include "fat_dentry.h"
#include "fat.h"
#include "../../vfs/vfs.h"
#include <libfs.h>
#include <errno.h>
#include <byteorder.h>
#include <align.h>
#include <assert.h>
 
block_t *
_fat_block_get(dev_handle_t dev_handle, fat_cluster_t firstc, off_t offset)
{
    block_t *bb;
    block_t *b;
    unsigned bps;
    unsigned spc;
    unsigned rscnt;     /* block address of the first FAT */
    unsigned fatcnt;
    unsigned rde;
    unsigned rds;       /* root directory size */
    unsigned sf;
    unsigned ssa;       /* size of the system area */
    unsigned clusters;
    fat_cluster_t clst = firstc;
    unsigned i;
 
    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
    spc = FAT_BS(bb)->spc;
    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
    fatcnt = FAT_BS(bb)->fatcnt;
    rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
    sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
    block_put(bb);
 
    rds = (sizeof(fat_dentry_t) * rde) / bps;
    rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
    ssa = rscnt + fatcnt * sf + rds;
 
    if (firstc == FAT_CLST_ROOT) {
        /* root directory special case */
        assert(offset < rds);
        b = block_get(dev_handle, rscnt + fatcnt * sf + offset, bps);
        return b;
    }
 
    clusters = offset / spc;
    for (i = 0; i < clusters; i++) {
        unsigned fsec;  /* sector offset relative to FAT1 */
        unsigned fidx;  /* FAT1 entry index */
 
        assert(clst >= FAT_CLST_FIRST && clst < FAT_CLST_BAD);
        fsec = (clst * sizeof(fat_cluster_t)) / bps;
        fidx = clst % (bps / sizeof(fat_cluster_t));
        /* read FAT1 */
        b = block_get(dev_handle, rscnt + fsec, bps);
        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
        assert(clst != FAT_CLST_BAD);
        assert(clst < FAT_CLST_LAST1);
        block_put(b);
    }
 
    b = block_get(dev_handle, ssa + (clst - FAT_CLST_FIRST) * spc +
        offset % spc, bps);
 
    return b;
}
 
/** Return number of blocks allocated to a file.
 *
 * @param dev_handle    Device handle of the device with the file.
 * @param firstc    First cluster of the file.
 *
 * @return      Number of blocks allocated to the file.
 */
uint16_t
_fat_blcks_get(dev_handle_t dev_handle, fat_cluster_t firstc)
{
    block_t *bb;
    block_t *b;
    unsigned bps;
    unsigned spc;
    unsigned rscnt;     /* block address of the first FAT */
    unsigned clusters = 0;
    fat_cluster_t clst = firstc;
 
    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
    spc = FAT_BS(bb)->spc;
    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
    block_put(bb);
 
    if (firstc == FAT_CLST_RES0) {
        /* No space allocated to the file. */
        return 0;
    }
 
    while (clst < FAT_CLST_LAST1) {
        unsigned fsec;  /* sector offset relative to FAT1 */
        unsigned fidx;  /* FAT1 entry index */
 
        assert(clst >= FAT_CLST_FIRST);
        fsec = (clst * sizeof(fat_cluster_t)) / bps;
        fidx = clst % (bps / sizeof(fat_cluster_t));
        /* read FAT1 */
        b = block_get(dev_handle, rscnt + fsec, bps);
        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
        assert(clst != FAT_CLST_BAD);
        block_put(b);
        clusters++;
    }
 
    return clusters * spc;
}
 
uint16_t fat_bps_get(dev_handle_t dev_handle)
{
    block_t *bb;
    uint16_t bps;
   
    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
    assert(bb != NULL);
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
    block_put(bb);
 
    return bps;
}
 
/** Fill the gap between EOF and a new file position.
 *
 * @param nodep     FAT node with the gap.
 * @param mcl       First cluster in an independent cluster chain that will
 *          be later appended to the end of the node's own cluster
 *          chain. If pos is still in the last allocated cluster,
 *          this argument is ignored.
 * @param pos       Position in the last node block.
 */
void fat_fill_gap(fat_node_t *nodep, fat_cluster_t mcl, off_t pos)
{
    uint16_t bps;
    unsigned spc;
    block_t *bb, *b;
    off_t o, boundary;
 
    bb = block_get(nodep->idx->dev_handle, BS_BLOCK, BS_SIZE);
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
    spc = FAT_BS(bb)->spc;
    block_put(bb);
   
    boundary = ROUND_UP(nodep->size, bps * spc);
 
    /* zero out already allocated space */
    for (o = nodep->size - 1; o < pos && o < boundary;
        o = ALIGN_DOWN(o + bps, bps)) {
        b = fat_block_get(nodep, o / bps);
        memset(b->data + o % bps, 0, bps - o % bps);
        b->dirty = true;        /* need to sync node */
        block_put(b);
    }
   
    if (o >= pos)
        return;
   
    /* zero out the initial part of the new cluster chain */
    for (o = boundary; o < pos; o += bps) {
        b = _fat_block_get(nodep->idx->dev_handle, mcl,
            (o - boundary) / bps);
        memset(b->data, 0, min(bps, pos - o));
        b->dirty = true;        /* need to sync node */
        block_put(b);
    }
}
 
void
fat_mark_cluster(dev_handle_t dev_handle, unsigned fatno, fat_cluster_t clst,
    fat_cluster_t value)
{
    /* TODO */
}
 
 
void fat_alloc_shadow_clusters(dev_handle_t dev_handle, fat_cluster_t *lifo,
    unsigned nclsts)
{
    uint8_t fatcnt;
    uint8_t fatno;
    unsigned c;
    block_t *bb;
 
    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
    fatcnt = FAT_BS(bb)->fatcnt;
    block_put(bb);
   
    for (fatno = FAT1 + 1; fatno < fatcnt; fatno++) {
        for (c = 0; c < nclsts; c++) {
            fat_mark_cluster(dev_handle, fatno, lifo[c],
                c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);
        }
    }
}
 
int
fat_alloc_clusters(dev_handle_t dev_handle, unsigned nclsts, fat_cluster_t *mcl,
    fat_cluster_t *lcl)
{
    uint16_t bps;
    uint16_t rscnt;
    uint16_t sf;
    block_t *bb, *blk;
    fat_cluster_t *lifo;    /* stack for storing free cluster numbers */
    unsigned found = 0; /* top of the free cluster number stack */
    unsigned b, c, cl;
 
    lifo = (fat_cluster_t *) malloc(nclsts * sizeof(fat_cluster_t));
    if (lifo)
        return ENOMEM;
   
    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
    bps = uint16_t_le2host(FAT_BS(bb)->bps);
    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
    sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
    block_put(bb);
   
    /*
     * Search FAT1 for unused clusters.
     */
    for (b = 0, cl = 0; b < sf; blk++) {
        blk = block_get(dev_handle, rscnt + b, bps);
        for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {
            fat_cluster_t *clst = (fat_cluster_t *)blk->data + c;
            if (*clst == FAT_CLST_RES0) {
                /*
                 * The cluster is free. Put it into our stack
                 * of found clusters and mark it as non-free.
                 */
                lifo[found] = cl;
                if (found == 0)
                    *clst = FAT_CLST_LAST1;
                else
                    *clst = lifo[found - 1];
                blk->dirty = true;  /* need to sync block */
                if (++found == nclsts) {
                    /* we are almost done */
                    block_put(blk);
                    /* update the shadow copies of FAT */
                    fat_alloc_shadow_clusters(dev_handle,
                        lifo, nclsts);
                    *mcl = lifo[found - 1];
                    *lcl = lifo[0];
                    free(lifo);
                    return EOK;
                }
            }
        }
        block_put(blk);
    }
 
    /*
     * We could not find enough clusters. Now we need to free the clusters
     * we have allocated so far.
     */
    while (found--)
        fat_mark_cluster(dev_handle, FAT1, lifo[found], FAT_CLST_RES0);
   
    free(lifo);
    return ENOSPC;
}
 
void fat_append_clusters(fat_node_t *nodep, fat_cluster_t mcl)
{
}
 
/**
 * @}
 */
 

Rev 3506	Rev 3507
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_fat.c	34	* @file fat_fat.c
35	* @brief Functions that manipulate the file allocation tables.	35	* @brief Functions that manipulate the file allocation tables.
36	*/	36	*/
37		37
38	#include "fat_fat.h"	38	#include "fat_fat.h"
39	#include "fat_dentry.h"	39	#include "fat_dentry.h"
40	#include "fat.h"	40	#include "fat.h"
41	#include "../../vfs/vfs.h"	41	#include "../../vfs/vfs.h"
42	#include <libfs.h>	42	#include <libfs.h>
43	#include <errno.h>	43	#include <errno.h>
44	#include <byteorder.h>	44	#include <byteorder.h>
45	#include <align.h>	45	#include <align.h>
46	#include <assert.h>	46	#include <assert.h>
47		47
48	block_t *	48	block_t *
49	_fat_block_get(dev_handle_t dev_handle, fat_cluster_t firstc, off_t offset)	49	_fat_block_get(dev_handle_t dev_handle, fat_cluster_t firstc, off_t offset)
50	{	50	{
51	block_t *bb;	51	block_t *bb;
52	block_t *b;	52	block_t *b;
53	unsigned bps;	53	unsigned bps;
54	unsigned spc;	54	unsigned spc;
55	unsigned rscnt; /* block address of the first FAT */	55	unsigned rscnt; /* block address of the first FAT */
56	unsigned fatcnt;	56	unsigned fatcnt;
57	unsigned rde;	57	unsigned rde;
58	unsigned rds; /* root directory size */	58	unsigned rds; /* root directory size */
59	unsigned sf;	59	unsigned sf;
60	unsigned ssa; /* size of the system area */	60	unsigned ssa; /* size of the system area */
61	unsigned clusters;	61	unsigned clusters;
62	fat_cluster_t clst = firstc;	62	fat_cluster_t clst = firstc;
63	unsigned i;	63	unsigned i;
64		64
65	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);	65	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
66	bps = uint16_t_le2host(FAT_BS(bb)->bps);	66	bps = uint16_t_le2host(FAT_BS(bb)->bps);
67	spc = FAT_BS(bb)->spc;	67	spc = FAT_BS(bb)->spc;
68	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);	68	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
69	fatcnt = FAT_BS(bb)->fatcnt;	69	fatcnt = FAT_BS(bb)->fatcnt;
70	rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);	70	rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
71	sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);	71	sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
72	block_put(bb);	72	block_put(bb);
73		73
74	rds = (sizeof(fat_dentry_t) * rde) / bps;	74	rds = (sizeof(fat_dentry_t) * rde) / bps;
75	rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);	75	rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
76	ssa = rscnt + fatcnt * sf + rds;	76	ssa = rscnt + fatcnt * sf + rds;
77		77
78	if (firstc == FAT_CLST_ROOT) {	78	if (firstc == FAT_CLST_ROOT) {
79	/* root directory special case */	79	/* root directory special case */
80	assert(offset < rds);	80	assert(offset < rds);
81	b = block_get(dev_handle, rscnt + fatcnt * sf + offset, bps);	81	b = block_get(dev_handle, rscnt + fatcnt * sf + offset, bps);
82	return b;	82	return b;
83	}	83	}
84		84
85	clusters = offset / spc;	85	clusters = offset / spc;
86	for (i = 0; i < clusters; i++) {	86	for (i = 0; i < clusters; i++) {
87	unsigned fsec; /* sector offset relative to FAT1 */	87	unsigned fsec; /* sector offset relative to FAT1 */
88	unsigned fidx; /* FAT1 entry index */	88	unsigned fidx; /* FAT1 entry index */
89		89
90	assert(clst >= FAT_CLST_FIRST && clst < FAT_CLST_BAD);	90	assert(clst >= FAT_CLST_FIRST && clst < FAT_CLST_BAD);
91	fsec = (clst * sizeof(fat_cluster_t)) / bps;	91	fsec = (clst * sizeof(fat_cluster_t)) / bps;
92	fidx = clst % (bps / sizeof(fat_cluster_t));	92	fidx = clst % (bps / sizeof(fat_cluster_t));
93	/* read FAT1 */	93	/* read FAT1 */
94	b = block_get(dev_handle, rscnt + fsec, bps);	94	b = block_get(dev_handle, rscnt + fsec, bps);
95	clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);	95	clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
96	assert(clst != FAT_CLST_BAD);	96	assert(clst != FAT_CLST_BAD);
97	assert(clst < FAT_CLST_LAST1);	97	assert(clst < FAT_CLST_LAST1);
98	block_put(b);	98	block_put(b);
99	}	99	}
100		100
101	b = block_get(dev_handle, ssa + (clst - FAT_CLST_FIRST) * spc +	101	b = block_get(dev_handle, ssa + (clst - FAT_CLST_FIRST) * spc +
102	offset % spc, bps);	102	offset % spc, bps);
103		103
104	return b;	104	return b;
105	}	105	}
106		106
107	/** Return number of blocks allocated to a file.	107	/** Return number of blocks allocated to a file.
108	*	108	*
109	* @param dev_handle Device handle of the device with the file.	109	* @param dev_handle Device handle of the device with the file.
110	* @param firstc First cluster of the file.	110	* @param firstc First cluster of the file.
111	*	111	*
112	* @return Number of blocks allocated to the file.	112	* @return Number of blocks allocated to the file.
113	*/	113	*/
114	uint16_t	114	uint16_t
115	_fat_blcks_get(dev_handle_t dev_handle, fat_cluster_t firstc)	115	_fat_blcks_get(dev_handle_t dev_handle, fat_cluster_t firstc)
116	{	116	{
117	block_t *bb;	117	block_t *bb;
118	block_t *b;	118	block_t *b;
119	unsigned bps;	119	unsigned bps;
120	unsigned spc;	120	unsigned spc;
121	unsigned rscnt; /* block address of the first FAT */	121	unsigned rscnt; /* block address of the first FAT */
122	unsigned clusters = 0;	122	unsigned clusters = 0;
123	fat_cluster_t clst = firstc;	123	fat_cluster_t clst = firstc;
124		124
125	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);	125	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
126	bps = uint16_t_le2host(FAT_BS(bb)->bps);	126	bps = uint16_t_le2host(FAT_BS(bb)->bps);
127	spc = FAT_BS(bb)->spc;	127	spc = FAT_BS(bb)->spc;
128	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);	128	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
129	block_put(bb);	129	block_put(bb);
130		130
131	if (firstc == FAT_CLST_RES0) {	131	if (firstc == FAT_CLST_RES0) {
132	/* No space allocated to the file. */	132	/* No space allocated to the file. */
133	return 0;	133	return 0;
134	}	134	}
135		135
136	while (clst < FAT_CLST_LAST1) {	136	while (clst < FAT_CLST_LAST1) {
137	unsigned fsec; /* sector offset relative to FAT1 */	137	unsigned fsec; /* sector offset relative to FAT1 */
138	unsigned fidx; /* FAT1 entry index */	138	unsigned fidx; /* FAT1 entry index */
139		139
140	assert(clst >= FAT_CLST_FIRST);	140	assert(clst >= FAT_CLST_FIRST);
141	fsec = (clst * sizeof(fat_cluster_t)) / bps;	141	fsec = (clst * sizeof(fat_cluster_t)) / bps;
142	fidx = clst % (bps / sizeof(fat_cluster_t));	142	fidx = clst % (bps / sizeof(fat_cluster_t));
143	/* read FAT1 */	143	/* read FAT1 */
144	b = block_get(dev_handle, rscnt + fsec, bps);	144	b = block_get(dev_handle, rscnt + fsec, bps);
145	clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);	145	clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
146	assert(clst != FAT_CLST_BAD);	146	assert(clst != FAT_CLST_BAD);
147	block_put(b);	147	block_put(b);
148	clusters++;	148	clusters++;
149	}	149	}
150		150
151	return clusters * spc;	151	return clusters * spc;
152	}	152	}
153		153
154	uint16_t fat_bps_get(dev_handle_t dev_handle)	154	uint16_t fat_bps_get(dev_handle_t dev_handle)
155	{	155	{
156	block_t *bb;	156	block_t *bb;
157	uint16_t bps;	157	uint16_t bps;
158		158
159	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);	159	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
160	assert(bb != NULL);	160	assert(bb != NULL);
161	bps = uint16_t_le2host(FAT_BS(bb)->bps);	161	bps = uint16_t_le2host(FAT_BS(bb)->bps);
162	block_put(bb);	162	block_put(bb);
163		163
164	return bps;	164	return bps;
165	}	165	}
166		166
167	/** Fill the gap between EOF and a new file position.	167	/** Fill the gap between EOF and a new file position.
168	*	168	*
169	* @param nodep FAT node with the gap.	169	* @param nodep FAT node with the gap.
170	* @param mcl First cluster in an independent cluster chain that will	170	* @param mcl First cluster in an independent cluster chain that will
171	* be later appended to the end of the node's own cluster	171	* be later appended to the end of the node's own cluster
172	* chain. If pos is still in the last allocated cluster,	172	* chain. If pos is still in the last allocated cluster,
173	* this argument is ignored.	173	* this argument is ignored.
174	* @param pos Position in the last node block.	174	* @param pos Position in the last node block.
175	*/	175	*/
176	void fat_fill_gap(fat_node_t *nodep, fat_cluster_t mcl, off_t pos)	176	void fat_fill_gap(fat_node_t *nodep, fat_cluster_t mcl, off_t pos)
177	{	177	{
178	uint16_t bps;	178	uint16_t bps;
179	unsigned spc;	179	unsigned spc;
180	block_t bb, b;	180	block_t bb, b;
181	off_t o, boundary;	181	off_t o, boundary;
182		182
183	bb = block_get(nodep->idx->dev_handle, BS_BLOCK, BS_SIZE);	183	bb = block_get(nodep->idx->dev_handle, BS_BLOCK, BS_SIZE);
184	bps = uint16_t_le2host(FAT_BS(bb)->bps);	184	bps = uint16_t_le2host(FAT_BS(bb)->bps);
185	spc = FAT_BS(bb)->spc;	185	spc = FAT_BS(bb)->spc;
186	block_put(bb);	186	block_put(bb);
187		187
188	boundary = ROUND_UP(nodep->size, bps * spc);	188	boundary = ROUND_UP(nodep->size, bps * spc);
189		189
190	/* zero out already allocated space */	190	/* zero out already allocated space */
191	for (o = nodep->size - 1; o < pos && o < boundary;	191	for (o = nodep->size - 1; o < pos && o < boundary;
192	o = ALIGN_DOWN(o + bps, bps)) {	192	o = ALIGN_DOWN(o + bps, bps)) {
193	b = fat_block_get(nodep, o / bps);	193	b = fat_block_get(nodep, o / bps);
194	memset(b->data + o % bps, 0, bps - o % bps);	194	memset(b->data + o % bps, 0, bps - o % bps);
195	b->dirty = true; /* need to sync node */	195	b->dirty = true; /* need to sync node */
196	block_put(b);	196	block_put(b);
197	}	197	}
198		198
199	if (o >= pos)	199	if (o >= pos)
200	return;	200	return;
201		201
202	/* zero out the initial part of the new cluster chain */	202	/* zero out the initial part of the new cluster chain */
203	for (o = boundary; o < pos; o += bps) {	203	for (o = boundary; o < pos; o += bps) {
204	b = _fat_block_get(nodep->idx->dev_handle, mcl,	204	b = _fat_block_get(nodep->idx->dev_handle, mcl,
205	(o - boundary) / bps);	205	(o - boundary) / bps);
206	memset(b->data, 0, min(bps, pos - o));	206	memset(b->data, 0, min(bps, pos - o));
207	b->dirty = true; /* need to sync node */	207	b->dirty = true; /* need to sync node */
208	block_put(b);	208	block_put(b);
209	}	209	}
210	}	210	}
211		211
212	void	212	void
213	fat_mark_cluster(dev_handle_t dev_handle, unsigned fatno, fat_cluster_t clst,	213	fat_mark_cluster(dev_handle_t dev_handle, unsigned fatno, fat_cluster_t clst,
214	fat_cluster_t value)	214	fat_cluster_t value)
215	{	215	{
216	/* TODO */	216	/* TODO */
217	}	217	}
218		218
219	void	-
220	fat_alloc_shadow_clusters(dev_handle_t dev_handle, fat_cluster_t *lifo,	219	void fat_alloc_shadow_clusters(dev_handle_t dev_handle, fat_cluster_t *lifo,
221	unsigned nclsts)	220	unsigned nclsts)
222	{	221	{
-		222	uint8_t fatcnt;
-		223	uint8_t fatno;
-		224	unsigned c;
223	/* TODO */	225	block_t *bb;
-		226
-		227	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
-		228	fatcnt = FAT_BS(bb)->fatcnt;
-		229	block_put(bb);
-		230
-		231	for (fatno = FAT1 + 1; fatno < fatcnt; fatno++) {
-		232	for (c = 0; c < nclsts; c++) {
-		233	fat_mark_cluster(dev_handle, fatno, lifo[c],
-		234	c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);
-		235	}
-		236	}
224	}	237	}
225		238
226	int	239	int
227	fat_alloc_clusters(dev_handle_t dev_handle, unsigned nclsts, fat_cluster_t *mcl,	240	fat_alloc_clusters(dev_handle_t dev_handle, unsigned nclsts, fat_cluster_t *mcl,
228	fat_cluster_t *lcl)	241	fat_cluster_t *lcl)
229	{	242	{
230	uint16_t bps;	243	uint16_t bps;
231	uint16_t rscnt;	244	uint16_t rscnt;
232	uint16_t sf;	245	uint16_t sf;
233	block_t bb, blk;	246	block_t bb, blk;
234	fat_cluster_t lifo; / stack for storing free cluster numbers */	247	fat_cluster_t lifo; / stack for storing free cluster numbers */
235	unsigned found = 0; /* top of the free cluster number stack */	248	unsigned found = 0; /* top of the free cluster number stack */
236	unsigned b, c, cl;	249	unsigned b, c, cl;
237		250
238	lifo = (fat_cluster_t ) malloc(nclsts sizeof(fat_cluster_t));	251	lifo = (fat_cluster_t ) malloc(nclsts sizeof(fat_cluster_t));
239	if (lifo)	252	if (lifo)
240	return ENOMEM;	253	return ENOMEM;
241		254
242	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);	255	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
243	bps = uint16_t_le2host(FAT_BS(bb)->bps);	256	bps = uint16_t_le2host(FAT_BS(bb)->bps);
244	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);	257	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
245	sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);	258	sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
246	block_put(bb);	259	block_put(bb);
247		260
248	/*	261	/*
249	* Search FAT1 for unused clusters.	262	* Search FAT1 for unused clusters.
250	*/	263	*/
251	for (b = 0, cl = 0; b < sf; blk++) {	264	for (b = 0, cl = 0; b < sf; blk++) {
252	blk = block_get(dev_handle, rscnt + b, bps);	265	blk = block_get(dev_handle, rscnt + b, bps);
253	for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {	266	for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {
254	fat_cluster_t clst = (fat_cluster_t )blk->data + c;	267	fat_cluster_t clst = (fat_cluster_t )blk->data + c;
255	if (*clst == FAT_CLST_RES0) {	268	if (*clst == FAT_CLST_RES0) {
256	/*	269	/*
257	* The cluster is free. Put it into our stack	270	* The cluster is free. Put it into our stack
258	* of found clusters and mark it as non-free.	271	* of found clusters and mark it as non-free.
259	*/	272	*/
260	lifo[found] = cl;	273	lifo[found] = cl;
261	if (found == 0)	274	if (found == 0)
262	*clst = FAT_CLST_LAST1;	275	*clst = FAT_CLST_LAST1;
263	else	276	else
264	*clst = lifo[found - 1];	277	*clst = lifo[found - 1];
265	blk->dirty = true; /* need to sync block */	278	blk->dirty = true; /* need to sync block */
266	if (++found == nclsts) {	279	if (++found == nclsts) {
267	/* we are almost done */	280	/* we are almost done */
268	block_put(blk);	281	block_put(blk);
269	/* update the shadow copies of FAT */	282	/* update the shadow copies of FAT */
270	fat_alloc_shadow_clusters(dev_handle,	283	fat_alloc_shadow_clusters(dev_handle,
271	lifo, nclsts);	284	lifo, nclsts);
272	*mcl = lifo[found - 1];	285	*mcl = lifo[found - 1];
273	*lcl = lifo[0];	286	*lcl = lifo[0];
274	free(lifo);	287	free(lifo);
275	return EOK;	288	return EOK;
276	}	289	}
277	}	290	}
278	}	291	}
279	block_put(blk);	292	block_put(blk);
280	}	293	}
281		294
282	/*	295	/*
283	* We could not find enough clusters. Now we need to free the clusters	296	* We could not find enough clusters. Now we need to free the clusters
284	* we have allocated so far.	297	* we have allocated so far.
285	*/	298	*/
286	while (found--)	299	while (found--)
287	fat_mark_cluster(dev_handle, FAT1, lifo[found], FAT_CLST_RES0);	300	fat_mark_cluster(dev_handle, FAT1, lifo[found], FAT_CLST_RES0);
288		301
289	free(lifo);	302	free(lifo);
290	return ENOSPC;	303	return ENOSPC;
291	}	304	}
292		305
293	void fat_append_clusters(fat_node_t *nodep, fat_cluster_t mcl)	306	void fat_append_clusters(fat_node_t *nodep, fat_cluster_t mcl)
294	{	307	{
295	}	308	}
296		309
297	/**	310	/**
298	* @}	311	* @}
299	*/	312	*/
300		313

Subversion Repositories HelenOS

(root)/branches/dynload/uspace/srv/fs/fat/fat_fat.c @ 3674 – Rev 3506 → 3507