1 /* libs/diskconfig/diskconfig.c 2 * 3 * Copyright 2008, The Android Open Source Project 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 #define LOG_TAG "config_mbr" 19 #include <stdint.h> 20 #include <stdlib.h> 21 #include <string.h> 22 #include <stdio.h> 23 24 #include <cutils/log.h> 25 26 #include <diskconfig/diskconfig.h> 27 28 29 /* start and len are in LBA units */ 30 static void 31 cfg_pentry(struct pc_partition *pentry, uint8_t status, uint8_t type, 32 uint32_t start, uint32_t len) 33 { 34 if (len > 0) { 35 /* seems that somes BIOSens can get wedged on boot while verifying 36 * the mbr if these are 0 */ 37 memset(&pentry->start, 0xff, sizeof(struct chs)); 38 memset(&pentry->end, 0xff, sizeof(struct chs)); 39 } else { 40 /* zero out the c/h/s entries.. they are not used */ 41 memset(&pentry->start, 0, sizeof(struct chs)); 42 memset(&pentry->end, 0, sizeof(struct chs)); 43 } 44 45 pentry->status = status; 46 pentry->type = type; 47 pentry->start_lba = start; 48 pentry->len_lba = len; 49 50 ALOGI("Configuring pentry. status=0x%x type=0x%x start_lba=%u len_lba=%u", 51 pentry->status, pentry->type, pentry->start_lba, pentry->len_lba); 52 } 53 54 55 static inline uint32_t 56 kb_to_lba(uint32_t len_kb, uint32_t sect_size) 57 { 58 uint64_t lba; 59 60 lba = (uint64_t)len_kb * 1024; 61 /* bump it up to the next LBA boundary just in case */ 62 lba = (lba + (uint64_t)sect_size - 1) & ~((uint64_t)sect_size - 1); 63 lba /= (uint64_t)sect_size; 64 if (lba >= 0xffffffffULL) 65 ALOGE("Error converting kb -> lba. 32bit overflow, expect weirdness"); 66 return (uint32_t)(lba & 0xffffffffULL); 67 } 68 69 70 static struct write_list * 71 mk_pri_pentry(struct disk_info *dinfo, struct part_info *pinfo, int pnum, 72 uint32_t *lba) 73 { 74 struct write_list *item; 75 struct pc_partition *pentry; 76 77 if (pnum >= PC_NUM_BOOT_RECORD_PARTS) { 78 ALOGE("Maximum number of primary partition exceeded."); 79 return NULL; 80 } 81 82 if (!(item = alloc_wl(sizeof(struct pc_partition)))) { 83 ALOGE("Unable to allocate memory for partition entry."); 84 return NULL; 85 } 86 87 { 88 /* DO NOT DEREFERENCE */ 89 struct pc_boot_record *mbr = (void *)PC_MBR_DISK_OFFSET; 90 /* grab the offset in mbr where to write this partition entry. */ 91 item->offset = (loff_t)((uintptr_t)((uint8_t *)(&mbr->ptable[pnum]))); 92 } 93 94 pentry = (struct pc_partition *) &item->data; 95 96 /* need a standard primary partition entry */ 97 if (pinfo) { 98 /* need this to be 64 bit in case len_kb is large */ 99 uint64_t len_lba; 100 101 if (pinfo->len_kb != (uint32_t)-1) { 102 /* bump it up to the next LBA boundary just in case */ 103 len_lba = ((uint64_t)pinfo->len_kb * 1024); 104 len_lba += ((uint64_t)dinfo->sect_size - 1); 105 len_lba &= ~((uint64_t)dinfo->sect_size - 1); 106 len_lba /= (uint64_t)dinfo->sect_size; 107 } else { 108 /* make it fill the rest of disk */ 109 len_lba = dinfo->num_lba - *lba; 110 } 111 112 cfg_pentry(pentry, ((pinfo->flags & PART_ACTIVE_FLAG) ? 113 PC_PART_ACTIVE : PC_PART_NORMAL), 114 pinfo->type, *lba, (uint32_t)len_lba); 115 116 pinfo->start_lba = *lba; 117 *lba += (uint32_t)len_lba; 118 } else { 119 /* this should be made an extended partition, and should take 120 * up the rest of the disk as a primary partition */ 121 cfg_pentry(pentry, PC_PART_NORMAL, PC_PART_TYPE_EXTENDED, 122 *lba, dinfo->num_lba - *lba); 123 124 /* note that we do not update the *lba because we now have to 125 * create a chain of extended partition tables, and first one is at 126 * *lba */ 127 } 128 129 return item; 130 } 131 132 133 /* This function configures an extended boot record at the beginning of an 134 * extended partition. This creates a logical partition and a pointer to 135 * the next EBR. 136 * 137 * ext_lba == The start of the toplevel extended partition (pointed to by the 138 * entry in the MBR). 139 */ 140 static struct write_list * 141 mk_ext_pentry(struct disk_info *dinfo, struct part_info *pinfo, uint32_t *lba, 142 uint32_t ext_lba, struct part_info *pnext) 143 { 144 struct write_list *item; 145 struct pc_boot_record *ebr; 146 uint32_t len; /* in lba units */ 147 148 if (!(item = alloc_wl(sizeof(struct pc_boot_record)))) { 149 ALOGE("Unable to allocate memory for EBR."); 150 return NULL; 151 } 152 153 /* we are going to write the ebr at the current LBA, and then bump the 154 * lba counter since that is where the logical data partition will start */ 155 item->offset = ((loff_t)(*lba)) * dinfo->sect_size; 156 (*lba)++; 157 158 ebr = (struct pc_boot_record *) &item->data; 159 memset(ebr, 0, sizeof(struct pc_boot_record)); 160 ebr->mbr_sig = PC_BIOS_BOOT_SIG; 161 162 if (pinfo->len_kb != (uint32_t)-1) 163 len = kb_to_lba(pinfo->len_kb, dinfo->sect_size); 164 else { 165 if (pnext) { 166 ALOGE("Only the last partition can be specified to fill the disk " 167 "(name = '%s')", pinfo->name); 168 goto fail; 169 } 170 len = dinfo->num_lba - *lba; 171 /* update the pinfo structure to reflect the new size, for 172 * bookkeeping */ 173 pinfo->len_kb = 174 (uint32_t)(((uint64_t)len * (uint64_t)dinfo->sect_size) / 175 ((uint64_t)1024)); 176 } 177 178 cfg_pentry(&ebr->ptable[PC_EBR_LOGICAL_PART], PC_PART_NORMAL, 179 pinfo->type, 1, len); 180 181 pinfo->start_lba = *lba; 182 *lba += len; 183 184 /* If this is not the last partition, we have to create a link to the 185 * next extended partition. 186 * 187 * Otherwise, there's nothing to do since the "pointer entry" is 188 * already zero-filled. 189 */ 190 if (pnext) { 191 /* The start lba for next partition is an offset from the beginning 192 * of the top-level extended partition */ 193 uint32_t next_start_lba = *lba - ext_lba; 194 uint32_t next_len_lba; 195 if (pnext->len_kb != (uint32_t)-1) 196 next_len_lba = 1 + kb_to_lba(pnext->len_kb, dinfo->sect_size); 197 else 198 next_len_lba = dinfo->num_lba - *lba; 199 cfg_pentry(&ebr->ptable[PC_EBR_NEXT_PTR_PART], PC_PART_NORMAL, 200 PC_PART_TYPE_EXTENDED, next_start_lba, next_len_lba); 201 } 202 203 return item; 204 205 fail: 206 free_wl(item); 207 return NULL; 208 } 209 210 211 static struct write_list * 212 mk_mbr_sig() 213 { 214 struct write_list *item; 215 if (!(item = alloc_wl(sizeof(uint16_t)))) { 216 ALOGE("Unable to allocate memory for MBR signature."); 217 return NULL; 218 } 219 220 { 221 /* DO NOT DEREFERENCE */ 222 struct pc_boot_record *mbr = (void *)PC_MBR_DISK_OFFSET; 223 /* grab the offset in mbr where to write mbr signature. */ 224 item->offset = (loff_t)((uintptr_t)((uint8_t *)(&mbr->mbr_sig))); 225 } 226 227 *((uint16_t*)item->data) = PC_BIOS_BOOT_SIG; 228 return item; 229 } 230 231 struct write_list * 232 config_mbr(struct disk_info *dinfo) 233 { 234 struct part_info *pinfo; 235 uint32_t cur_lba = dinfo->skip_lba; 236 uint32_t ext_lba = 0; 237 struct write_list *wr_list = NULL; 238 struct write_list *temp_wr = NULL; 239 int cnt = 0; 240 int extended = 0; 241 242 if (!dinfo->part_lst) 243 return NULL; 244 245 for (cnt = 0; cnt < dinfo->num_parts; ++cnt) { 246 pinfo = &dinfo->part_lst[cnt]; 247 248 /* Should we create an extedned partition? */ 249 if (cnt == (PC_NUM_BOOT_RECORD_PARTS - 1)) { 250 if (cnt + 1 < dinfo->num_parts) { 251 extended = 1; 252 ext_lba = cur_lba; 253 if ((temp_wr = mk_pri_pentry(dinfo, NULL, cnt, &cur_lba))) 254 wlist_add(&wr_list, temp_wr); 255 else { 256 ALOGE("Cannot create primary extended partition."); 257 goto fail; 258 } 259 } 260 } 261 262 /* if extended, need 1 lba for ebr */ 263 if ((cur_lba + extended) >= dinfo->num_lba) 264 goto nospace; 265 else if (pinfo->len_kb != (uint32_t)-1) { 266 uint32_t sz_lba = (pinfo->len_kb / dinfo->sect_size) * 1024; 267 if ((cur_lba + sz_lba + extended) > dinfo->num_lba) 268 goto nospace; 269 } 270 271 if (!extended) 272 temp_wr = mk_pri_pentry(dinfo, pinfo, cnt, &cur_lba); 273 else { 274 struct part_info *pnext; 275 pnext = cnt + 1 < dinfo->num_parts ? &dinfo->part_lst[cnt+1] : NULL; 276 temp_wr = mk_ext_pentry(dinfo, pinfo, &cur_lba, ext_lba, pnext); 277 } 278 279 if (temp_wr) 280 wlist_add(&wr_list, temp_wr); 281 else { 282 ALOGE("Cannot create partition %d (%s).", cnt, pinfo->name); 283 goto fail; 284 } 285 } 286 287 /* fill in the rest of the MBR with empty parts (if needed). */ 288 for (; cnt < PC_NUM_BOOT_RECORD_PARTS; ++cnt) { 289 struct part_info blank; 290 cur_lba = 0; 291 memset(&blank, 0, sizeof(struct part_info)); 292 if (!(temp_wr = mk_pri_pentry(dinfo, &blank, cnt, &cur_lba))) { 293 ALOGE("Cannot create blank partition %d.", cnt); 294 goto fail; 295 } 296 wlist_add(&wr_list, temp_wr); 297 } 298 299 if ((temp_wr = mk_mbr_sig())) 300 wlist_add(&wr_list, temp_wr); 301 else { 302 ALOGE("Cannot set MBR signature"); 303 goto fail; 304 } 305 306 return wr_list; 307 308 nospace: 309 ALOGE("Not enough space to add parttion '%s'.", pinfo->name); 310 311 fail: 312 wlist_free(wr_list); 313 return NULL; 314 } 315 316 317 /* Returns the device path of the partition referred to by 'name' 318 * Must be freed by the caller. 319 */ 320 char * 321 find_mbr_part(struct disk_info *dinfo, const char *name) 322 { 323 struct part_info *plist = dinfo->part_lst; 324 int num = 0; 325 char *dev_name = NULL; 326 int has_extended = (dinfo->num_parts > PC_NUM_BOOT_RECORD_PARTS); 327 328 for(num = 1; num <= dinfo->num_parts; ++num) { 329 if (!strcmp(plist[num-1].name, name)) 330 break; 331 } 332 333 if (num > dinfo->num_parts) 334 return NULL; 335 336 if (has_extended && (num >= PC_NUM_BOOT_RECORD_PARTS)) 337 num++; 338 339 if (!(dev_name = malloc(MAX_NAME_LEN))) { 340 ALOGE("Cannot allocate memory."); 341 return NULL; 342 } 343 344 num = snprintf(dev_name, MAX_NAME_LEN, "%s%d", dinfo->device, num); 345 if (num >= MAX_NAME_LEN) { 346 ALOGE("Device name is too long?!"); 347 free(dev_name); 348 return NULL; 349 } 350 351 return dev_name; 352 } 353
