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)
{
    block_t *bb, *blk;
    uint16_t bps;
    uint16_t rscnt;
    uint16_t sf;
    uint8_t fatcnt;
    fat_cluster_t *cp;
 
    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);
    fatcnt = FAT_BS(bb)->fatcnt;
    block_put(bb);
 
    assert(fatno < fatcnt);
    blk = block_get(dev_handle, rscnt + sf * fatno +
        (clst * sizeof(fat_cluster_t)) / bps, bps);
    cp = (fat_cluster_t *)blk->data + clst % (bps / sizeof(fat_cluster_t));
    *cp = host2uint16_t_le(value);
    blk->dirty = true;      /* need to sync block */
    block_put(blk);
}
 
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 3507	Rev 3510
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	block_t bb, blk;
-		217	uint16_t bps;
-		218	uint16_t rscnt;
216	/* TODO */	219	uint16_t sf;
-		220	uint8_t fatcnt;
-		221	fat_cluster_t *cp;
-		222
-		223	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
-		224	bps = uint16_t_le2host(FAT_BS(bb)->bps);
-		225	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
-		226	sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
-		227	fatcnt = FAT_BS(bb)->fatcnt;
-		228	block_put(bb);
-		229
-		230	assert(fatno < fatcnt);
-		231	blk = block_get(dev_handle, rscnt + sf * fatno +
-		232	(clst * sizeof(fat_cluster_t)) / bps, bps);
-		233	cp = (fat_cluster_t *)blk->data + clst % (bps / sizeof(fat_cluster_t));
-		234	*cp = host2uint16_t_le(value);
-		235	blk->dirty = true; /* need to sync block */
-		236	block_put(blk);
217	}	237	}
218		238
219	void fat_alloc_shadow_clusters(dev_handle_t dev_handle, fat_cluster_t *lifo,	239	void fat_alloc_shadow_clusters(dev_handle_t dev_handle, fat_cluster_t *lifo,
220	unsigned nclsts)	240	unsigned nclsts)
221	{	241	{
222	uint8_t fatcnt;	242	uint8_t fatcnt;
223	uint8_t fatno;	243	uint8_t fatno;
224	unsigned c;	244	unsigned c;
225	block_t *bb;	245	block_t *bb;
226		246
227	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);	247	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
228	fatcnt = FAT_BS(bb)->fatcnt;	248	fatcnt = FAT_BS(bb)->fatcnt;
229	block_put(bb);	249	block_put(bb);
230		250
231	for (fatno = FAT1 + 1; fatno < fatcnt; fatno++) {	251	for (fatno = FAT1 + 1; fatno < fatcnt; fatno++) {
232	for (c = 0; c < nclsts; c++) {	252	for (c = 0; c < nclsts; c++) {
233	fat_mark_cluster(dev_handle, fatno, lifo[c],	253	fat_mark_cluster(dev_handle, fatno, lifo[c],
234	c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);	254	c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);
235	}	255	}
236	}	256	}
237	}	257	}
238		258
239	int	259	int
240	fat_alloc_clusters(dev_handle_t dev_handle, unsigned nclsts, fat_cluster_t *mcl,	260	fat_alloc_clusters(dev_handle_t dev_handle, unsigned nclsts, fat_cluster_t *mcl,
241	fat_cluster_t *lcl)	261	fat_cluster_t *lcl)
242	{	262	{
243	uint16_t bps;	263	uint16_t bps;
244	uint16_t rscnt;	264	uint16_t rscnt;
245	uint16_t sf;	265	uint16_t sf;
246	block_t bb, blk;	266	block_t bb, blk;
247	fat_cluster_t lifo; / stack for storing free cluster numbers */	267	fat_cluster_t lifo; / stack for storing free cluster numbers */
248	unsigned found = 0; /* top of the free cluster number stack */	268	unsigned found = 0; /* top of the free cluster number stack */
249	unsigned b, c, cl;	269	unsigned b, c, cl;
250		270
251	lifo = (fat_cluster_t ) malloc(nclsts sizeof(fat_cluster_t));	271	lifo = (fat_cluster_t ) malloc(nclsts sizeof(fat_cluster_t));
252	if (lifo)	272	if (lifo)
253	return ENOMEM;	273	return ENOMEM;
254		274
255	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);	275	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
256	bps = uint16_t_le2host(FAT_BS(bb)->bps);	276	bps = uint16_t_le2host(FAT_BS(bb)->bps);
257	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);	277	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
258	sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);	278	sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
259	block_put(bb);	279	block_put(bb);
260		280
261	/*	281	/*
262	* Search FAT1 for unused clusters.	282	* Search FAT1 for unused clusters.
263	*/	283	*/
264	for (b = 0, cl = 0; b < sf; blk++) {	284	for (b = 0, cl = 0; b < sf; blk++) {
265	blk = block_get(dev_handle, rscnt + b, bps);	285	blk = block_get(dev_handle, rscnt + b, bps);
266	for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {	286	for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {
267	fat_cluster_t clst = (fat_cluster_t )blk->data + c;	287	fat_cluster_t clst = (fat_cluster_t )blk->data + c;
268	if (*clst == FAT_CLST_RES0) {	288	if (*clst == FAT_CLST_RES0) {
269	/*	289	/*
270	* The cluster is free. Put it into our stack	290	* The cluster is free. Put it into our stack
271	* of found clusters and mark it as non-free.	291	* of found clusters and mark it as non-free.
272	*/	292	*/
273	lifo[found] = cl;	293	lifo[found] = cl;
274	if (found == 0)	294	if (found == 0)
275	*clst = FAT_CLST_LAST1;	295	*clst = FAT_CLST_LAST1;
276	else	296	else
277	*clst = lifo[found - 1];	297	*clst = lifo[found - 1];
278	blk->dirty = true; /* need to sync block */	298	blk->dirty = true; /* need to sync block */
279	if (++found == nclsts) {	299	if (++found == nclsts) {
280	/* we are almost done */	300	/* we are almost done */
281	block_put(blk);	301	block_put(blk);
282	/* update the shadow copies of FAT */	302	/* update the shadow copies of FAT */
283	fat_alloc_shadow_clusters(dev_handle,	303	fat_alloc_shadow_clusters(dev_handle,
284	lifo, nclsts);	304	lifo, nclsts);
285	*mcl = lifo[found - 1];	305	*mcl = lifo[found - 1];
286	*lcl = lifo[0];	306	*lcl = lifo[0];
287	free(lifo);	307	free(lifo);
288	return EOK;	308	return EOK;
289	}	309	}
290	}	310	}
291	}	311	}
292	block_put(blk);	312	block_put(blk);
293	}	313	}
294		314
295	/*	315	/*
296	* We could not find enough clusters. Now we need to free the clusters	316	* We could not find enough clusters. Now we need to free the clusters
297	* we have allocated so far.	317	* we have allocated so far.
298	*/	318	*/
299	while (found--)	319	while (found--)
300	fat_mark_cluster(dev_handle, FAT1, lifo[found], FAT_CLST_RES0);	320	fat_mark_cluster(dev_handle, FAT1, lifo[found], FAT_CLST_RES0);
301		321
302	free(lifo);	322	free(lifo);
303	return ENOSPC;	323	return ENOSPC;
304	}	324	}
305		325
306	void fat_append_clusters(fat_node_t *nodep, fat_cluster_t mcl)	326	void fat_append_clusters(fat_node_t *nodep, fat_cluster_t mcl)
307	{	327	{
308	}	328	}
309		329
310	/**	330	/**
311	* @}	331	* @}
312	*/	332	*/
313		333

Subversion Repositories HelenOS

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