WebSVN – HelenOS – Diff – /trunk/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.
 * @param lastc     If non-NULL, output argument holding the
 *          last cluster.
 *
 * @return      Number of blocks allocated to the file.
 */
uint16_t
_fat_blcks_get(dev_handle_t dev_handle, fat_cluster_t firstc,
    fat_cluster_t *lastc)
{
    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. */
        if (lastc)
            *lastc = firstc;
        return 0;
    }
 
    while (clst < FAT_CLST_LAST1) {
        unsigned fsec;  /* sector offset relative to FAT1 */
        unsigned fidx;  /* FAT1 entry index */
 
        assert(clst >= FAT_CLST_FIRST);
        if (lastc)
            *lastc = clst;      /* remember the last cluster */
        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++;
    }
 
    if (lastc)
        *lastc = clst;
    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 (uint16_t_le2host(*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;
                *clst = (found == 0) ?
                    host2uint16_t_le(FAT_CLST_LAST1) :
                    host2uint16_t_le(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)
{
    block_t *bb;
    fat_cluster_t lcl;
    uint8_t fatcnt, fatno;
 
    if (_fat_blcks_get(nodep->idx->dev_handle, nodep->firstc, &lcl) == 0) {
        nodep->firstc = host2uint16_t_le(mcl);
        nodep->dirty = true;        /* need to sync node */
        return;
    }
 
    bb = block_get(nodep->idx->dev_handle, BS_BLOCK, BS_SIZE);
    fatcnt = FAT_BS(bb)->fatcnt;
    block_put(bb);
 
    for (fatno = FAT1; fatno < fatcnt; fatno++)
        fat_mark_cluster(nodep->idx->dev_handle, fatno, lcl, mcl);
}
 
/**
 * @}
 */
 

Rev 3512	Rev 3513
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	* @param lastc If non-NULL, output argument holding the
-		112	* last cluster.
111	*	113	*
112	* @return Number of blocks allocated to the file.	114	* @return Number of blocks allocated to the file.
113	*/	115	*/
114	uint16_t	116	uint16_t
115	_fat_blcks_get(dev_handle_t dev_handle, fat_cluster_t firstc)	117	_fat_blcks_get(dev_handle_t dev_handle, fat_cluster_t firstc,
-		118	fat_cluster_t *lastc)
116	{	119	{
117	block_t *bb;	120	block_t *bb;
118	block_t *b;	121	block_t *b;
119	unsigned bps;	122	unsigned bps;
120	unsigned spc;	123	unsigned spc;
121	unsigned rscnt; /* block address of the first FAT */	124	unsigned rscnt; /* block address of the first FAT */
122	unsigned clusters = 0;	125	unsigned clusters = 0;
123	fat_cluster_t clst = firstc;	126	fat_cluster_t clst = firstc;
124		127
125	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);	128	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
126	bps = uint16_t_le2host(FAT_BS(bb)->bps);	129	bps = uint16_t_le2host(FAT_BS(bb)->bps);
127	spc = FAT_BS(bb)->spc;	130	spc = FAT_BS(bb)->spc;
128	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);	131	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
129	block_put(bb);	132	block_put(bb);
130		133
131	if (firstc == FAT_CLST_RES0) {	134	if (firstc == FAT_CLST_RES0) {
132	/* No space allocated to the file. */	135	/* No space allocated to the file. */
-		136	if (lastc)
-		137	*lastc = firstc;
133	return 0;	138	return 0;
134	}	139	}
135		140
136	while (clst < FAT_CLST_LAST1) {	141	while (clst < FAT_CLST_LAST1) {
137	unsigned fsec; /* sector offset relative to FAT1 */	142	unsigned fsec; /* sector offset relative to FAT1 */
138	unsigned fidx; /* FAT1 entry index */	143	unsigned fidx; /* FAT1 entry index */
139		144
140	assert(clst >= FAT_CLST_FIRST);	145	assert(clst >= FAT_CLST_FIRST);
-		146	if (lastc)
-		147	lastc = clst; / remember the last cluster */
141	fsec = (clst * sizeof(fat_cluster_t)) / bps;	148	fsec = (clst * sizeof(fat_cluster_t)) / bps;
142	fidx = clst % (bps / sizeof(fat_cluster_t));	149	fidx = clst % (bps / sizeof(fat_cluster_t));
143	/* read FAT1 */	150	/* read FAT1 */
144	b = block_get(dev_handle, rscnt + fsec, bps);	151	b = block_get(dev_handle, rscnt + fsec, bps);
145	clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);	152	clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
146	assert(clst != FAT_CLST_BAD);	153	assert(clst != FAT_CLST_BAD);
147	block_put(b);	154	block_put(b);
148	clusters++;	155	clusters++;
149	}	156	}
150		157
-		158	if (lastc)
-		159	*lastc = clst;
151	return clusters * spc;	160	return clusters * spc;
152	}	161	}
153		162
154	uint16_t fat_bps_get(dev_handle_t dev_handle)	163	uint16_t fat_bps_get(dev_handle_t dev_handle)
155	{	164	{
156	block_t *bb;	165	block_t *bb;
157	uint16_t bps;	166	uint16_t bps;
158		167
159	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);	168	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
160	assert(bb != NULL);	169	assert(bb != NULL);
161	bps = uint16_t_le2host(FAT_BS(bb)->bps);	170	bps = uint16_t_le2host(FAT_BS(bb)->bps);
162	block_put(bb);	171	block_put(bb);
163		172
164	return bps;	173	return bps;
165	}	174	}
166		175
167	/** Fill the gap between EOF and a new file position.	176	/** Fill the gap between EOF and a new file position.
168	*	177	*
169	* @param nodep FAT node with the gap.	178	* @param nodep FAT node with the gap.
170	* @param mcl First cluster in an independent cluster chain that will	179	* @param mcl First cluster in an independent cluster chain that will
171	* be later appended to the end of the node's own cluster	180	* be later appended to the end of the node's own cluster
172	* chain. If pos is still in the last allocated cluster,	181	* chain. If pos is still in the last allocated cluster,
173	* this argument is ignored.	182	* this argument is ignored.
174	* @param pos Position in the last node block.	183	* @param pos Position in the last node block.
175	*/	184	*/
176	void fat_fill_gap(fat_node_t *nodep, fat_cluster_t mcl, off_t pos)	185	void fat_fill_gap(fat_node_t *nodep, fat_cluster_t mcl, off_t pos)
177	{	186	{
178	uint16_t bps;	187	uint16_t bps;
179	unsigned spc;	188	unsigned spc;
180	block_t bb, b;	189	block_t bb, b;
181	off_t o, boundary;	190	off_t o, boundary;
182		191
183	bb = block_get(nodep->idx->dev_handle, BS_BLOCK, BS_SIZE);	192	bb = block_get(nodep->idx->dev_handle, BS_BLOCK, BS_SIZE);
184	bps = uint16_t_le2host(FAT_BS(bb)->bps);	193	bps = uint16_t_le2host(FAT_BS(bb)->bps);
185	spc = FAT_BS(bb)->spc;	194	spc = FAT_BS(bb)->spc;
186	block_put(bb);	195	block_put(bb);
187		196
188	boundary = ROUND_UP(nodep->size, bps * spc);	197	boundary = ROUND_UP(nodep->size, bps * spc);
189		198
190	/* zero out already allocated space */	199	/* zero out already allocated space */
191	for (o = nodep->size - 1; o < pos && o < boundary;	200	for (o = nodep->size - 1; o < pos && o < boundary;
192	o = ALIGN_DOWN(o + bps, bps)) {	201	o = ALIGN_DOWN(o + bps, bps)) {
193	b = fat_block_get(nodep, o / bps);	202	b = fat_block_get(nodep, o / bps);
194	memset(b->data + o % bps, 0, bps - o % bps);	203	memset(b->data + o % bps, 0, bps - o % bps);
195	b->dirty = true; /* need to sync node */	204	b->dirty = true; /* need to sync node */
196	block_put(b);	205	block_put(b);
197	}	206	}
198		207
199	if (o >= pos)	208	if (o >= pos)
200	return;	209	return;
201		210
202	/* zero out the initial part of the new cluster chain */	211	/* zero out the initial part of the new cluster chain */
203	for (o = boundary; o < pos; o += bps) {	212	for (o = boundary; o < pos; o += bps) {
204	b = _fat_block_get(nodep->idx->dev_handle, mcl,	213	b = _fat_block_get(nodep->idx->dev_handle, mcl,
205	(o - boundary) / bps);	214	(o - boundary) / bps);
206	memset(b->data, 0, min(bps, pos - o));	215	memset(b->data, 0, min(bps, pos - o));
207	b->dirty = true; /* need to sync node */	216	b->dirty = true; /* need to sync node */
208	block_put(b);	217	block_put(b);
209	}	218	}
210	}	219	}
211		220
212	void	221	void
213	fat_mark_cluster(dev_handle_t dev_handle, unsigned fatno, fat_cluster_t clst,	222	fat_mark_cluster(dev_handle_t dev_handle, unsigned fatno, fat_cluster_t clst,
214	fat_cluster_t value)	223	fat_cluster_t value)
215	{	224	{
216	block_t bb, blk;	225	block_t bb, blk;
217	uint16_t bps;	226	uint16_t bps;
218	uint16_t rscnt;	227	uint16_t rscnt;
219	uint16_t sf;	228	uint16_t sf;
220	uint8_t fatcnt;	229	uint8_t fatcnt;
221	fat_cluster_t *cp;	230	fat_cluster_t *cp;
222		231
223	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);	232	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
224	bps = uint16_t_le2host(FAT_BS(bb)->bps);	233	bps = uint16_t_le2host(FAT_BS(bb)->bps);
225	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);	234	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
226	sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);	235	sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
227	fatcnt = FAT_BS(bb)->fatcnt;	236	fatcnt = FAT_BS(bb)->fatcnt;
228	block_put(bb);	237	block_put(bb);
229		238
230	assert(fatno < fatcnt);	239	assert(fatno < fatcnt);
231	blk = block_get(dev_handle, rscnt + sf * fatno +	240	blk = block_get(dev_handle, rscnt + sf * fatno +
232	(clst * sizeof(fat_cluster_t)) / bps, bps);	241	(clst * sizeof(fat_cluster_t)) / bps, bps);
233	cp = (fat_cluster_t *)blk->data + clst % (bps / sizeof(fat_cluster_t));	242	cp = (fat_cluster_t *)blk->data + clst % (bps / sizeof(fat_cluster_t));
234	*cp = host2uint16_t_le(value);	243	*cp = host2uint16_t_le(value);
235	blk->dirty = true; /* need to sync block */	244	blk->dirty = true; /* need to sync block */
236	block_put(blk);	245	block_put(blk);
237	}	246	}
238		247
239	void fat_alloc_shadow_clusters(dev_handle_t dev_handle, fat_cluster_t *lifo,	248	void fat_alloc_shadow_clusters(dev_handle_t dev_handle, fat_cluster_t *lifo,
240	unsigned nclsts)	249	unsigned nclsts)
241	{	250	{
242	uint8_t fatcnt;	251	uint8_t fatcnt;
243	uint8_t fatno;	252	uint8_t fatno;
244	unsigned c;	253	unsigned c;
245	block_t *bb;	254	block_t *bb;
246		255
247	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);	256	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
248	fatcnt = FAT_BS(bb)->fatcnt;	257	fatcnt = FAT_BS(bb)->fatcnt;
249	block_put(bb);	258	block_put(bb);
250		259
251	for (fatno = FAT1 + 1; fatno < fatcnt; fatno++) {	260	for (fatno = FAT1 + 1; fatno < fatcnt; fatno++) {
252	for (c = 0; c < nclsts; c++) {	261	for (c = 0; c < nclsts; c++) {
253	fat_mark_cluster(dev_handle, fatno, lifo[c],	262	fat_mark_cluster(dev_handle, fatno, lifo[c],
254	c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);	263	c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);
255	}	264	}
256	}	265	}
257	}	266	}
258		267
259	int	268	int
260	fat_alloc_clusters(dev_handle_t dev_handle, unsigned nclsts, fat_cluster_t *mcl,	269	fat_alloc_clusters(dev_handle_t dev_handle, unsigned nclsts, fat_cluster_t *mcl,
261	fat_cluster_t *lcl)	270	fat_cluster_t *lcl)
262	{	271	{
263	uint16_t bps;	272	uint16_t bps;
264	uint16_t rscnt;	273	uint16_t rscnt;
265	uint16_t sf;	274	uint16_t sf;
266	block_t bb, blk;	275	block_t bb, blk;
267	fat_cluster_t lifo; / stack for storing free cluster numbers */	276	fat_cluster_t lifo; / stack for storing free cluster numbers */
268	unsigned found = 0; /* top of the free cluster number stack */	277	unsigned found = 0; /* top of the free cluster number stack */
269	unsigned b, c, cl;	278	unsigned b, c, cl;
270		279
271	lifo = (fat_cluster_t ) malloc(nclsts sizeof(fat_cluster_t));	280	lifo = (fat_cluster_t ) malloc(nclsts sizeof(fat_cluster_t));
272	if (lifo)	281	if (lifo)
273	return ENOMEM;	282	return ENOMEM;
274		283
275	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);	284	bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
276	bps = uint16_t_le2host(FAT_BS(bb)->bps);	285	bps = uint16_t_le2host(FAT_BS(bb)->bps);
277	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);	286	rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
278	sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);	287	sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
279	block_put(bb);	288	block_put(bb);
280		289
281	/*	290	/*
282	* Search FAT1 for unused clusters.	291	* Search FAT1 for unused clusters.
283	*/	292	*/
284	for (b = 0, cl = 0; b < sf; blk++) {	293	for (b = 0, cl = 0; b < sf; blk++) {
285	blk = block_get(dev_handle, rscnt + b, bps);	294	blk = block_get(dev_handle, rscnt + b, bps);
286	for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {	295	for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {
287	fat_cluster_t clst = (fat_cluster_t )blk->data + c;	296	fat_cluster_t clst = (fat_cluster_t )blk->data + c;
288	if (uint16_t_le2host(*clst) == FAT_CLST_RES0) {	297	if (uint16_t_le2host(*clst) == FAT_CLST_RES0) {
289	/*	298	/*
290	* The cluster is free. Put it into our stack	299	* The cluster is free. Put it into our stack
291	* of found clusters and mark it as non-free.	300	* of found clusters and mark it as non-free.
292	*/	301	*/
293	lifo[found] = cl;	302	lifo[found] = cl;
294	*clst = (found == 0) ?	303	*clst = (found == 0) ?
295	host2uint16_t_le(FAT_CLST_LAST1) :	304	host2uint16_t_le(FAT_CLST_LAST1) :
296	host2uint16_t_le(lifo[found - 1]);	305	host2uint16_t_le(lifo[found - 1]);
297	blk->dirty = true; /* need to sync block */	306	blk->dirty = true; /* need to sync block */
298	if (++found == nclsts) {	307	if (++found == nclsts) {
299	/* we are almost done */	308	/* we are almost done */
300	block_put(blk);	309	block_put(blk);
301	/* update the shadow copies of FAT */	310	/* update the shadow copies of FAT */
302	fat_alloc_shadow_clusters(dev_handle,	311	fat_alloc_shadow_clusters(dev_handle,
303	lifo, nclsts);	312	lifo, nclsts);
304	*mcl = lifo[found - 1];	313	*mcl = lifo[found - 1];
305	*lcl = lifo[0];	314	*lcl = lifo[0];
306	free(lifo);	315	free(lifo);
307	return EOK;	316	return EOK;
308	}	317	}
309	}	318	}
310	}	319	}
311	block_put(blk);	320	block_put(blk);
312	}	321	}
313		322
314	/*	323	/*
315	* We could not find enough clusters. Now we need to free the clusters	324	* We could not find enough clusters. Now we need to free the clusters
316	* we have allocated so far.	325	* we have allocated so far.
317	*/	326	*/
318	while (found--)	327	while (found--)
319	fat_mark_cluster(dev_handle, FAT1, lifo[found], FAT_CLST_RES0);	328	fat_mark_cluster(dev_handle, FAT1, lifo[found], FAT_CLST_RES0);
320		329
321	free(lifo);	330	free(lifo);
322	return ENOSPC;	331	return ENOSPC;
323	}	332	}
324		333
325	void fat_append_clusters(fat_node_t *nodep, fat_cluster_t mcl)	334	void fat_append_clusters(fat_node_t *nodep, fat_cluster_t mcl)
326	{	335	{
-		336	block_t *bb;
-		337	fat_cluster_t lcl;
-		338	uint8_t fatcnt, fatno;
-		339
-		340	if (_fat_blcks_get(nodep->idx->dev_handle, nodep->firstc, &lcl) == 0) {
-		341	nodep->firstc = host2uint16_t_le(mcl);
-		342	nodep->dirty = true; /* need to sync node */
-		343	return;
-		344	}
-		345
-		346	bb = block_get(nodep->idx->dev_handle, BS_BLOCK, BS_SIZE);
-		347	fatcnt = FAT_BS(bb)->fatcnt;
-		348	block_put(bb);
-		349
-		350	for (fatno = FAT1; fatno < fatcnt; fatno++)
-		351	fat_mark_cluster(nodep->idx->dev_handle, fatno, lcl, mcl);
327	}	352	}
328		353
329	/**	354	/**
330	* @}	355	* @}
331	*/	356	*/
332		357

Subversion Repositories HelenOS

(root)/trunk/uspace/srv/fs/fat/fat_fat.c @ 4608 – Rev 3512 → 3513