Changes in uspace/lib/mbr/libmbr.c [9bda5d90:a2aa81cb] in mainline
- File:
-
- 1 edited
-
uspace/lib/mbr/libmbr.c (modified) (34 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/mbr/libmbr.c
r9bda5d90 ra2aa81cb 46 46 47 47 static br_block_t * alloc_br(void); 48 static int decode_part(pt_entry_t * src, mbr_part_t * trgt, uint32_t base); 49 static int decode_logical(mbr_t * mbr, mbr_partitions_t * p, mbr_part_t * ext); 50 static void encode_part(mbr_part_t * src, pt_entry_t * trgt, uint32_t base, bool ebr); 51 static int check_overlap(mbr_part_t * p1, mbr_part_t * p2); 52 static int check_encaps(mbr_part_t * inner, mbr_part_t * outer); 53 static int check_preceeds(mbr_part_t * preceeder, mbr_part_t * precedee); 48 static int decode_part(pt_entry_t *, mbr_part_t *, uint32_t); 49 static int decode_logical(mbr_label_t *, mbr_part_t *); 50 static void encode_part(mbr_part_t *, pt_entry_t *, uint32_t, bool); 51 static int check_overlap(mbr_part_t *, mbr_part_t *); 52 static int check_encaps(mbr_part_t *, mbr_part_t *); 53 static int check_preceeds(mbr_part_t *, mbr_part_t *); 54 55 /** Allocate and initialize mbr_label_t structure */ 56 mbr_label_t * mbr_alloc_label(void) 57 { 58 mbr_label_t *label = malloc(sizeof(mbr_label_t)); 59 if (label == NULL) 60 return NULL; 61 62 label->mbr = NULL; 63 label->parts = NULL; 64 label->device = 0; 65 66 return label; 67 } 68 69 /** Free mbr_label_t structure */ 70 void mbr_free_label(mbr_label_t *label) 71 { 72 if (label->mbr != NULL) 73 mbr_free_mbr(label->mbr); 74 75 if (label->parts != NULL) 76 mbr_free_partitions(label->parts); 77 78 free(label); 79 } 54 80 55 81 /** Allocate memory for mbr_t */ … … 60 86 61 87 /** Read MBR from specific device 62 * @param dev_handle device to read MBR from 63 * 64 * @return mbr record on success, NULL on error 65 */ 66 mbr_t * mbr_read_mbr(service_id_t dev_handle) 67 { 88 * @param label label to write data to 89 * @param dev_handle device to read MBR from 90 * 91 * @return EOK on success, error code on error 92 */ 93 int mbr_read_mbr(mbr_label_t *label, service_id_t dev_handle) 94 { 95 if (label == NULL) 96 return EINVAL; 97 68 98 int rc; 69 70 mbr_t * mbr = malloc(sizeof(mbr_t)); 71 if (mbr == NULL) { 72 return NULL; 99 100 if (label->mbr == NULL) { 101 label->mbr = mbr_alloc_mbr(); 102 if (label->mbr == NULL) { 103 return ENOMEM; 104 } 73 105 } 74 106 75 107 rc = block_init(EXCHANGE_ATOMIC, dev_handle, 512); 76 if (rc != EOK) { 77 free(mbr); 78 return NULL; 79 } 80 81 rc = block_read_direct(dev_handle, 0, 1, &(mbr->raw_data)); 82 if (rc != EOK) { 83 free(mbr); 84 block_fini(dev_handle); 85 return NULL; 86 } 87 108 if (rc != EOK) 109 return rc; 110 111 rc = block_read_direct(dev_handle, 0, 1, &(label->mbr->raw_data)); 88 112 block_fini(dev_handle); 89 90 mbr->device = dev_handle; 91 92 return mbr; 113 if (rc != EOK) 114 return rc; 115 116 label->device = dev_handle; 117 118 return EOK; 93 119 } 94 120 95 121 /** Write mbr to disk 96 * @param mbrMBR to be written122 * @param label MBR to be written 97 123 * @param dev_handle device handle to write MBR to (may be different 98 124 * from the device in 'mbr') … … 100 126 * @return 0 on success, otherwise libblock error code 101 127 */ 102 int mbr_write_mbr(mbr_ t * mbr, service_id_t dev_handle)128 int mbr_write_mbr(mbr_label_t *label, service_id_t dev_handle) 103 129 { 104 130 int rc; … … 109 135 } 110 136 111 rc = block_write_direct(dev_handle, 0, 1, &( mbr->raw_data));137 rc = block_write_direct(dev_handle, 0, 1, &(label->mbr->raw_data)); 112 138 block_fini(dev_handle); 113 139 if (rc != EOK) { … … 115 141 } 116 142 117 return 0;143 return EOK; 118 144 } 119 145 … … 124 150 * @return 1 if MBR, 0 if GPT 125 151 */ 126 int mbr_is_mbr(mbr_t * mbr) 127 { 128 return (mbr->raw_data.pte[0].ptype != PT_GPT) ? 1 : 0; 129 } 130 131 /** Parse partitions from MBR 132 * @param mbr MBR to be parsed 133 * 134 * @return linked list of partitions or NULL on error 135 */ 136 mbr_partitions_t * mbr_read_partitions(mbr_t * mbr) 137 { 138 int rc, i, rc_ext; 139 mbr_part_t * p; 140 mbr_part_t * ext = NULL; 141 mbr_partitions_t * parts; 142 143 if (mbr == NULL) 144 return NULL; 145 146 parts = mbr_alloc_partitions(); 147 if (parts == NULL) { 148 return NULL; 149 } 150 151 // Generate the primary partitions 152 int mbr_is_mbr(mbr_label_t *label) 153 { 154 return (label->mbr->raw_data.pte[0].ptype != PT_GPT) ? 1 : 0; 155 } 156 157 /** Parse partitions from MBR, freeing previous partitions if any 158 * NOTE: it is assumed mbr_read_mbr(label) was called before. 159 * @param label MBR to be parsed 160 * 161 * @return linked list of partitions or NULL on error 162 */ 163 int mbr_read_partitions(mbr_label_t *label) 164 { 165 if (label == NULL || label->mbr == NULL) 166 return EINVAL; 167 168 int rc, rc_ext; 169 unsigned int i; 170 mbr_part_t *p; 171 mbr_part_t *ext = NULL; 172 //mbr_partitions_t *parts; 173 printf("check\n"); 174 if (label->parts != NULL) 175 mbr_free_partitions(label->parts); 176 printf("check2\n"); 177 label->parts = mbr_alloc_partitions(); 178 if (label->parts == NULL) { 179 return ENOMEM; 180 } 181 printf("primary\n"); 182 /* Generate the primary partitions */ 152 183 for (i = 0; i < N_PRIMARY; ++i) { 153 if ( mbr->raw_data.pte[i].ptype == PT_UNUSED)184 if (label->mbr->raw_data.pte[i].ptype == PT_UNUSED) 154 185 continue; 155 186 printf("pcheck1\n"); 156 187 p = mbr_alloc_partition(); 157 188 if (p == NULL) { 158 189 printf(LIBMBR_NAME ": Error on memory allocation.\n"); 159 mbr_free_partitions( parts);160 return NULL;161 } 162 163 rc_ext = decode_part(&( mbr->raw_data.pte[i]), p, 0);190 mbr_free_partitions(label->parts); 191 return ENOMEM; 192 } 193 printf("pcheck2\n"); 194 rc_ext = decode_part(&(label->mbr->raw_data.pte[i]), p, 0); 164 195 mbr_set_flag(p, ST_LOGIC, false); 165 rc = mbr_add_partition( parts, p);196 rc = mbr_add_partition(label, p); 166 197 if (rc != ERR_OK) { 167 198 printf(LIBMBR_NAME ": Error occured during decoding the MBR. (%d)\n" \ 168 LIBMBR_NAME ": Partition list may be incomplete.\n", rc); 169 return NULL; 170 } 171 199 LIBMBR_NAME ": MBR is invalid.\n", rc); 200 mbr_free_partitions(label->parts); 201 return EINVAL; 202 } 203 printf("pcheck3\n"); 172 204 if (rc_ext) { 173 205 ext = p; 174 parts->l_extended = list_last(&(parts->list)); 175 } 176 } 177 178 // Fill in the primary partitions and generate logical ones, if any 179 rc = decode_logical(mbr, parts, ext); 206 label->parts->l_extended = list_nth(&(label->parts->list), i); 207 } 208 printf("pcheck4\n"); 209 } 210 printf("logical\n"); 211 /* Fill in the primary partitions and generate logical ones, if any */ 212 rc = decode_logical(label, ext); 180 213 if (rc != EOK) { 181 214 printf(LIBMBR_NAME ": Error occured during decoding the MBR.\n" \ 182 215 LIBMBR_NAME ": Partition list may be incomplete.\n"); 183 } 184 185 return parts; 216 return rc; 217 } 218 printf("finish\n"); 219 return EOK; 186 220 } 187 221 188 222 /** Write MBR and partitions to device 189 * @param parts partition list to be written 190 * @param mbr MBR to be written with 'parts' partitions 191 * @param dev_handle device to write the data to 192 * 193 * @return returns EOK on succes, specific error code otherwise 194 */ 195 int mbr_write_partitions(mbr_partitions_t * parts, mbr_t * mbr, service_id_t dev_handle) 223 * @param label label to write 224 * @param dev_handle device to write the data to 225 * 226 * @return returns EOK on succes, specific error code otherwise 227 */ 228 int mbr_write_partitions(mbr_label_t *label, service_id_t dev_handle) 196 229 { 197 230 int i = 0; 198 231 int rc; 199 mbr_part_t * 200 mbr_part_t * ext = (parts->l_extended == NULL) ? NULL201 : list_get_instance( parts->l_extended, mbr_part_t, link);232 mbr_part_t *p; 233 mbr_part_t *ext = (label->parts->l_extended == NULL) ? NULL 234 : list_get_instance(label->parts->l_extended, mbr_part_t, link); 202 235 203 236 rc = block_init(EXCHANGE_ATOMIC, dev_handle, 512); … … 207 240 } 208 241 209 link_t * l =parts->list.head.next;210 211 / / Encoding primary partitions212 for (i = 0; i < parts->n_primary; i++) {213 p = list_get_instance(l, mbr_part_t, link); 214 encode_part(p, &( mbr->raw_data.pte[i]), 0, false);242 link_t *l = label->parts->list.head.next; 243 244 /* Encoding primary partitions */ 245 for (i = 0; i < label->parts->n_primary; i++) { 246 p = list_get_instance(l, mbr_part_t, link); 247 encode_part(p, &(label->mbr->raw_data.pte[i]), 0, false); 215 248 l = l->next; 216 249 } 217 250 218 / / Writing MBR219 rc = block_write_direct(dev_handle, 0, 1, &( mbr->raw_data));251 /* Writing MBR */ 252 rc = block_write_direct(dev_handle, 0, 1, &(label->mbr->raw_data)); 220 253 if (rc != EOK) { 221 254 printf(LIBMBR_NAME ": Error while writing MBR : %d - %s.\n", rc, str_error(rc)); … … 234 267 * as much power over it as you can get. Thanks. */ 235 268 236 / / Encoding and writing first logical partition237 if (l != &( parts->list.head)) {269 /* Encoding and writing first logical partition */ 270 if (l != &(label->parts->list.head)) { 238 271 p = list_get_instance(l, mbr_part_t, link); 239 272 p->ebr_addr = base; … … 256 289 prev_p = p; 257 290 258 / / Encoding and writing logical partitions259 while (l != &( parts->list.head)) {291 /* Encoding and writing logical partitions */ 292 while (l != &(label->parts->list.head)) { 260 293 p = list_get_instance(l, mbr_part_t, link); 261 294 … … 286 319 } 287 320 288 / / write the last EBR321 /* write the last EBR */ 289 322 encode_part(NULL, &(prev_p->ebr->pte[1]), 0, false); 290 323 rc = block_write_direct(dev_handle, prev_p->ebr_addr, 1, prev_p->ebr); … … 305 338 mbr_part_t * mbr_alloc_partition(void) 306 339 { 307 mbr_part_t * 340 mbr_part_t *p = malloc(sizeof(mbr_part_t)); 308 341 if (p == NULL) { 309 342 return NULL; … … 312 345 link_initialize(&(p->link)); 313 346 p->ebr = NULL; 314 p->type = 0;347 p->type = PT_UNUSED; 315 348 p->status = 0; 316 349 p->start_addr = 0; 317 350 p->length = 0; 318 351 p->ebr_addr = 0; 319 352 320 353 return p; 321 354 } … … 324 357 mbr_partitions_t * mbr_alloc_partitions(void) 325 358 { 326 mbr_partitions_t * 359 mbr_partitions_t *parts = malloc(sizeof(mbr_partitions_t)); 327 360 if (parts == NULL) { 328 361 return NULL; 329 362 } 330 363 331 364 list_initialize(&(parts->list)); 332 365 parts->n_primary = 0; 333 366 parts->n_logical = 0; 334 367 parts->l_extended = NULL; 368 369 /* add blank primary partitions */ 370 int i; 371 mbr_part_t *p; 372 for (i = 0; i < N_PRIMARY; ++i) { 373 p = mbr_alloc_partition(); 374 if (p == NULL) { 375 mbr_free_partitions(parts); 376 return NULL; 377 } 378 list_append(&(p->link), &(parts->list)); 379 } 380 335 381 336 382 return parts; … … 340 386 * Performs checks, sorts the list. 341 387 * 342 * @param parts partition listto add to388 * @param label label to add to 343 389 * @param p partition to add 344 390 * 345 391 * @return ERR_OK (0) on success, other MBR_ERR_VAL otherwise 346 392 */ 347 MBR_ERR_VAL mbr_add_partition(mbr_partitions_t * parts, mbr_part_t * p) 348 { 349 if (mbr_get_flag(p, ST_LOGIC)) { // adding logical part 350 // is there any extended partition? 393 mbr_err_val mbr_add_partition(mbr_label_t *label, mbr_part_t *p) 394 { 395 int rc; 396 mbr_partitions_t *parts = label->parts; 397 398 aoff64_t nblocks; 399 printf("add1.\n"); 400 rc = block_init(EXCHANGE_ATOMIC, label->device, 512); 401 if (rc != EOK) { 402 printf(LIBMBR_NAME ": Error while getting number of blocks: %d - %s.\n", rc, str_error(rc)); 403 return ERR_LIBBLOCK; 404 } 405 printf("add2.\n"); 406 rc = block_get_nblocks(label->device, &nblocks); 407 block_fini(label->device); 408 if (rc != EOK) { 409 printf(LIBMBR_NAME ": Error while getting number of blocks: %d - %s.\n", rc, str_error(rc)); 410 return ERR_LIBBLOCK; 411 } 412 printf("add3.\n"); 413 if (mbr_get_flag(p, ST_LOGIC)) { 414 /* adding logical partition */ 415 416 /* is there any extended partition? */ 351 417 if (parts->l_extended == NULL) 352 418 return ERR_NO_EXTENDED; 353 419 354 / / is the logical partition inside the extended one?355 mbr_part_t * 420 /* is the logical partition inside the extended one? */ 421 mbr_part_t *ext = list_get_instance(parts->l_extended, mbr_part_t, link); 356 422 if (!check_encaps(p, ext)) 357 423 return ERR_OUT_BOUNDS; 358 424 359 / / find a place for the new partition in a sorted linked list360 mbr_part_t *last = list_get_instance(list_last(&(parts->list)), mbr_part_t, link);361 mbr_part_t * 362 uint32_t ebr_space = 1;425 /* find a place for the new partition in a sorted linked list */ 426 //mbr_part_t *last = list_get_instance(list_last(&(parts->list)), mbr_part_t, link); 427 mbr_part_t *iter; 428 //uint32_t ebr_space = 1; 363 429 mbr_part_foreach(parts, iter) { 364 430 if (mbr_get_flag(iter, ST_LOGIC)) { … … 366 432 return ERR_OVERLAP; 367 433 if (check_preceeds(iter, p)) { 368 last = iter; 369 ebr_space = p->start_addr - (last->start_addr + last->length); 370 } else 371 break; 434 /* checking if there's at least one sector of space preceeding */ 435 if ((iter->start_addr + iter->length) >= p->start_addr - 1) 436 return ERR_NO_EBR; 437 } else { 438 /* checking if there's at least one sector of space following (for following partitions's EBR) */ 439 if ((p->start_addr + p->length) >= iter->start_addr - 1) 440 return ERR_NO_EBR; 441 } 372 442 } 373 443 } 374 444 375 // checking if there's at least one sector of space preceeding 376 if (ebr_space < 1) 377 return ERR_NO_EBR; 378 379 // checking if there's at least one sector of space following (for following partitions's EBR) 380 if (last->link.next != &(parts->list.head)) { 381 if (list_get_instance(&(last->link.next), mbr_part_t, link)->start_addr <= p->start_addr + p->length + 1) 382 return ERR_NO_EBR; 383 } 384 385 // alloc EBR if it's not already there 445 /* alloc EBR if it's not already there */ 386 446 if (p->ebr == NULL) { 387 447 p->ebr = alloc_br(); … … 391 451 } 392 452 393 / / add it394 list_ insert_after(&(p->link), &(last->link));453 /* add it */ 454 list_append(&(p->link), &(parts->list)); 395 455 parts->n_logical += 1; 396 } else { // adding primary 456 } else { 457 /* adding primary */ 458 397 459 if (parts->n_primary == 4) { 398 460 return ERR_PRIMARY_FULL; 399 461 } 400 462 401 / / TODO: should we check if it's inside the drive's upper boundary?402 if (p->start_addr == 0 ) {463 /* Check if partition makes space for MBR itself. */ 464 if (p->start_addr == 0 || ((aoff64_t) p->start_addr) + p->length >= nblocks) { 403 465 return ERR_OUT_BOUNDS; 404 466 } 405 406 / / if it's extended, is there any other one?467 printf("add4.\n"); 468 /* if it's extended, is there any other one? */ 407 469 if ((p->type == PT_EXTENDED || p->type == PT_EXTENDED_LBA) && parts->l_extended != NULL) { 408 470 return ERR_EXTENDED_PRESENT; 409 471 } 410 411 // find a place and add it 412 if (list_empty(&(parts->list))) { 413 list_append(&(p->link), &(parts->list)); 414 } else { 415 mbr_part_t * iter; 416 mbr_part_foreach(parts, iter) { 417 if (mbr_get_flag(iter, ST_LOGIC)) { 418 list_insert_before(&(p->link), &(iter->link)); 419 break; 420 } else if (check_overlap(p, iter)) 421 return ERR_OVERLAP; 422 } 423 if (iter == list_get_instance(&(parts->list.head.prev), mbr_part_t, link)) 424 list_append(&(p->link), &(parts->list)); 425 } 472 printf("add5.\n"); 473 /* find a place and add it */ 474 mbr_part_t *iter; 475 mbr_part_t *empty = NULL; 476 mbr_part_foreach(parts, iter) { 477 printf("type: %x\n", iter->type); 478 if (iter->type == PT_UNUSED) { 479 if (empty == NULL) 480 empty = iter; 481 } else if (check_overlap(p, iter)) 482 return ERR_OVERLAP; 483 } 484 printf("add6. %p, %p\n", empty, p); 485 list_insert_after(&(p->link), &(empty->link)); 486 printf("add6.1.\n"); 487 list_remove(&(empty->link)); 488 printf("add6.2.\n"); 489 free(empty); 490 printf("add7.\n"); 426 491 parts->n_primary += 1; 427 492 … … 429 494 parts->l_extended = &(p->link); 430 495 } 431 496 printf("add8.\n"); 432 497 return ERR_OK; 433 498 } … … 435 500 /** Remove partition 436 501 * Removes partition by index, indexed from zero. When removing extended 437 * partition, all logical partitions get removed as well.502 * partition, all logical partitions get removed as well. 438 503 * 439 * @param parts partition listto remove from504 * @param label label to remove from 440 505 * @param idx index of the partition to remove 441 506 * 442 507 * @return EOK on success, EINVAL if idx invalid 443 508 */ 444 int mbr_remove_partition(mbr_ partitions_t * parts, size_t idx)445 { 446 link_t * l = list_nth(&(parts->list), idx);509 int mbr_remove_partition(mbr_label_t *label, size_t idx) 510 { 511 link_t *l = list_nth(&(label->parts->list), idx); 447 512 if (l == NULL) 448 513 return EINVAL; 449 514 450 mbr_part_t * p; 451 452 /* TODO: if it is extended partition, should we also remove all logical? 453 * If we don't, we break the consistency of the list. If we do, 454 * the user will have to input them all over again. So yes. */ 455 if (l == parts->l_extended) { 456 parts->l_extended = NULL; 457 458 link_t * it = l->next; 459 link_t * next_it; 460 while (it != &(parts->list.head)) { 515 mbr_part_t *p; 516 517 /* If we're removing an extended partition, remove all logical as well */ 518 if (l == label->parts->l_extended) { 519 label->parts->l_extended = NULL; 520 521 link_t *it = l->next; 522 link_t *next_it; 523 while (it != &(label->parts->list.head)) { 461 524 next_it = it->next; 462 525 … … 464 527 if (mbr_get_flag(p, ST_LOGIC)) { 465 528 list_remove(it); 466 parts->n_logical -= 1;529 label->parts->n_logical -= 1; 467 530 mbr_free_partition(p); 468 531 } … … 473 536 } 474 537 475 list_remove(l); 476 538 /* Remove the partition itself */ 477 539 p = list_get_instance(l, mbr_part_t, link); 478 if (mbr_get_flag(p, ST_LOGIC)) 479 parts->n_logical -= 1; 480 else 481 parts->n_primary -= 1; 482 483 484 mbr_free_partition(p); 540 if (mbr_get_flag(p, ST_LOGIC)) { 541 label->parts->n_logical -= 1; 542 list_remove(l); 543 mbr_free_partition(p); 544 } else { 545 /* Cannot remove primary - it would break ordering, just zero it */ 546 label->parts->n_primary -= 1; 547 p->type = 0; 548 p->status = 0; 549 p->start_addr = 0; 550 p->length = 0; 551 p->ebr_addr = 0; 552 } 485 553 486 554 return EOK; … … 488 556 489 557 /** mbr_part_t destructor */ 490 void mbr_free_partition(mbr_part_t * 558 void mbr_free_partition(mbr_part_t *p) 491 559 { 492 560 if (p->ebr != NULL) … … 496 564 497 565 /** Get flag bool value */ 498 int mbr_get_flag(mbr_part_t * 566 int mbr_get_flag(mbr_part_t *p, MBR_FLAGS flag) 499 567 { 500 568 return (p->status & (1 << flag)) ? 1 : 0; … … 502 570 503 571 /** Set a specifig status flag to a value */ 504 void mbr_set_flag(mbr_part_t * 572 void mbr_set_flag(mbr_part_t *p, MBR_FLAGS flag, bool value) 505 573 { 506 574 uint8_t status = p->status; … … 522 590 523 591 /** Just a wrapper for free() */ 524 void mbr_free_mbr(mbr_t * 592 void mbr_free_mbr(mbr_t *mbr) 525 593 { 526 594 free(mbr); … … 531 599 * @param parts partition list to be freed 532 600 */ 533 void mbr_free_partitions(mbr_partitions_t * 601 void mbr_free_partitions(mbr_partitions_t *parts) 534 602 { 535 603 list_foreach_safe(parts->list, cur_link, next) { 536 mbr_part_t * p = list_get_instance(cur_link, mbr_part_t, link); 537 list_remove(cur_link); 604 mbr_part_t *p = list_get_instance(cur_link, mbr_part_t, link); 538 605 mbr_free_partition(p); 539 606 } … … 544 611 // Internal functions follow // 545 612 546 static br_block_t * 547 { 548 br_block_t * 613 static br_block_t *alloc_br() 614 { 615 br_block_t *br = malloc(sizeof(br_block_t)); 549 616 if (br == NULL) 550 617 return NULL; … … 559 626 * @return returns 1, if extended partition, 0 otherwise 560 627 * */ 561 static int decode_part(pt_entry_t * src, mbr_part_t *trgt, uint32_t base)628 static int decode_part(pt_entry_t *src, mbr_part_t *trgt, uint32_t base) 562 629 { 563 630 trgt->type = src->ptype; 564 631 565 632 /* Checking only 0x80; otherwise writing will fix to 0x00 */ 566 //trgt->bootable = (src->status == B_ACTIVE) ? true : false; 567 mbr_set_flag(trgt, ST_BOOT, (src->status == B_ACTIVE) ? true : false); 633 trgt->status = (trgt->status & 0xFF00) | src->status; 568 634 569 635 trgt->start_addr = uint32_t_le2host(src->first_lba) + base; … … 574 640 575 641 /** Parse MBR contents to mbr_part_t list */ 576 static int decode_logical(mbr_ t * mbr, mbr_partitions_t * parts, mbr_part_t * ext)642 static int decode_logical(mbr_label_t *label, mbr_part_t * ext) 577 643 { 578 644 int rc; 579 mbr_part_t * p; 580 581 if (mbr == NULL || parts == NULL) 582 return EINVAL; 583 645 mbr_part_t *p; 584 646 585 647 if (ext == NULL) 586 648 return EOK; 587 649 588 589 650 uint32_t base = ext->start_addr; 590 651 uint32_t addr = base; 591 br_block_t * 592 593 rc = block_init(EXCHANGE_ATOMIC, mbr->device, 512);652 br_block_t *ebr; 653 654 rc = block_init(EXCHANGE_ATOMIC, label->device, 512); 594 655 if (rc != EOK) 595 656 return rc; … … 601 662 } 602 663 603 rc = block_read_direct( mbr->device, addr, 1, ebr);664 rc = block_read_direct(label->device, addr, 1, ebr); 604 665 if (rc != EOK) { 605 666 goto free_ebr_end; … … 626 687 p->ebr = ebr; 627 688 p->ebr_addr = addr; 628 rc = mbr_add_partition( parts, p);689 rc = mbr_add_partition(label, p); 629 690 if (rc != ERR_OK) 630 691 return EINVAL; … … 639 700 } 640 701 641 rc = block_read_direct( mbr->device, addr, 1, ebr);702 rc = block_read_direct(label->device, addr, 1, ebr); 642 703 if (rc != EOK) { 643 704 goto free_ebr_end; … … 660 721 p->ebr = ebr; 661 722 p->ebr_addr = addr; 662 rc = mbr_add_partition( parts, p);723 rc = mbr_add_partition(label, p); 663 724 if (rc != ERR_OK) 664 725 return EINVAL; … … 674 735 675 736 end: 676 block_fini( mbr->device);737 block_fini(label->device); 677 738 678 739 return rc; … … 683 744 { 684 745 if (src != NULL) { 685 trgt->status = mbr_get_flag(src, ST_BOOT) ? B_ACTIVE : B_INACTIVE; 746 //trgt->status = mbr_get_flag(src, ST_BOOT) ? B_ACTIVE : B_INACTIVE; 747 trgt->status = (uint8_t) (src->status & 0xFF); 748 /* ingoring CHS */ 749 trgt->first_chs[0] = 0xFE; 750 trgt->first_chs[1] = 0xFF; 751 trgt->first_chs[2] = 0xFF; 752 trgt->last_chs[0] = 0xFE; 753 trgt->last_chs[1] = 0xFF; 754 trgt->last_chs[2] = 0xFF; 686 755 if (ebr) { // encoding reference to EBR 687 756 trgt->ptype = PT_EXTENDED_LBA;
Note:
See TracChangeset
for help on using the changeset viewer.
