URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [fs/] [udf/] [partition.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 * partition.c
 *
 * PURPOSE
 *      Partition handling routines for the OSTA-UDF(tm) filesystem.
 *
 * COPYRIGHT
 *      This file is distributed under the terms of the GNU General Public
 *      License (GPL). Copies of the GPL can be obtained from:
 *              ftp://prep.ai.mit.edu/pub/gnu/GPL
 *      Each contributing author retains all rights to their own work.
 *
 *  (C) 1998-2001 Ben Fennema
 *
 * HISTORY
 *
 * 12/06/98 blf  Created file.
 *
 */
 
#include "udfdecl.h"
#include "udf_sb.h"
#include "udf_i.h"
 
#include <linux/fs.h>
#include <linux/string.h>
#include <linux/udf_fs.h>
#include <linux/slab.h>
#include <linux/buffer_head.h>
 
inline uint32_t udf_get_pblock(struct super_block *sb, uint32_t block,
                               uint16_t partition, uint32_t offset)
{
        if (partition >= UDF_SB_NUMPARTS(sb)) {
                udf_debug("block=%d, partition=%d, offset=%d: invalid partition\n",
                          block, partition, offset);
                return 0xFFFFFFFF;
        }
        if (UDF_SB_PARTFUNC(sb, partition))
                return UDF_SB_PARTFUNC(sb, partition)(sb, block, partition, offset);
        else
                return UDF_SB_PARTROOT(sb, partition) + block + offset;
}
 
uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
                               uint16_t partition, uint32_t offset)
{
        struct buffer_head *bh = NULL;
        uint32_t newblock;
        uint32_t index;
        uint32_t loc;
 
        index = (sb->s_blocksize - UDF_SB_TYPEVIRT(sb,partition).s_start_offset) / sizeof(uint32_t);
 
        if (block > UDF_SB_TYPEVIRT(sb,partition).s_num_entries) {
                udf_debug("Trying to access block beyond end of VAT (%d max %d)\n",
                          block, UDF_SB_TYPEVIRT(sb,partition).s_num_entries);
                return 0xFFFFFFFF;
        }
 
        if (block >= index) {
                block -= index;
                newblock = 1 + (block / (sb->s_blocksize / sizeof(uint32_t)));
                index = block % (sb->s_blocksize / sizeof(uint32_t));
        } else {
                newblock = 0;
                index = UDF_SB_TYPEVIRT(sb,partition).s_start_offset / sizeof(uint32_t) + block;
        }
 
        loc = udf_block_map(UDF_SB_VAT(sb), newblock);
 
        if (!(bh = sb_bread(sb, loc))) {
                udf_debug("get_pblock(UDF_VIRTUAL_MAP:%p,%d,%d) VAT: %d[%d]\n",
                          sb, block, partition, loc, index);
                return 0xFFFFFFFF;
        }
 
        loc = le32_to_cpu(((__le32 *)bh->b_data)[index]);
 
        brelse(bh);
 
        if (UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum == partition) {
                udf_debug("recursive call to udf_get_pblock!\n");
                return 0xFFFFFFFF;
        }
 
        return udf_get_pblock(sb, loc,
                              UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum,
                              offset);
}
 
inline uint32_t udf_get_pblock_virt20(struct super_block * sb, uint32_t block,
                                      uint16_t partition, uint32_t offset)
{
        return udf_get_pblock_virt15(sb, block, partition, offset);
}
 
