1 /* 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/slab.h> 28 #include <linux/buffer_head.h> 29 30 uint32_t udf_get_pblock(struct super_block *sb, uint32_t block, 31 uint16_t partition, uint32_t offset) 32 { 33 struct udf_sb_info *sbi = UDF_SB(sb); 34 struct udf_part_map *map; 35 if (partition >= sbi->s_partitions) { 36 udf_debug("block=%d, partition=%d, offset=%d: " 37 "invalid partition\n", block, partition, offset); 38 return 0xFFFFFFFF; 39 } 40 map = &sbi->s_partmaps[partition]; 41 if (map->s_partition_func) 42 return map->s_partition_func(sb, block, partition, offset); 43 else 44 return map->s_partition_root + block + offset; 45 } 46 47 uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block, 48 uint16_t partition, uint32_t offset) 49 { 50 struct buffer_head *bh = NULL; 51 uint32_t newblock; 52 uint32_t index; 53 uint32_t loc; 54 struct udf_sb_info *sbi = UDF_SB(sb); 55 struct udf_part_map *map; 56 struct udf_virtual_data *vdata; 57 struct udf_inode_info *iinfo = UDF_I(sbi->s_vat_inode); 58 59 map = &sbi->s_partmaps[partition]; 60 vdata = &map->s_type_specific.s_virtual; 61 62 if (block > vdata->s_num_entries) { 63 udf_debug("Trying to access block beyond end of VAT " 64 "(%d max %d)\n", block, vdata->s_num_entries); 65 return 0xFFFFFFFF; 66 } 67 68 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { 69 loc = le32_to_cpu(((__le32 *)(iinfo->i_ext.i_data + 70 vdata->s_start_offset))[block]); 71 goto translate; 72 } 73 index = (sb->s_blocksize - vdata->s_start_offset) / sizeof(uint32_t); 74 if (block >= index) { 75 block -= index; 76 newblock = 1 + (block / (sb->s_blocksize / sizeof(uint32_t))); 77 index = block % (sb->s_blocksize / sizeof(uint32_t)); 78 } else { 79 newblock = 0; 80 index = vdata->s_start_offset / sizeof(uint32_t) + block; 81 } 82 83 loc = udf_block_map(sbi->s_vat_inode, newblock); 84 85 bh = sb_bread(sb, loc); 86 if (!bh) { 87 udf_debug("get_pblock(UDF_VIRTUAL_MAP:%p,%d,%d) VAT: %d[%d]\n", 88 sb, block, partition, loc, index); 89 return 0xFFFFFFFF; 90 } 91 92 loc = le32_to_cpu(((__le32 *)bh->b_data)[index]); 93 94 brelse(bh); 95 96 translate: 97 if (iinfo->i_location.partitionReferenceNum == partition) { 98 udf_debug("recursive call to udf_get_pblock!\n"); 99 return 0xFFFFFFFF; 100 } 101 102 return udf_get_pblock(sb, loc, 103 iinfo->i_location.partitionReferenceNum, 104 offset); 105 } 106 107 inline uint32_t udf_get_pblock_virt20(struct super_block *sb, uint32_t block, 108 uint16_t partition, uint32_t offset) 109 { 110 return udf_get_pblock_virt15(sb, block, partition, offset); 111 } 112 113 uint32_t udf_get_pblock_spar15(struct super_block *sb, uint32_t block, 114 uint16_t partition, uint32_t offset) 115 { 116 int i; 117 struct sparingTable *st = NULL; 118 struct udf_sb_info *sbi = UDF_SB(sb); 119 struct udf_part_map *map; 120 uint32_t packet; 121 struct udf_sparing_data *sdata; 122 123 map = &sbi->s_partmaps[partition]; 124 sdata = &map->s_type_specific.s_sparing; 125 packet = (block + offset) & ~(sdata->s_packet_len - 1); 126 127 for (i = 0; i < 4; i++) { 128 if (sdata->s_spar_map[i] != NULL) { 129 st = (struct sparingTable *) 130 sdata->s_spar_map[i]->b_data; 131 break; 132 } 133 } 134 135 if (st) { 136 for (i = 0; i < le16_to_cpu(st->reallocationTableLen); i++) { 137 struct sparingEntry *entry = &st->mapEntry[i]; 138 u32 origLoc = le32_to_cpu(entry->origLocation); 139 if (origLoc >= 0xFFFFFFF0) 140 break; 141 else if (origLoc == packet) 142 return le32_to_cpu(entry->mappedLocation) + 143 ((block + offset) & 144 (sdata->s_packet_len - 1)); 145 else if (origLoc > packet) 146 break; 147 } 148 } 149 150 return map->s_partition_root + block + offset; 151 } 152 153 int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block) 154 { 155 struct udf_sparing_data *sdata; 156 struct sparingTable *st = NULL; 157 struct sparingEntry mapEntry; 158 uint32_t packet; 159 int i, j, k, l; 160 struct udf_sb_info *sbi = UDF_SB(sb); 161 u16 reallocationTableLen; 162 struct buffer_head *bh; 163 164 for (i = 0; i < sbi->s_partitions; i++) { 165 struct udf_part_map *map = &sbi->s_partmaps[i]; 166 if (old_block > map->s_partition_root && 167 old_block < map->s_partition_root + map->s_partition_len) { 168 sdata = &map->s_type_specific.s_sparing; 169 packet = (old_block - map->s_partition_root) & 170 ~(sdata->s_packet_len - 1); 171 172 for (j = 0; j < 4; j++) 173 if (sdata->s_spar_map[j] != NULL) { 174 st = (struct sparingTable *) 175 sdata->s_spar_map[j]->b_data; 176 break; 177 } 178 179 if (!st) 180 return 1; 181 182 reallocationTableLen = 183 le16_to_cpu(st->reallocationTableLen); 184 for (k = 0; k < reallocationTableLen; k++) { 185 struct sparingEntry *entry = &st->mapEntry[k]; 186 u32 origLoc = le32_to_cpu(entry->origLocation); 187 188 if (origLoc == 0xFFFFFFFF) { 189 for (; j < 4; j++) { 190 int len; 191 bh = sdata->s_spar_map[j]; 192 if (!bh) 193 continue; 194 195 st = (struct sparingTable *) 196 bh->b_data; 197 entry->origLocation = 198 cpu_to_le32(packet); 199 len = 200 sizeof(struct sparingTable) + 201 reallocationTableLen * 202 sizeof(struct sparingEntry); 203 udf_update_tag((char *)st, len); 204 mark_buffer_dirty(bh); 205 } 206 *new_block = le32_to_cpu( 207 entry->mappedLocation) + 208 ((old_block - 209 map->s_partition_root) & 210 (sdata->s_packet_len - 1)); 211 return 0; 212 } else if (origLoc == packet) { 213 *new_block = le32_to_cpu( 214 entry->mappedLocation) + 215 ((old_block - 216 map->s_partition_root) & 217 (sdata->s_packet_len - 1)); 218 return 0; 219 } else if (origLoc > packet) 220 break; 221 } 222 223 for (l = k; l < reallocationTableLen; l++) { 224 struct sparingEntry *entry = &st->mapEntry[l]; 225 u32 origLoc = le32_to_cpu(entry->origLocation); 226 227 if (origLoc != 0xFFFFFFFF) 228 continue; 229 230 for (; j < 4; j++) { 231 bh = sdata->s_spar_map[j]; 232 if (!bh) 233 continue; 234 235 st = (struct sparingTable *)bh->b_data; 236 mapEntry = st->mapEntry[l]; 237 mapEntry.origLocation = 238 cpu_to_le32(packet); 239 memmove(&st->mapEntry[k + 1], 240 &st->mapEntry[k], 241 (l - k) * 242 sizeof(struct sparingEntry)); 243 st->mapEntry[k] = mapEntry; 244 udf_update_tag((char *)st, 245 sizeof(struct sparingTable) + 246 reallocationTableLen * 247 sizeof(struct sparingEntry)); 248 mark_buffer_dirty(bh); 249 } 250 *new_block = 251 le32_to_cpu( 252 st->mapEntry[k].mappedLocation) + 253 ((old_block - map->s_partition_root) & 254 (sdata->s_packet_len - 1)); 255 return 0; 256 } 257 258 return 1; 259 } /* if old_block */ 260 } 261 262 if (i == sbi->s_partitions) { 263 /* outside of partitions */ 264 /* for now, fail =) */ 265 return 1; 266 } 267 268 return 0; 269 } 270 271 static uint32_t udf_try_read_meta(struct inode *inode, uint32_t block, 272 uint16_t partition, uint32_t offset) 273 { 274 struct super_block *sb = inode->i_sb; 275 struct udf_part_map *map; 276 struct kernel_lb_addr eloc; 277 uint32_t elen; 278 sector_t ext_offset; 279 struct extent_position epos = {}; 280 uint32_t phyblock; 281 282 if (inode_bmap(inode, block, &epos, &eloc, &elen, &ext_offset) != 283 (EXT_RECORDED_ALLOCATED >> 30)) 284 phyblock = 0xFFFFFFFF; 285 else { 286 map = &UDF_SB(sb)->s_partmaps[partition]; 287 /* map to sparable/physical partition desc */ 288 phyblock = udf_get_pblock(sb, eloc.logicalBlockNum, 289 map->s_partition_num, ext_offset + offset); 290 } 291 292 brelse(epos.bh); 293 return phyblock; 294 } 295 296 uint32_t udf_get_pblock_meta25(struct super_block *sb, uint32_t block, 297 uint16_t partition, uint32_t offset) 298 { 299 struct udf_sb_info *sbi = UDF_SB(sb); 300 struct udf_part_map *map; 301 struct udf_meta_data *mdata; 302 uint32_t retblk; 303 struct inode *inode; 304 305 udf_debug("READING from METADATA\n"); 306 307 map = &sbi->s_partmaps[partition]; 308 mdata = &map->s_type_specific.s_metadata; 309 inode = mdata->s_metadata_fe ? : mdata->s_mirror_fe; 310 311 /* We shouldn't mount such media... */ 312 BUG_ON(!inode); 313 retblk = udf_try_read_meta(inode, block, partition, offset); 314 if (retblk == 0xFFFFFFFF) { 315 udf_warning(sb, __func__, "error reading from METADATA, " 316 "trying to read from MIRROR"); 317 inode = mdata->s_mirror_fe; 318 if (!inode) 319 return 0xFFFFFFFF; 320 retblk = udf_try_read_meta(inode, block, partition, offset); 321 } 322 323 return retblk; 324 } 325