blob: 467a26171cd96e547d8f50c464727ff9e5afade5 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * partition.c
3 *
4 * PURPOSE
5 * Partition handling routines for the OSTA-UDF(tm) filesystem.
6 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * 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
31inline uint32_t udf_get_pblock(struct super_block *sb, uint32_t block, uint16_t partition, uint32_t offset)
32{
33 if (partition >= UDF_SB_NUMPARTS(sb))
34 {
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
45uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block, uint16_t partition, uint32_t offset)
46{
47 struct buffer_head *bh = NULL;
48 uint32_t newblock;
49 uint32_t index;
50 uint32_t loc;
51
52 index = (sb->s_blocksize - UDF_SB_TYPEVIRT(sb,partition).s_start_offset) / sizeof(uint32_t);
53
54 if (block > UDF_SB_TYPEVIRT(sb,partition).s_num_entries)
55 {
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 {
63 block -= index;
64 newblock = 1 + (block / (sb->s_blocksize / sizeof(uint32_t)));
65 index = block % (sb->s_blocksize / sizeof(uint32_t));
66 }
67 else
68 {
69 newblock = 0;
70 index = UDF_SB_TYPEVIRT(sb,partition).s_start_offset / sizeof(uint32_t) + block;
71 }
72
73 loc = udf_block_map(UDF_SB_VAT(sb), newblock);
74
75 if (!(bh = sb_bread(sb, loc)))
76 {
77 udf_debug("get_pblock(UDF_VIRTUAL_MAP:%p,%d,%d) VAT: %d[%d]\n",
78 sb, block, partition, loc, index);
79 return 0xFFFFFFFF;
80 }
81
82 loc = le32_to_cpu(((__le32 *)bh->b_data)[index]);
83
Jan Kara3bf25cb2007-05-08 00:35:16 -070084 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
86 if (UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum == partition)
87 {
88 udf_debug("recursive call to udf_get_pblock!\n");
89 return 0xFFFFFFFF;
90 }
91
92 return udf_get_pblock(sb, loc, UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum, offset);
93}
94
95inline uint32_t udf_get_pblock_virt20(struct super_block *sb, uint32_t block, uint16_t partition, uint32_t offset)
96{
97 return udf_get_pblock_virt15(sb, block, partition, offset);
98}
99
100uint32_t udf_get_pblock_spar15(struct super_block *sb, uint32_t block, uint16_t partition, uint32_t offset)
101{
102 int i;
103 struct sparingTable *st = NULL;
104 uint32_t packet = (block + offset) & ~(UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1);
105
106 for (i=0; i<4; i++)
107 {
108 if (UDF_SB_TYPESPAR(sb,partition).s_spar_map[i] != NULL)
109 {
110 st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,partition).s_spar_map[i]->b_data;
111 break;
112 }
113 }
114
115 if (st)
116 {
117 for (i=0; i<le16_to_cpu(st->reallocationTableLen); i++)
118 {
119 if (le32_to_cpu(st->mapEntry[i].origLocation) >= 0xFFFFFFF0)
120 break;
121 else if (le32_to_cpu(st->mapEntry[i].origLocation) == packet)
122 {
123 return le32_to_cpu(st->mapEntry[i].mappedLocation) +
124 ((block + offset) & (UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1));
125 }
126 else if (le32_to_cpu(st->mapEntry[i].origLocation) > packet)
127 break;
128 }
129 }
130 return UDF_SB_PARTROOT(sb,partition) + block + offset;
131}
132
133int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
134{
135 struct udf_sparing_data *sdata;
136 struct sparingTable *st = NULL;
137 struct sparingEntry mapEntry;
138 uint32_t packet;
139 int i, j, k, l;
140
141 for (i=0; i<UDF_SB_NUMPARTS(sb); i++)
142 {
143 if (old_block > UDF_SB_PARTROOT(sb,i) &&
144 old_block < UDF_SB_PARTROOT(sb,i) + UDF_SB_PARTLEN(sb,i))
145 {
146 sdata = &UDF_SB_TYPESPAR(sb,i);
147 packet = (old_block - UDF_SB_PARTROOT(sb,i)) & ~(sdata->s_packet_len - 1);
148
149 for (j=0; j<4; j++)
150 {
151 if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL)
152 {
153 st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
154 break;
155 }
156 }
157
158 if (!st)
159 return 1;
160
161 for (k=0; k<le16_to_cpu(st->reallocationTableLen); k++)
162 {
163 if (le32_to_cpu(st->mapEntry[k].origLocation) == 0xFFFFFFFF)
164 {
165 for (; j<4; j++)
166 {
167 if (sdata->s_spar_map[j])
168 {
169 st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
170 st->mapEntry[k].origLocation = cpu_to_le32(packet);
171 udf_update_tag((char *)st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) * sizeof(struct sparingEntry));
172 mark_buffer_dirty(sdata->s_spar_map[j]);
173 }
174 }
175 *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
176 ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
177 return 0;
178 }
179 else if (le32_to_cpu(st->mapEntry[k].origLocation) == packet)
180 {
181 *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
182 ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
183 return 0;
184 }
185 else if (le32_to_cpu(st->mapEntry[k].origLocation) > packet)
186 break;
187 }
188 for (l=k; l<le16_to_cpu(st->reallocationTableLen); l++)
189 {
190 if (le32_to_cpu(st->mapEntry[l].origLocation) == 0xFFFFFFFF)
191 {
192 for (; j<4; j++)
193 {
194 if (sdata->s_spar_map[j])
195 {
196 st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
197 mapEntry = st->mapEntry[l];
198 mapEntry.origLocation = cpu_to_le32(packet);
199 memmove(&st->mapEntry[k+1], &st->mapEntry[k], (l-k)*sizeof(struct sparingEntry));
200 st->mapEntry[k] = mapEntry;
201 udf_update_tag((char *)st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) * sizeof(struct sparingEntry));
202 mark_buffer_dirty(sdata->s_spar_map[j]);
203 }
204 }
205 *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
206 ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
207 return 0;
208 }
209 }
210 return 1;
211 }
212 }
213 if (i == UDF_SB_NUMPARTS(sb))
214 {
215 /* outside of partitions */
216 /* for now, fail =) */
217 return 1;
218 }
219
220 return 0;
221}