uint32_t udf_get_pblock_spar15(struct super_block * sb, uint32_t block,
                               uint16_t partition, uint32_t offset)
{
        int i;
        struct sparingTable *st = NULL;
        uint32_t packet = (block + offset) & ~(UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1);
 
        for (i = 0; i < 4; i++) {
                if (UDF_SB_TYPESPAR(sb,partition).s_spar_map[i] != NULL) {
                        st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,partition).s_spar_map[i]->b_data;
                        break;
                }
        }
 
        if (st) {
                for (i = 0; i < le16_to_cpu(st->reallocationTableLen); i++) {
                        if (le32_to_cpu(st->mapEntry[i].origLocation) >= 0xFFFFFFF0) {
                                break;
                        } else if (le32_to_cpu(st->mapEntry[i].origLocation) == packet) {
                                return le32_to_cpu(st->mapEntry[i].mappedLocation) +
                                        ((block + offset) & (UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1));
                        } else if (le32_to_cpu(st->mapEntry[i].origLocation) > packet) {
                                break;
                        }
                }
        }
 
        return UDF_SB_PARTROOT(sb,partition) + block + offset;
}
 
int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
{
        struct udf_sparing_data *sdata;
        struct sparingTable *st = NULL;
        struct sparingEntry mapEntry;
        uint32_t packet;
        int i, j, k, l;
 
        for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
                if (old_block > UDF_SB_PARTROOT(sb,i) &&
                    old_block < UDF_SB_PARTROOT(sb,i) + UDF_SB_PARTLEN(sb,i)) {
                        sdata = &UDF_SB_TYPESPAR(sb,i);
                        packet = (old_block - UDF_SB_PARTROOT(sb,i)) & ~(sdata->s_packet_len - 1);
 
                        for (j = 0; j < 4; j++) {
                                if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL) {
                                        st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
                                        break;
                                }
                        }
 
                        if (!st)
                                return 1;
 
                        for (k = 0; k < le16_to_cpu(st->reallocationTableLen); k++) {
                                if (le32_to_cpu(st->mapEntry[k].origLocation) == 0xFFFFFFFF) {
                                        for (; j < 4; j++) {
                                                if (sdata->s_spar_map[j]) {
                                                        st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
                                                        st->mapEntry[k].origLocation = cpu_to_le32(packet);
                                                        udf_update_tag((char *)st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) * sizeof(struct sparingEntry));
                                                        mark_buffer_dirty(sdata->s_spar_map[j]);
                                                }
                                        }
                                        *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
                                                ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
                                        return 0;
                                } else if (le32_to_cpu(st->mapEntry[k].origLocation) == packet) {
                                        *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
                                                ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
                                        return 0;
                                } else if (le32_to_cpu(st->mapEntry[k].origLocation) > packet) {
                                        break;
                                }
                        }
 
                        for (l = k; l < le16_to_cpu(st->reallocationTableLen); l++) {
                                if (le32_to_cpu(st->mapEntry[l].origLocation) == 0xFFFFFFFF) {
                                        for (; j < 4; j++) {
                                                if (sdata->s_spar_map[j]) {
                                                        st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
                                                        mapEntry = st->mapEntry[l];
                                                        mapEntry.origLocation = cpu_to_le32(packet);
                                                        memmove(&st->mapEntry[k + 1], &st->mapEntry[k], (l - k) * sizeof(struct sparingEntry));
                                                        st->mapEntry[k] = mapEntry;
                                                        udf_update_tag((char *)st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) * sizeof(struct sparingEntry));
                                                        mark_buffer_dirty(sdata->s_spar_map[j]);
                                                }
                                        }
                                        *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
                                                ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
                                        return 0;
                                }
                        }
 
                        return 1;
                } /* if old_block */
        }
 
        if (i == UDF_SB_NUMPARTS(sb)) {
                /* outside of partitions */
                /* for now, fail =) */
                return 1;
        }
 
        return 0;
}

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [fs/] [udf/] [partition.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* partition.c`
3			`*`
4			`* PURPOSE`
5			`* Partition handling routines for the OSTA-UDF(tm) filesystem.`
6			`*`
7			`* COPYRIGHT`
8			`* This file is distributed under the terms of the GNU General Public`
9			`* License (GPL). Copies of the GPL can be obtained from:`
10			`* ftp://prep.ai.mit.edu/pub/gnu/GPL`
11			`* Each contributing author retains all rights to their own work.`
12			`*`
13			`* (C) 1998-2001 Ben Fennema`
14			`*`
15			`* HISTORY`
16			`*`
17			`* 12/06/98 blf Created file.`
18			`*`
19			`*/`
20
21			`#include "udfdecl.h"`
22			`#include "udf_sb.h"`
23			`#include "udf_i.h"`
24
25			`#include <linux/fs.h>`
26			`#include <linux/string.h>`
27			`#include <linux/udf_fs.h>`
28			`#include <linux/slab.h>`
29			`#include <linux/buffer_head.h>`
30
31			`inline uint32_t udf_get_pblock(struct super_block *sb, uint32_t block,`
32			`uint16_t partition, uint32_t offset)`
33			`{`
34			`if (partition >= UDF_SB_NUMPARTS(sb)) {`
35			`udf_debug("block=%d, partition=%d, offset=%d: invalid partition\n",`
36			`block, partition, offset);`
37			`return 0xFFFFFFFF;`
38			`}`
39			`if (UDF_SB_PARTFUNC(sb, partition))`
40			`return UDF_SB_PARTFUNC(sb, partition)(sb, block, partition, offset);`
41			`else`
42			`return UDF_SB_PARTROOT(sb, partition) + block + offset;`
43			`}`
44
45			`uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,`
46			`uint16_t partition, uint32_t offset)`
47			`{`
48			`struct buffer_head *bh = NULL;`
49			`uint32_t newblock;`
50			`uint32_t index;`
51			`uint32_t loc;`
52
53			`index = (sb->s_blocksize - UDF_SB_TYPEVIRT(sb,partition).s_start_offset) / sizeof(uint32_t);`
54
55			`if (block > UDF_SB_TYPEVIRT(sb,partition).s_num_entries) {`
56			`udf_debug("Trying to access block beyond end of VAT (%d max %d)\n",`
57			`block, UDF_SB_TYPEVIRT(sb,partition).s_num_entries);`
58			`return 0xFFFFFFFF;`
59			`}`
60
61			`if (block >= index) {`
62			`block -= index;`
63			`newblock = 1 + (block / (sb->s_blocksize / sizeof(uint32_t)));`
64			`index = block % (sb->s_blocksize / sizeof(uint32_t));`
65			`} else {`
66			`newblock = 0;`
67			`index = UDF_SB_TYPEVIRT(sb,partition).s_start_offset / sizeof(uint32_t) + block;`
68			`}`
69
70			`loc = udf_block_map(UDF_SB_VAT(sb), newblock);`
71
72			`if (!(bh = sb_bread(sb, loc))) {`
73			`udf_debug("get_pblock(UDF_VIRTUAL_MAP:%p,%d,%d) VAT: %d[%d]\n",`
74			`sb, block, partition, loc, index);`
75			`return 0xFFFFFFFF;`
76			`}`
77
78			`loc = le32_to_cpu(((__le32 *)bh->b_data)[index]);`
79
80			`brelse(bh);`
81
82			`if (UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum == partition) {`
83			`udf_debug("recursive call to udf_get_pblock!\n");`
84			`return 0xFFFFFFFF;`
85			`}`
86
87			`return udf_get_pblock(sb, loc,`
88			`UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum,`
89			`offset);`
90			`}`
91
92			`inline uint32_t udf_get_pblock_virt20(struct super_block * sb, uint32_t block,`
93			`uint16_t partition, uint32_t offset)`
94			`{`
95			`return udf_get_pblock_virt15(sb, block, partition, offset);`
96			`}`
97
98			`uint32_t udf_get_pblock_spar15(struct super_block * sb, uint32_t block,`
99			`uint16_t partition, uint32_t offset)`
100			`{`
101			`int i;`
102			`struct sparingTable *st = NULL;`
103			`uint32_t packet = (block + offset) & ~(UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1);`
104
105			`for (i = 0; i < 4; i++) {`
106			`if (UDF_SB_TYPESPAR(sb,partition).s_spar_map[i] != NULL) {`
107			`st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,partition).s_spar_map[i]->b_data;`
108			`break;`
109			`}`
110			`}`
111
112			`if (st) {`
113			`for (i = 0; i < le16_to_cpu(st->reallocationTableLen); i++) {`
114			`if (le32_to_cpu(st->mapEntry[i].origLocation) >= 0xFFFFFFF0) {`
115			`break;`
116			`} else if (le32_to_cpu(st->mapEntry[i].origLocation) == packet) {`
117			`return le32_to_cpu(st->mapEntry[i].mappedLocation) +`
118			`((block + offset) & (UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1));`
119			`} else if (le32_to_cpu(st->mapEntry[i].origLocation) > packet) {`
120			`break;`
121			`}`
122			`}`
123			`}`
124
125			`return UDF_SB_PARTROOT(sb,partition) + block + offset;`
126			`}`
127
128			`int udf_relocate_blocks(struct super_block sb, long old_block, long new_block)`
129			`{`
130			`struct udf_sparing_data *sdata;`
131			`struct sparingTable *st = NULL;`
132			`struct sparingEntry mapEntry;`
133			`uint32_t packet;`
134			`int i, j, k, l;`
135
136			`for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {`
137			`if (old_block > UDF_SB_PARTROOT(sb,i) &&`
138			`old_block < UDF_SB_PARTROOT(sb,i) + UDF_SB_PARTLEN(sb,i)) {`
139			`sdata = &UDF_SB_TYPESPAR(sb,i);`
140			`packet = (old_block - UDF_SB_PARTROOT(sb,i)) & ~(sdata->s_packet_len - 1);`
141
142			`for (j = 0; j < 4; j++) {`
143			`if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL) {`
144			`st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;`
145			`break;`
146			`}`
147			`}`
148
149			`if (!st)`
150			`return 1;`
151
152			`for (k = 0; k < le16_to_cpu(st->reallocationTableLen); k++) {`
153			`if (le32_to_cpu(st->mapEntry[k].origLocation) == 0xFFFFFFFF) {`
154			`for (; j < 4; j++) {`
155			`if (sdata->s_spar_map[j]) {`
156			`st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;`
157			`st->mapEntry[k].origLocation = cpu_to_le32(packet);`
158			`udf_update_tag((char )st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) sizeof(struct sparingEntry));`
159			`mark_buffer_dirty(sdata->s_spar_map[j]);`
160			`}`
161			`}`
162			`*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +`
163			`((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));`
164			`return 0;`
165			`} else if (le32_to_cpu(st->mapEntry[k].origLocation) == packet) {`
166			`*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +`
167			`((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));`
168			`return 0;`
169			`} else if (le32_to_cpu(st->mapEntry[k].origLocation) > packet) {`
170			`break;`
171			`}`
172			`}`
173
174			`for (l = k; l < le16_to_cpu(st->reallocationTableLen); l++) {`
175			`if (le32_to_cpu(st->mapEntry[l].origLocation) == 0xFFFFFFFF) {`
176			`for (; j < 4; j++) {`
177			`if (sdata->s_spar_map[j]) {`
178			`st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;`
179			`mapEntry = st->mapEntry[l];`
180			`mapEntry.origLocation = cpu_to_le32(packet);`
181			`memmove(&st->mapEntry[k + 1], &st->mapEntry[k], (l - k) * sizeof(struct sparingEntry));`
182			`st->mapEntry[k] = mapEntry;`
183			`udf_update_tag((char )st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) sizeof(struct sparingEntry));`
184			`mark_buffer_dirty(sdata->s_spar_map[j]);`
185			`}`
186			`}`
187			`*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +`
188			`((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));`
189			`return 0;`
190			`}`
191			`}`
192
193			`return 1;`
194			`} /* if old_block */`
195			`}`
196
197			`if (i == UDF_SB_NUMPARTS(sb)) {`
198			`/* outside of partitions */`
199			`/* for now, fail =) */`
200			`return 1;`
201			`}`
202
203			`return 0;`
204			`}`