RTEMS-6
Annotated Report
libblock
Sun Feb 28 23:58:30 2021
0010fa44 <ramdisk_allocate>:
void *area_begin,
uint32_t media_block_size,
rtems_blkdev_bnum media_block_count,
bool trace
)
{
10fa44: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
10fa48: 4688 mov r8, r1
10fa4a: 4605 mov r5, r0
struct ramdisk *rd = calloc(1, sizeof(*rd));
10fa4c: 2110 movs r1, #16
10fa4e: 2001 movs r0, #1
{
10fa50: 4616 mov r6, r2
10fa52: 461f mov r7, r3
struct ramdisk *rd = calloc(1, sizeof(*rd));
10fa54: f000 f840 bl 10fad8 <calloc>
if (rd == NULL) {
10fa58: 4604 mov r4, r0
10fa5a: b138 cbz r0, 10fa6c <ramdisk_allocate+0x28>
return NULL;
}
if (area_begin == NULL) {
10fa5c: b14d cbz r5, 10fa72 <ramdisk_allocate+0x2e>
}
rd->block_size = media_block_size;
rd->block_num = media_block_count;
rd->area = area_begin;
rd->trace = trace;
rd->initialized = true;
10fa5e: 2301 movs r3, #1
rd->block_size = media_block_size;
10fa60: f8c4 8000 str.w r8, [r4]
rd->area = area_begin;
10fa64: e9c4 6501 strd r6, r5, [r4, #4]
rd->trace = trace;
10fa68: 73a7 strb r7, [r4, #14]
rd->initialized = true;
10fa6a: 7323 strb r3, [r4, #12]
return rd;
}
10fa6c: 4620 mov r0, r4
10fa6e: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
area_begin = calloc(media_block_count, media_block_size);
10fa72: 4641 mov r1, r8
10fa74: 4630 mov r0, r6
10fa76: f000 f82f bl 10fad8 <calloc>
if (area_begin == NULL) {
10fa7a: 4605 mov r5, r0
10fa7c: b110 cbz r0, 10fa84 <ramdisk_allocate+0x40>
rd->malloced = true;
10fa7e: 2301 movs r3, #1
10fa80: 7363 strb r3, [r4, #13]
10fa82: e7ec b.n 10fa5e <ramdisk_allocate+0x1a>
free(rd);
10fa84: 4620 mov r0, r4 <== NOT EXECUTED
return NULL;
10fa86: 462c mov r4, r5 <== NOT EXECUTED
free(rd);
10fa88: f7f6 f942 bl 105d10 <free> <== NOT EXECUTED
return NULL;
10fa8c: e7ee b.n 10fa6c <ramdisk_allocate+0x28> <== NOT EXECUTED
10fa8e: bf00 nop
00106064 <ramdisk_free>:
return rd;
}
void ramdisk_free(ramdisk *rd)
{
if (rd != NULL) {
106064: b180 cbz r0, 106088 <ramdisk_free+0x24>
if (rd->malloced) {
106066: 7b43 ldrb r3, [r0, #13]
{
106068: b510 push {r4, lr}
10606a: 4604 mov r4, r0
if (rd->malloced) {
10606c: b923 cbnz r3, 106078 <ramdisk_free+0x14>
free(rd->area);
}
free(rd);
10606e: 4620 mov r0, r4
}
}
106070: e8bd 4010 ldmia.w sp!, {r4, lr}
free(rd);
106074: f000 b8c0 b.w 1061f8 <free>
free(rd->area);
106078: 6880 ldr r0, [r0, #8]
10607a: f000 f8bd bl 1061f8 <free>
free(rd);
10607e: 4620 mov r0, r4
}
106080: e8bd 4010 ldmia.w sp!, {r4, lr}
free(rd);
106084: f000 b8b8 b.w 1061f8 <free>
106088: 4770 bx lr <== NOT EXECUTED
10608a: bf00 nop
00105ed4 <ramdisk_initialize>:
rtems_device_driver
ramdisk_initialize(
rtems_device_major_number major RTEMS_UNUSED,
rtems_device_minor_number minor RTEMS_UNUSED,
void *arg RTEMS_UNUSED)
{
105ed4: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
* This is allocating memory for a RAM disk which will persist for
* the life of the system. RTEMS has no "de-initialize" driver call
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
105ed8: f240 09a0 movw r9, #160 ; 0xa0
105edc: f2c0 0920 movt r9, #32
{
105ee0: b089 sub sp, #36 ; 0x24
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
105ee2: 2110 movs r1, #16
r->trace = false;
105ee4: 2600 movs r6, #0
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
105ee6: f8d9 5000 ldr.w r5, [r9]
105eea: 4628 mov r0, r5
105eec: f000 f8f4 bl 1060d8 <calloc>
r->trace = false;
105ef0: 7386 strb r6, [r0, #14]
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
105ef2: 2d00 cmp r5, #0
105ef4: d04c beq.n 105f90 <ramdisk_initialize+0xbc> <== ALWAYS TAKEN
105ef6: f647 47e0 movw r7, #31968 ; 0x7ce0
{
r->malloced = false;
r->initialized = true;
r->area = c->location;
}
rc = rtems_blkdev_create(name, c->block_size, c->block_num,
105efa: f645 7ba1 movw fp, #24481 ; 0x5fa1
105efe: f2c0 0711 movt r7, #17
105f02: 4d26 ldr r5, [pc, #152] ; (105f9c <ramdisk_initialize+0xc8>)
105f04: 4604 mov r4, r0
105f06: f2c0 0b10 movt fp, #16
{
if (r->malloced)
{
free(r->area);
}
r->initialized = false;
105f0a: 46b2 mov sl, r6
r->initialized = true;
105f0c: 46b8 mov r8, r7
105f0e: e018 b.n 105f42 <ramdisk_initialize+0x6e>
105f10: f04f 0301 mov.w r3, #1
r->malloced = false;
105f14: f884 a00d strb.w sl, [r4, #13]
r->initialized = true;
105f18: 7323 strb r3, [r4, #12]
r->area = c->location;
105f1a: f8c4 e008 str.w lr, [r4, #8]
rc = rtems_blkdev_create(name, c->block_size, c->block_num,
105f1e: 465b mov r3, fp
105f20: 4639 mov r1, r7
105f22: a805 add r0, sp, #20
105f24: 9400 str r4, [sp, #0]
105f26: f7ff fc59 bl 1057dc <rtems_blkdev_create>
if (rc != RTEMS_SUCCESSFUL)
105f2a: b118 cbz r0, 105f34 <ramdisk_initialize+0x60>
if (r->malloced)
105f2c: 7b63 ldrb r3, [r4, #13] <== NOT EXECUTED
105f2e: bb5b cbnz r3, 105f88 <ramdisk_initialize+0xb4> <== NOT EXECUTED
r->initialized = false;
105f30: f884 a00c strb.w sl, [r4, #12] <== NOT EXECUTED
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
105f34: f8d9 3000 ldr.w r3, [r9]
105f38: 3601 adds r6, #1
105f3a: 3410 adds r4, #16
105f3c: 350c adds r5, #12
105f3e: 42b3 cmp r3, r6
105f40: d926 bls.n 105f90 <ramdisk_initialize+0xbc>
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
105f42: e898 0007 ldmia.w r8, {r0, r1, r2}
105f46: ab05 add r3, sp, #20
name [sizeof(RAMDISK_DEVICE_BASE_NAME) - 1] += i;
105f48: f106 0c61 add.w ip, r6, #97 ; 0x61
r->block_size = c->block_size;
105f4c: f855 7c0c ldr.w r7, [r5, #-12]
if (c->location == NULL)
105f50: f855 ec04 ldr.w lr, [r5, #-4]
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
105f54: c303 stmia r3!, {r0, r1}
105f56: 701a strb r2, [r3, #0]
r->block_num = c->block_num;
105f58: f855 2c08 ldr.w r2, [r5, #-8]
r->block_size = c->block_size;
105f5c: 6027 str r7, [r4, #0]
name [sizeof(RAMDISK_DEVICE_BASE_NAME) - 1] += i;
105f5e: f88d c01b strb.w ip, [sp, #27]
r->block_num = c->block_num;
105f62: 6062 str r2, [r4, #4]
if (c->location == NULL)
105f64: f1be 0f00 cmp.w lr, #0
105f68: d1d2 bne.n 105f10 <ramdisk_initialize+0x3c>
r->malloced = true;
105f6a: f04f 0301 mov.w r3, #1
r->area = malloc(r->block_size * r->block_num);
105f6e: fb02 f007 mul.w r0, r2, r7
r->malloced = true;
105f72: 7363 strb r3, [r4, #13]
r->area = malloc(r->block_size * r->block_num);
105f74: 9203 str r2, [sp, #12]
105f76: f000 fb17 bl 1065a8 <malloc>
if (r->area == NULL) /* No enough memory for this disk */
105f7a: 9a03 ldr r2, [sp, #12]
r->area = malloc(r->block_size * r->block_num);
105f7c: 60a0 str r0, [r4, #8]
if (r->area == NULL) /* No enough memory for this disk */
105f7e: b158 cbz r0, 105f98 <ramdisk_initialize+0xc4>
r->initialized = true;
105f80: f04f 0301 mov.w r3, #1
105f84: 7323 strb r3, [r4, #12]
105f86: e7ca b.n 105f1e <ramdisk_initialize+0x4a>
free(r->area);
105f88: 68a0 ldr r0, [r4, #8] <== NOT EXECUTED
105f8a: f000 f935 bl 1061f8 <free> <== NOT EXECUTED
105f8e: e7cf b.n 105f30 <ramdisk_initialize+0x5c> <== NOT EXECUTED
}
}
return RTEMS_SUCCESSFUL;
}
105f90: 2000 movs r0, #0
105f92: b009 add sp, #36 ; 0x24
105f94: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
r->initialized = false;
105f98: 7320 strb r0, [r4, #12] <== NOT EXECUTED
continue;
105f9a: e7cb b.n 105f34 <ramdisk_initialize+0x60> <== NOT EXECUTED
105f9c: 002000a0 .word 0x002000a0 <== NOT EXECUTED
00105fa0 <ramdisk_ioctl>:
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
105fa0: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
105fa4: f244 2507 movw r5, #16903 ; 0x4207
105fa8: f2c2 0500 movt r5, #8192 ; 0x2000
static inline void *rtems_disk_get_driver_data(
const rtems_disk_device *dd
)
{
return dd->driver_data;
105fac: 6bc7 ldr r7, [r0, #60] ; 0x3c
105fae: 42a9 cmp r1, r5
105fb0: d026 beq.n 106000 <ramdisk_ioctl+0x60>
105fb2: f244 2501 movw r5, #16897 ; 0x4201
105fb6: f2cc 0518 movt r5, #49176 ; 0xc018
105fba: 42a9 cmp r1, r5
105fbc: d12b bne.n 106016 <ramdisk_ioctl+0x76>
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
105fbe: 6816 ldr r6, [r2, #0]
105fc0: 4614 mov r4, r2
105fc2: b3ae cbz r6, 106030 <ramdisk_ioctl+0x90>
105fc4: 2e01 cmp r6, #1
105fc6: d12a bne.n 10601e <ramdisk_ioctl+0x7e> <== ALWAYS TAKEN
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
105fc8: 6913 ldr r3, [r2, #16]
uint8_t *to = rd->area;
105fca: f8d7 8008 ldr.w r8, [r7, #8]
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
105fce: b183 cbz r3, 105ff2 <ramdisk_ioctl+0x52>
105fd0: f102 0528 add.w r5, r2, #40 ; 0x28
105fd4: 2600 movs r6, #0
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
105fd6: f855 3c10 ldr.w r3, [r5, #-16]
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
105fda: 3601 adds r6, #1
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
105fdc: 6838 ldr r0, [r7, #0]
105fde: e955 2103 ldrd r2, r1, [r5, #-12]
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
105fe2: 3510 adds r5, #16
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
105fe4: fb00 8003 mla r0, r0, r3, r8
105fe8: f00a ed6a blx 110ac0 <memcpy>
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
105fec: 6923 ldr r3, [r4, #16]
105fee: 429e cmp r6, r3
105ff0: d3f1 bcc.n 105fd6 <ramdisk_ioctl+0x36>
(*req->done)(req, status);
105ff2: 4620 mov r0, r4
105ff4: 6863 ldr r3, [r4, #4]
105ff6: 2100 movs r1, #0
105ff8: 4798 blx r3
{
case RTEMS_BLKDEV_REQ_READ:
return ramdisk_read(rd, r);
case RTEMS_BLKDEV_REQ_WRITE:
return ramdisk_write(rd, r);
105ffa: 2000 movs r0, #0
break;
}
errno = EINVAL;
return -1;
}
105ffc: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
if (rd->free_at_delete_request) {
106000: 7bfb ldrb r3, [r7, #15]
106002: bb5b cbnz r3, 10605c <ramdisk_ioctl+0xbc>
errno = EINVAL;
106004: f00a fb92 bl 11072c <__errno>
106008: 2216 movs r2, #22
10600a: 4603 mov r3, r0
10600c: 601a str r2, [r3, #0]
return -1;
10600e: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
}
106012: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
106016: e8bd 41f0 ldmia.w sp!, {r4, r5, r6, r7, r8, lr}
return rtems_blkdev_ioctl (dd, req, argp);
10601a: f007 bc6d b.w 10d8f8 <rtems_blkdev_ioctl>
errno = EINVAL;
10601e: f00a fb85 bl 11072c <__errno> <== NOT EXECUTED
106022: 2216 movs r2, #22 <== NOT EXECUTED
106024: 4603 mov r3, r0 <== NOT EXECUTED
106026: 601a str r2, [r3, #0] <== NOT EXECUTED
return -1;
106028: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
}
10602c: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
106030: 6913 ldr r3, [r2, #16]
uint8_t *from = rd->area;
106032: f8d7 8008 ldr.w r8, [r7, #8]
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
106036: 2b00 cmp r3, #0
106038: d0db beq.n 105ff2 <ramdisk_ioctl+0x52> <== ALWAYS TAKEN
10603a: f102 0528 add.w r5, r2, #40 ; 0x28
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
10603e: f855 3c10 ldr.w r3, [r5, #-16]
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
106042: 3601 adds r6, #1
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
106044: 6839 ldr r1, [r7, #0]
106046: e955 2003 ldrd r2, r0, [r5, #-12]
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
10604a: 3510 adds r5, #16
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
10604c: fb01 8103 mla r1, r1, r3, r8
106050: f00a ed36 blx 110ac0 <memcpy>
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
106054: 6923 ldr r3, [r4, #16]
106056: 429e cmp r6, r3
106058: d3f1 bcc.n 10603e <ramdisk_ioctl+0x9e> <== ALWAYS TAKEN
10605a: e7ca b.n 105ff2 <ramdisk_ioctl+0x52>
ramdisk_free(rd);
10605c: 4638 mov r0, r7
10605e: f000 f801 bl 106064 <ramdisk_free>
106062: e7cf b.n 106004 <ramdisk_ioctl+0x64>
00105b4c <ramdisk_register>:
uint32_t media_block_size,
rtems_blkdev_bnum media_block_count,
bool trace,
const char *disk
)
{
105b4c: b5f0 push {r4, r5, r6, r7, lr}
105b4e: 460e mov r6, r1
105b50: 4611 mov r1, r2
105b52: b083 sub sp, #12
105b54: 4605 mov r5, r0
105b56: 461f mov r7, r3
rtems_status_code sc = RTEMS_SUCCESSFUL;
ramdisk *rd = NULL;
rd = ramdisk_allocate(NULL, media_block_size, media_block_count, trace);
105b58: 4632 mov r2, r6
105b5a: 460b mov r3, r1
105b5c: 4601 mov r1, r0
105b5e: 2000 movs r0, #0
105b60: f009 ff70 bl 10fa44 <ramdisk_allocate>
if (rd == NULL) {
105b64: b168 cbz r0, 105b82 <ramdisk_register+0x36>
return RTEMS_UNSATISFIED;
}
sc = rtems_blkdev_create(
105b66: 4604 mov r4, r0
105b68: f64f 1381 movw r3, #63873 ; 0xf981
105b6c: 4632 mov r2, r6
105b6e: f2c0 0310 movt r3, #16
105b72: 4629 mov r1, r5
105b74: 4638 mov r0, r7
105b76: 9400 str r4, [sp, #0]
105b78: f009 fe9e bl 10f8b8 <rtems_blkdev_create>
media_block_size,
media_block_count,
ramdisk_ioctl,
rd
);
if (sc != RTEMS_SUCCESSFUL) {
105b7c: b920 cbnz r0, 105b88 <ramdisk_register+0x3c>
return RTEMS_UNSATISFIED;
}
return RTEMS_SUCCESSFUL;
}
105b7e: b003 add sp, #12
105b80: bdf0 pop {r4, r5, r6, r7, pc}
return RTEMS_UNSATISFIED;
105b82: 200d movs r0, #13 <== NOT EXECUTED
}
105b84: b003 add sp, #12 <== NOT EXECUTED
105b86: bdf0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
ramdisk_free(rd);
105b88: 4620 mov r0, r4 <== NOT EXECUTED
105b8a: f009 ff81 bl 10fa90 <ramdisk_free> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
105b8e: 200d movs r0, #13 <== NOT EXECUTED
105b90: e7f5 b.n 105b7e <ramdisk_register+0x32> <== NOT EXECUTED
105b92: bf00 nop
0010d3dc <rtems_bdbuf_get>:
{
10d3dc: b570 push {r4, r5, r6, lr}
10d3de: 4605 mov r5, r0
10d3e0: 481c ldr r0, [pc, #112] ; (10d454 <rtems_bdbuf_get+0x78>)
10d3e2: 460c mov r4, r1
10d3e4: 4616 mov r6, r2
10d3e6: f7fc fd49 bl 109e7c <_Mutex_Acquire>
if (block < dd->block_count)
10d3ea: 6aab ldr r3, [r5, #40] ; 0x28
10d3ec: 429c cmp r4, r3
10d3ee: d21d bcs.n 10d42c <rtems_bdbuf_get+0x50> <== ALWAYS TAKEN
if (dd->block_to_media_block_shift >= 0)
10d3f0: 6b29 ldr r1, [r5, #48] ; 0x30
10d3f2: 2900 cmp r1, #0
return block << dd->block_to_media_block_shift;
10d3f4: bfa8 it ge
10d3f6: 408c lslge r4, r1
if (dd->block_to_media_block_shift >= 0)
10d3f8: db0f blt.n 10d41a <rtems_bdbuf_get+0x3e> <== ALWAYS TAKEN
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
10d3fa: 69a9 ldr r1, [r5, #24]
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
10d3fc: 4628 mov r0, r5
10d3fe: 4421 add r1, r4
10d400: f7ff fec2 bl 10d188 <rtems_bdbuf_get_buffer_for_access>
10d404: 4604 mov r4, r0
switch (bd->state)
10d406: 6a00 ldr r0, [r0, #32]
10d408: 2802 cmp r0, #2
10d40a: d01f beq.n 10d44c <rtems_bdbuf_get+0x70>
10d40c: 2807 cmp r0, #7
10d40e: d019 beq.n 10d444 <rtems_bdbuf_get+0x68>
10d410: 2801 cmp r0, #1
10d412: d013 beq.n 10d43c <rtems_bdbuf_get+0x60> <== NEVER TAKEN
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_2);
10d414: 210a movs r1, #10 <== NOT EXECUTED
10d416: f7fe fd97 bl 10bf48 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
10d41a: e9d5 2108 ldrd r2, r1, [r5, #32] <== NOT EXECUTED
10d41e: 2300 movs r3, #0 <== NOT EXECUTED
10d420: fba4 0101 umull r0, r1, r4, r1 <== NOT EXECUTED
10d424: f002 ffb6 bl 110394 <__aeabi_uldivmod> <== NOT EXECUTED
10d428: 4604 mov r4, r0 <== NOT EXECUTED
return (rtems_blkdev_bnum)
10d42a: e7e6 b.n 10d3fa <rtems_bdbuf_get+0x1e> <== NOT EXECUTED
sc = RTEMS_INVALID_ID;
10d42c: 2504 movs r5, #4 <== NOT EXECUTED
rtems_bdbuf_buffer *bd = NULL;
10d42e: 2400 movs r4, #0 <== NOT EXECUTED
_Mutex_Release( mutex );
10d430: 4808 ldr r0, [pc, #32] ; (10d454 <rtems_bdbuf_get+0x78>)
10d432: f7fc fd4f bl 109ed4 <_Mutex_Release>
}
10d436: 4628 mov r0, r5
*bd_ptr = bd;
10d438: 6034 str r4, [r6, #0]
}
10d43a: bd70 pop {r4, r5, r6, pc}
bd->state = state;
10d43c: 2305 movs r3, #5
}
10d43e: 2500 movs r5, #0
bd->state = state;
10d440: 6223 str r3, [r4, #32]
}
10d442: e7f5 b.n 10d430 <rtems_bdbuf_get+0x54>
bd->state = state;
10d444: 2304 movs r3, #4
}
10d446: 2500 movs r5, #0
bd->state = state;
10d448: 6223 str r3, [r4, #32]
}
10d44a: e7f1 b.n 10d430 <rtems_bdbuf_get+0x54>
bd->state = state;
10d44c: 2303 movs r3, #3
}
10d44e: 2500 movs r5, #0
bd->state = state;
10d450: 6223 str r3, [r4, #32]
}
10d452: e7ed b.n 10d430 <rtems_bdbuf_get+0x54>
10d454: 00202868 .word 0x00202868
0010d89c <rtems_bdbuf_get_device_stats>:
}
void rtems_bdbuf_get_device_stats (const rtems_disk_device *dd,
rtems_blkdev_stats *stats)
{
10d89c: b570 push {r4, r5, r6, lr}
10d89e: 4605 mov r5, r0
_Mutex_Acquire( mutex );
10d8a0: 4e0a ldr r6, [pc, #40] ; (10d8cc <rtems_bdbuf_get_device_stats+0x30>)
10d8a2: 460c mov r4, r1
10d8a4: 4630 mov r0, r6
10d8a6: f7fc fae9 bl 109e7c <_Mutex_Acquire>
rtems_bdbuf_lock_cache ();
*stats = dd->stats;
10d8aa: f105 0e44 add.w lr, r5, #68 ; 0x44
10d8ae: 46a4 mov ip, r4
10d8b0: e8be 000f ldmia.w lr!, {r0, r1, r2, r3}
10d8b4: e8ac 000f stmia.w ip!, {r0, r1, r2, r3}
10d8b8: e89e 000f ldmia.w lr, {r0, r1, r2, r3}
10d8bc: e88c 000f stmia.w ip, {r0, r1, r2, r3}
_Mutex_Release( mutex );
10d8c0: 4630 mov r0, r6
rtems_bdbuf_unlock_cache ();
}
10d8c2: e8bd 4070 ldmia.w sp!, {r4, r5, r6, lr}
10d8c6: f7fc bb05 b.w 109ed4 <_Mutex_Release>
10d8ca: bf00 nop
10d8cc: 00202868 .word 0x00202868
0010d7bc <rtems_bdbuf_purge_dev>:
{
10d7bc: b538 push {r3, r4, r5, lr}
10d7be: 4604 mov r4, r0
_Mutex_Acquire( mutex );
10d7c0: 4d05 ldr r5, [pc, #20] ; (10d7d8 <rtems_bdbuf_purge_dev+0x1c>)
10d7c2: 4628 mov r0, r5
10d7c4: f7fc fb5a bl 109e7c <_Mutex_Acquire>
rtems_bdbuf_do_purge_dev (dd);
10d7c8: 4620 mov r0, r4
10d7ca: f7fe fd49 bl 10c260 <rtems_bdbuf_do_purge_dev>
_Mutex_Release( mutex );
10d7ce: 4628 mov r0, r5
}
10d7d0: e8bd 4038 ldmia.w sp!, {r3, r4, r5, lr}
10d7d4: f7fc bb7e b.w 109ed4 <_Mutex_Release>
10d7d8: 00202868 .word 0x00202868
0010d458 <rtems_bdbuf_read>:
{
10d458: e92d 43f8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
10d45c: 4604 mov r4, r0
_Mutex_Acquire( mutex );
10d45e: 4845 ldr r0, [pc, #276] ; (10d574 <rtems_bdbuf_read+0x11c>)
10d460: 460d mov r5, r1
10d462: 4617 mov r7, r2
10d464: f7fc fd0a bl 109e7c <_Mutex_Acquire>
if (block < dd->block_count)
10d468: 6aa3 ldr r3, [r4, #40] ; 0x28
10d46a: 429d cmp r5, r3
10d46c: d21d bcs.n 10d4aa <rtems_bdbuf_read+0x52> <== ALWAYS TAKEN
if (dd->block_to_media_block_shift >= 0)
10d46e: 6b20 ldr r0, [r4, #48] ; 0x30
10d470: 2800 cmp r0, #0
return block << dd->block_to_media_block_shift;
10d472: bfa8 it ge
10d474: fa05 f000 lslge.w r0, r5, r0
if (dd->block_to_media_block_shift >= 0)
10d478: db0f blt.n 10d49a <rtems_bdbuf_read+0x42> <== ALWAYS TAKEN
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
10d47a: 69a1 ldr r1, [r4, #24]
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
10d47c: 4401 add r1, r0
10d47e: 4620 mov r0, r4
10d480: f7ff fe82 bl 10d188 <rtems_bdbuf_get_buffer_for_access>
10d484: 4606 mov r6, r0
switch (bd->state)
10d486: 6a00 ldr r0, [r0, #32]
10d488: 2802 cmp r0, #2
10d48a: d061 beq.n 10d550 <rtems_bdbuf_read+0xf8>
10d48c: 2807 cmp r0, #7
10d48e: d03a beq.n 10d506 <rtems_bdbuf_read+0xae>
10d490: 2801 cmp r0, #1
10d492: d014 beq.n 10d4be <rtems_bdbuf_read+0x66> <== NEVER TAKEN
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_4);
10d494: 210b movs r1, #11 <== NOT EXECUTED
10d496: f7fe fd57 bl 10bf48 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
10d49a: e9d4 2008 ldrd r2, r0, [r4, #32] <== NOT EXECUTED
10d49e: 2300 movs r3, #0 <== NOT EXECUTED
10d4a0: fba5 0100 umull r0, r1, r5, r0 <== NOT EXECUTED
10d4a4: f002 ff76 bl 110394 <__aeabi_uldivmod> <== NOT EXECUTED
return (rtems_blkdev_bnum)
10d4a8: e7e7 b.n 10d47a <rtems_bdbuf_read+0x22> <== NOT EXECUTED
rtems_bdbuf_buffer *bd = NULL;
10d4aa: 2600 movs r6, #0 <== NOT EXECUTED
sc = RTEMS_INVALID_ID;
10d4ac: f04f 0804 mov.w r8, #4 <== NOT EXECUTED
_Mutex_Release( mutex );
10d4b0: 4830 ldr r0, [pc, #192] ; (10d574 <rtems_bdbuf_read+0x11c>)
10d4b2: f7fc fd0f bl 109ed4 <_Mutex_Release>
}
10d4b6: 4640 mov r0, r8
*bd_ptr = bd;
10d4b8: 603e str r6, [r7, #0]
}
10d4ba: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
++dd->stats.read_misses;
10d4be: 6ca3 ldr r3, [r4, #72] ; 0x48
10d4c0: 3301 adds r3, #1
10d4c2: 64a3 str r3, [r4, #72] ; 0x48
if (dd->read_ahead.trigger != block)
10d4c4: 6ee3 ldr r3, [r4, #108] ; 0x6c
10d4c6: 429d cmp r5, r3
10d4c8: d00a beq.n 10d4e0 <rtems_bdbuf_read+0x88>
return node->next == NULL;
10d4ca: 6e63 ldr r3, [r4, #100] ; 0x64
if (rtems_bdbuf_is_read_ahead_active (dd))
10d4cc: b123 cbz r3, 10d4d8 <rtems_bdbuf_read+0x80>
previous = the_node->previous;
10d4ce: 6ea2 ldr r2, [r4, #104] ; 0x68 <== NOT EXECUTED
next->previous = previous;
10d4d0: 605a str r2, [r3, #4] <== NOT EXECUTED
previous->next = next;
10d4d2: 6013 str r3, [r2, #0] <== NOT EXECUTED
node->next = NULL;
10d4d4: 2300 movs r3, #0 <== NOT EXECUTED
10d4d6: 6663 str r3, [r4, #100] ; 0x64 <== NOT EXECUTED
dd->read_ahead.trigger = block + 1;
10d4d8: 1c6b adds r3, r5, #1
10d4da: 66e3 str r3, [r4, #108] ; 0x6c
dd->read_ahead.next = block + 2;
10d4dc: 1cab adds r3, r5, #2
10d4de: 6723 str r3, [r4, #112] ; 0x70
sc = rtems_bdbuf_execute_read_request (dd, bd, 1);
10d4e0: 2201 movs r2, #1
10d4e2: 4631 mov r1, r6
10d4e4: 4620 mov r0, r4
10d4e6: f7ff fb3d bl 10cb64 <rtems_bdbuf_execute_read_request>
if (sc == RTEMS_SUCCESSFUL)
10d4ea: 4680 mov r8, r0
10d4ec: 2800 cmp r0, #0
10d4ee: d137 bne.n 10d560 <rtems_bdbuf_read+0x108>
++bd->group->users;
10d4f0: 6ab2 ldr r2, [r6, #40] ; 0x28
bd->state = state;
10d4f2: 2003 movs r0, #3
previous = the_node->previous;
10d4f4: e9d6 1300 ldrd r1, r3, [r6]
10d4f8: 6230 str r0, [r6, #32]
next->previous = previous;
10d4fa: 604b str r3, [r1, #4]
previous->next = next;
10d4fc: 6019 str r1, [r3, #0]
++bd->group->users;
10d4fe: 68d3 ldr r3, [r2, #12]
10d500: 3301 adds r3, #1
10d502: 60d3 str r3, [r2, #12]
}
10d504: e006 b.n 10d514 <rtems_bdbuf_read+0xbc>
++dd->stats.read_hits;
10d506: 6c63 ldr r3, [r4, #68] ; 0x44
}
10d508: f04f 0800 mov.w r8, #0
++dd->stats.read_hits;
10d50c: 3301 adds r3, #1
10d50e: 6463 str r3, [r4, #68] ; 0x44
bd->state = state;
10d510: 2304 movs r3, #4
10d512: 6233 str r3, [r6, #32]
if (bdbuf_cache.read_ahead_task != 0
10d514: f642 0940 movw r9, #10304 ; 0x2840
10d518: f2c0 0920 movt r9, #32
10d51c: f8d9 00dc ldr.w r0, [r9, #220] ; 0xdc
10d520: 2800 cmp r0, #0
10d522: d0c5 beq.n 10d4b0 <rtems_bdbuf_read+0x58>
&& dd->read_ahead.trigger == block
10d524: 6ee3 ldr r3, [r4, #108] ; 0x6c
10d526: 429d cmp r5, r3
10d528: d1c2 bne.n 10d4b0 <rtems_bdbuf_read+0x58>
&& !rtems_bdbuf_is_read_ahead_active (dd))
10d52a: 6e63 ldr r3, [r4, #100] ; 0x64
10d52c: 2b00 cmp r3, #0
10d52e: d1bf bne.n 10d4b0 <rtems_bdbuf_read+0x58> <== ALWAYS TAKEN
if (rtems_chain_is_empty (chain))
10d530: f8d9 30e0 ldr.w r3, [r9, #224] ; 0xe0
10d534: f109 05e4 add.w r5, r9, #228 ; 0xe4
10d538: 42ab cmp r3, r5
10d53a: d013 beq.n 10d564 <rtems_bdbuf_read+0x10c> <== NEVER TAKEN
old_last = tail->previous;
10d53c: f8d9 30e8 ldr.w r3, [r9, #232] ; 0xe8
rtems_chain_append_unprotected (chain, &dd->read_ahead.node);
10d540: f104 0264 add.w r2, r4, #100 ; 0x64
the_node->next = tail;
10d544: 6665 str r5, [r4, #100] ; 0x64
tail->previous = the_node;
10d546: f8c9 20e8 str.w r2, [r9, #232] ; 0xe8
old_last->next = the_node;
10d54a: 601a str r2, [r3, #0]
the_node->previous = old_last;
10d54c: 66a3 str r3, [r4, #104] ; 0x68
10d54e: e7af b.n 10d4b0 <rtems_bdbuf_read+0x58>
++dd->stats.read_hits;
10d550: 6c63 ldr r3, [r4, #68] ; 0x44
}
10d552: f04f 0800 mov.w r8, #0
++dd->stats.read_hits;
10d556: 3301 adds r3, #1
10d558: 6463 str r3, [r4, #68] ; 0x44
bd->state = state;
10d55a: 2303 movs r3, #3
10d55c: 6233 str r3, [r6, #32]
}
10d55e: e7d9 b.n 10d514 <rtems_bdbuf_read+0xbc>
bd = NULL;
10d560: 2600 movs r6, #0
10d562: e7d7 b.n 10d514 <rtems_bdbuf_read+0xbc>
sc = rtems_event_send (bdbuf_cache.read_ahead_task,
10d564: 2102 movs r1, #2
10d566: f000 fe27 bl 10e1b8 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
10d56a: 2800 cmp r0, #0
10d56c: d0e6 beq.n 10d53c <rtems_bdbuf_read+0xe4> <== NEVER TAKEN
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);
10d56e: 2005 movs r0, #5 <== NOT EXECUTED
10d570: f7fe fce4 bl 10bf3c <rtems_bdbuf_fatal> <== NOT EXECUTED
10d574: 00202868 .word 0x00202868 <== NOT EXECUTED
0010d578 <rtems_bdbuf_release>:
if (bd == NULL)
10d578: 2800 cmp r0, #0
10d57a: d043 beq.n 10d604 <rtems_bdbuf_release+0x8c> <== ALWAYS TAKEN
{
10d57c: b538 push {r3, r4, r5, lr}
_Mutex_Acquire( mutex );
10d57e: f642 0540 movw r5, #10304 ; 0x2840
10d582: f2c0 0520 movt r5, #32
10d586: 4604 mov r4, r0
10d588: f105 0028 add.w r0, r5, #40 ; 0x28
10d58c: f7fc fc76 bl 109e7c <_Mutex_Acquire>
switch (bd->state)
10d590: 6a20 ldr r0, [r4, #32]
10d592: 2804 cmp r0, #4
10d594: d025 beq.n 10d5e2 <rtems_bdbuf_release+0x6a>
10d596: d90a bls.n 10d5ae <rtems_bdbuf_release+0x36>
10d598: 1f43 subs r3, r0, #5
10d59a: 2b01 cmp r3, #1
10d59c: d834 bhi.n 10d608 <rtems_bdbuf_release+0x90> <== ALWAYS TAKEN
rtems_bdbuf_discard_buffer_after_access (bd);
10d59e: 4620 mov r0, r4
10d5a0: f7fe fe24 bl 10c1ec <rtems_bdbuf_discard_buffer_after_access>
_Mutex_Release( mutex );
10d5a4: 481a ldr r0, [pc, #104] ; (10d610 <rtems_bdbuf_release+0x98>)
10d5a6: f7fc fc95 bl 109ed4 <_Mutex_Release>
return RTEMS_SUCCESSFUL;
10d5aa: 2000 movs r0, #0
}
10d5ac: bd38 pop {r3, r4, r5, pc}
switch (bd->state)
10d5ae: 2803 cmp r0, #3
10d5b0: d12a bne.n 10d608 <rtems_bdbuf_release+0x90> <== ALWAYS TAKEN
--bd->group->users;
10d5b2: 6aa1 ldr r1, [r4, #40] ; 0x28
bd->state = state;
10d5b4: 2002 movs r0, #2
old_last = tail->previous;
10d5b6: 6eaa ldr r2, [r5, #104] ; 0x68
--bd->group->users;
10d5b8: 68cb ldr r3, [r1, #12]
10d5ba: 3b01 subs r3, #1
10d5bc: 60cb str r3, [r1, #12]
the_node->next = tail;
10d5be: f105 0164 add.w r1, r5, #100 ; 0x64
if (bd->waiters)
10d5c2: 6a63 ldr r3, [r4, #36] ; 0x24
10d5c4: 6021 str r1, [r4, #0]
bd->state = state;
10d5c6: 6220 str r0, [r4, #32]
tail->previous = the_node;
10d5c8: 66ac str r4, [r5, #104] ; 0x68
old_last->next = the_node;
10d5ca: 6014 str r4, [r2, #0]
the_node->previous = old_last;
10d5cc: 6062 str r2, [r4, #4]
if (bd->waiters)
10d5ce: b183 cbz r3, 10d5f2 <rtems_bdbuf_release+0x7a>
if (waiters->count > 0)
10d5d0: f8d5 3084 ldr.w r3, [r5, #132] ; 0x84
10d5d4: 2b00 cmp r3, #0
10d5d6: d0e5 beq.n 10d5a4 <rtems_bdbuf_release+0x2c>
_Condition_Broadcast( condition_variable );
10d5d8: f105 0088 add.w r0, r5, #136 ; 0x88
10d5dc: f000 ff46 bl 10e46c <_Condition_Broadcast>
}
10d5e0: e7e0 b.n 10d5a4 <rtems_bdbuf_release+0x2c>
rtems_bdbuf_add_to_modified_list_after_access (bd);
10d5e2: 4620 mov r0, r4
10d5e4: f7ff fe9e bl 10d324 <rtems_bdbuf_add_to_modified_list_after_access>
_Mutex_Release( mutex );
10d5e8: 4809 ldr r0, [pc, #36] ; (10d610 <rtems_bdbuf_release+0x98>)
10d5ea: f7fc fc73 bl 109ed4 <_Mutex_Release>
return RTEMS_SUCCESSFUL;
10d5ee: 2000 movs r0, #0
}
10d5f0: bd38 pop {r3, r4, r5, pc}
if (waiters->count > 0)
10d5f2: f8d5 30b4 ldr.w r3, [r5, #180] ; 0xb4
10d5f6: 2b00 cmp r3, #0
10d5f8: d0d4 beq.n 10d5a4 <rtems_bdbuf_release+0x2c>
_Condition_Broadcast( condition_variable );
10d5fa: f105 00b8 add.w r0, r5, #184 ; 0xb8
10d5fe: f000 ff35 bl 10e46c <_Condition_Broadcast>
}
10d602: e7cf b.n 10d5a4 <rtems_bdbuf_release+0x2c>
return RTEMS_INVALID_ADDRESS;
10d604: 2009 movs r0, #9 <== NOT EXECUTED
}
10d606: 4770 bx lr <== NOT EXECUTED
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_0);
10d608: 2109 movs r1, #9 <== NOT EXECUTED
10d60a: f7fe fc9d bl 10bf48 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
10d60e: bf00 nop <== NOT EXECUTED
10d610: 00202868 .word 0x00202868 <== NOT EXECUTED
0010d614 <rtems_bdbuf_release_modified>:
if (bd == NULL)
10d614: b1f0 cbz r0, 10d654 <rtems_bdbuf_release_modified+0x40>
{
10d616: b510 push {r4, lr}
10d618: 4604 mov r4, r0
_Mutex_Acquire( mutex );
10d61a: 480f ldr r0, [pc, #60] ; (10d658 <rtems_bdbuf_release_modified+0x44>)
10d61c: f7fc fc2e bl 109e7c <_Mutex_Acquire>
switch (bd->state)
10d620: 6a20 ldr r0, [r4, #32]
10d622: 2805 cmp r0, #5
10d624: d909 bls.n 10d63a <rtems_bdbuf_release_modified+0x26>
10d626: 2806 cmp r0, #6
10d628: d109 bne.n 10d63e <rtems_bdbuf_release_modified+0x2a> <== ALWAYS TAKEN
rtems_bdbuf_discard_buffer_after_access (bd);
10d62a: 4620 mov r0, r4
10d62c: f7fe fdde bl 10c1ec <rtems_bdbuf_discard_buffer_after_access>
_Mutex_Release( mutex );
10d630: 4809 ldr r0, [pc, #36] ; (10d658 <rtems_bdbuf_release_modified+0x44>)
10d632: f7fc fc4f bl 109ed4 <_Mutex_Release>
return RTEMS_SUCCESSFUL;
10d636: 2000 movs r0, #0
}
10d638: bd10 pop {r4, pc}
switch (bd->state)
10d63a: 2802 cmp r0, #2
10d63c: d802 bhi.n 10d644 <rtems_bdbuf_release_modified+0x30> <== NEVER TAKEN
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_6);
10d63e: 210d movs r1, #13 <== NOT EXECUTED
10d640: f7fe fc82 bl 10bf48 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
rtems_bdbuf_add_to_modified_list_after_access (bd);
10d644: 4620 mov r0, r4
10d646: f7ff fe6d bl 10d324 <rtems_bdbuf_add_to_modified_list_after_access>
10d64a: 4803 ldr r0, [pc, #12] ; (10d658 <rtems_bdbuf_release_modified+0x44>)
10d64c: f7fc fc42 bl 109ed4 <_Mutex_Release>
return RTEMS_SUCCESSFUL;
10d650: 2000 movs r0, #0
}
10d652: bd10 pop {r4, pc}
return RTEMS_INVALID_ADDRESS;
10d654: 2009 movs r0, #9 <== NOT EXECUTED
}
10d656: 4770 bx lr <== NOT EXECUTED
10d658: 00202868 .word 0x00202868 <== NOT EXECUTED
0010d8d0 <rtems_bdbuf_reset_device_stats>:
void rtems_bdbuf_reset_device_stats (rtems_disk_device *dd)
{
10d8d0: b538 push {r3, r4, r5, lr}
10d8d2: 4604 mov r4, r0
_Mutex_Acquire( mutex );
10d8d4: 4d07 ldr r5, [pc, #28] ; (10d8f4 <rtems_bdbuf_reset_device_stats+0x24>)
10d8d6: 4628 mov r0, r5
10d8d8: f7fc fad0 bl 109e7c <_Mutex_Acquire>
rtems_bdbuf_lock_cache ();
memset (&dd->stats, 0, sizeof(dd->stats));
10d8dc: f104 0044 add.w r0, r4, #68 ; 0x44
10d8e0: 2220 movs r2, #32
10d8e2: 2100 movs r1, #0
10d8e4: f003 fb5c bl 110fa0 <memset>
_Mutex_Release( mutex );
10d8e8: 4628 mov r0, r5
rtems_bdbuf_unlock_cache ();
}
10d8ea: e8bd 4038 ldmia.w sp!, {r3, r4, r5, lr}
10d8ee: f7fc baf1 b.w 109ed4 <_Mutex_Release>
10d8f2: bf00 nop
10d8f4: 00202868 .word 0x00202868
0010d7dc <rtems_bdbuf_set_block_size>:
{
10d7dc: e92d 43f8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
10d7e0: 4606 mov r6, r0
10d7e2: 460d mov r5, r1
if (sync)
10d7e4: 2a00 cmp r2, #0
10d7e6: d152 bne.n 10d88e <rtems_bdbuf_set_block_size+0xb2>
_Mutex_Acquire( mutex );
10d7e8: 482b ldr r0, [pc, #172] ; (10d898 <rtems_bdbuf_set_block_size+0xbc>)
10d7ea: f7fc fb47 bl 109e7c <_Mutex_Acquire>
if (block_size > 0)
10d7ee: b935 cbnz r5, 10d7fe <rtems_bdbuf_set_block_size+0x22>
_Mutex_Release( mutex );
10d7f0: 4829 ldr r0, [pc, #164] ; (10d898 <rtems_bdbuf_set_block_size+0xbc>)
sc = RTEMS_INVALID_NUMBER;
10d7f2: 240a movs r4, #10
10d7f4: f7fc fb6e bl 109ed4 <_Mutex_Release>
}
10d7f8: 4620 mov r0, r4
10d7fa: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
if (size > bdbuf_config.buffer_max)
10d7fe: f647 03dc movw r3, #30940 ; 0x78dc
10d802: f2c0 0311 movt r3, #17
10d806: 6a9a ldr r2, [r3, #40] ; 0x28
10d808: 4295 cmp r5, r2
10d80a: d8f1 bhi.n 10d7f0 <rtems_bdbuf_set_block_size+0x14>
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
10d80c: 6a59 ldr r1, [r3, #36] ; 0x24
10d80e: 1e68 subs r0, r5, #1
10d810: f002 fc32 bl 110078 <__udivsi3>
10d814: 1c43 adds r3, r0, #1
for (bds_per_size = 1;
10d816: 2800 cmp r0, #0
10d818: d03c beq.n 10d894 <rtems_bdbuf_set_block_size+0xb8>
10d81a: 2401 movs r4, #1
bds_per_size <<= 1)
10d81c: 0064 lsls r4, r4, #1
for (bds_per_size = 1;
10d81e: 42a3 cmp r3, r4
10d820: d8fc bhi.n 10d81c <rtems_bdbuf_set_block_size+0x40>
return bdbuf_cache.max_bds_per_group / bds_per_size;
10d822: f642 0340 movw r3, #10304 ; 0x2840
10d826: 4621 mov r1, r4
10d828: f2c0 0320 movt r3, #32
10d82c: 6a1f ldr r7, [r3, #32]
10d82e: 4638 mov r0, r7
10d830: f002 fc22 bl 110078 <__udivsi3>
if (bds_per_group != 0)
10d834: 42a7 cmp r7, r4
return bdbuf_cache.max_bds_per_group / bds_per_size;
10d836: 4680 mov r8, r0
if (bds_per_group != 0)
10d838: d3da bcc.n 10d7f0 <rtems_bdbuf_set_block_size+0x14> <== ALWAYS TAKEN
uint32_t media_blocks_per_block = block_size / dd->media_block_size;
10d83a: f8d6 9020 ldr.w r9, [r6, #32]
10d83e: 4628 mov r0, r5
int block_to_media_block_shift = 0;
10d840: 2400 movs r4, #0
uint32_t media_blocks_per_block = block_size / dd->media_block_size;
10d842: 4649 mov r1, r9
10d844: f002 fc18 bl 110078 <__udivsi3>
while ((one << block_to_media_block_shift) < media_blocks_per_block)
10d848: 2801 cmp r0, #1
uint32_t media_blocks_per_block = block_size / dd->media_block_size;
10d84a: 4607 mov r7, r0
while ((one << block_to_media_block_shift) < media_blocks_per_block)
10d84c: d907 bls.n 10d85e <rtems_bdbuf_set_block_size+0x82>
10d84e: 2201 movs r2, #1
++block_to_media_block_shift;
10d850: 3401 adds r4, #1
while ((one << block_to_media_block_shift) < media_blocks_per_block)
10d852: fa02 f304 lsl.w r3, r2, r4
10d856: 42bb cmp r3, r7
10d858: d3fa bcc.n 10d850 <rtems_bdbuf_set_block_size+0x74>
if ((dd->media_block_size << block_to_media_block_shift) != block_size)
10d85a: fa09 f904 lsl.w r9, r9, r4
dd->block_count = dd->size / media_blocks_per_block;
10d85e: 4639 mov r1, r7
10d860: 69f0 ldr r0, [r6, #28]
block_to_media_block_shift = -1;
10d862: 454d cmp r5, r9
10d864: bf18 it ne
10d866: f04f 34ff movne.w r4, #4294967295 ; 0xffffffff
dd->block_size = block_size;
10d86a: 6275 str r5, [r6, #36] ; 0x24
dd->block_count = dd->size / media_blocks_per_block;
10d86c: f002 fc04 bl 110078 <__udivsi3>
dd->block_to_media_block_shift = block_to_media_block_shift;
10d870: e9c6 740b strd r7, r4, [r6, #44] ; 0x2c
rtems_status_code sc = RTEMS_SUCCESSFUL;
10d874: 2400 movs r4, #0
dd->block_count = dd->size / media_blocks_per_block;
10d876: 62b0 str r0, [r6, #40] ; 0x28
rtems_bdbuf_do_purge_dev (dd);
10d878: 4630 mov r0, r6
dd->bds_per_group = bds_per_group;
10d87a: f8c6 8034 str.w r8, [r6, #52] ; 0x34
rtems_bdbuf_do_purge_dev (dd);
10d87e: f7fe fcef bl 10c260 <rtems_bdbuf_do_purge_dev>
10d882: 4805 ldr r0, [pc, #20] ; (10d898 <rtems_bdbuf_set_block_size+0xbc>)
10d884: f7fc fb26 bl 109ed4 <_Mutex_Release>
}
10d888: 4620 mov r0, r4
10d88a: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
rtems_bdbuf_syncdev (dd);
10d88e: f7ff ff5d bl 10d74c <rtems_bdbuf_syncdev>
10d892: e7a9 b.n 10d7e8 <rtems_bdbuf_set_block_size+0xc>
for (bds_per_size = 1;
10d894: 461c mov r4, r3
10d896: e7c4 b.n 10d822 <rtems_bdbuf_set_block_size+0x46>
10d898: 00202868 .word 0x00202868
0010d65c <rtems_bdbuf_sync>:
if (bd == NULL)
10d65c: 2800 cmp r0, #0
10d65e: d057 beq.n 10d710 <rtems_bdbuf_sync+0xb4> <== ALWAYS TAKEN
{
10d660: b570 push {r4, r5, r6, lr}
_Mutex_Acquire( mutex );
10d662: f642 0540 movw r5, #10304 ; 0x2840
10d666: f2c0 0520 movt r5, #32
10d66a: 4604 mov r4, r0
10d66c: f105 0028 add.w r0, r5, #40 ; 0x28
10d670: f7fc fc04 bl 109e7c <_Mutex_Acquire>
switch (bd->state)
10d674: 6a20 ldr r0, [r4, #32]
10d676: 2805 cmp r0, #5
10d678: d909 bls.n 10d68e <rtems_bdbuf_sync+0x32>
10d67a: 2806 cmp r0, #6
10d67c: d109 bne.n 10d692 <rtems_bdbuf_sync+0x36> <== ALWAYS TAKEN
rtems_bdbuf_discard_buffer_after_access (bd);
10d67e: 4620 mov r0, r4
10d680: f7fe fdb4 bl 10c1ec <rtems_bdbuf_discard_buffer_after_access>
_Mutex_Release( mutex );
10d684: 482d ldr r0, [pc, #180] ; (10d73c <rtems_bdbuf_sync+0xe0>)
10d686: f7fc fc25 bl 109ed4 <_Mutex_Release>
return RTEMS_SUCCESSFUL;
10d68a: 2000 movs r0, #0
}
10d68c: bd70 pop {r4, r5, r6, pc}
switch (bd->state)
10d68e: 2802 cmp r0, #2
10d690: d802 bhi.n 10d698 <rtems_bdbuf_sync+0x3c> <== NEVER TAKEN
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_5);
10d692: 210c movs r1, #12 <== NOT EXECUTED
10d694: f7fe fc58 bl 10bf48 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
if (bd->waiters)
10d698: 6a62 ldr r2, [r4, #36] ; 0x24
bd->state = state;
10d69a: 2108 movs r1, #8
old_last = tail->previous;
10d69c: f8d5 3080 ldr.w r3, [r5, #128] ; 0x80
10d6a0: 6221 str r1, [r4, #32]
the_node->next = tail;
10d6a2: f105 017c add.w r1, r5, #124 ; 0x7c
10d6a6: 6021 str r1, [r4, #0]
tail->previous = the_node;
10d6a8: f8c5 4080 str.w r4, [r5, #128] ; 0x80
old_last->next = the_node;
10d6ac: 601c str r4, [r3, #0]
the_node->previous = old_last;
10d6ae: 6063 str r3, [r4, #4]
if (bd->waiters)
10d6b0: b112 cbz r2, 10d6b8 <rtems_bdbuf_sync+0x5c>
if (waiters->count > 0)
10d6b2: f8d5 3084 ldr.w r3, [r5, #132] ; 0x84
10d6b6: bb33 cbnz r3, 10d706 <rtems_bdbuf_sync+0xaa>
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
10d6b8: 6828 ldr r0, [r5, #0]
10d6ba: 2104 movs r1, #4
10d6bc: f000 fd7c bl 10e1b8 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
10d6c0: 2800 cmp r0, #0
10d6c2: d134 bne.n 10d72e <rtems_bdbuf_sync+0xd2> <== ALWAYS TAKEN
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
10d6c4: 4e1e ldr r6, [pc, #120] ; (10d740 <rtems_bdbuf_sync+0xe4>)
switch (bd->state)
10d6c6: 6a20 ldr r0, [r4, #32]
10d6c8: 2807 cmp r0, #7
10d6ca: d803 bhi.n 10d6d4 <rtems_bdbuf_sync+0x78>
10d6cc: b958 cbnz r0, 10d6e6 <rtems_bdbuf_sync+0x8a>
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_9);
10d6ce: 2110 movs r1, #16 <== NOT EXECUTED
10d6d0: f7fe fc3a bl 10bf48 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
switch (bd->state)
10d6d4: f1a0 0308 sub.w r3, r0, #8
10d6d8: 2b02 cmp r3, #2
10d6da: d8f8 bhi.n 10d6ce <rtems_bdbuf_sync+0x72> <== ALWAYS TAKEN
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
10d6dc: 4631 mov r1, r6
10d6de: 4620 mov r0, r4
10d6e0: f7fe fd64 bl 10c1ac <rtems_bdbuf_wait>
break;
10d6e4: e7ef b.n 10d6c6 <rtems_bdbuf_sync+0x6a>
if (bd->waiters == 0
10d6e6: 6a63 ldr r3, [r4, #36] ; 0x24
10d6e8: 2b00 cmp r3, #0
10d6ea: d1cb bne.n 10d684 <rtems_bdbuf_sync+0x28>
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
10d6ec: 1e43 subs r3, r0, #1
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
10d6ee: 2b01 cmp r3, #1
10d6f0: d8c8 bhi.n 10d684 <rtems_bdbuf_sync+0x28> <== ALWAYS TAKEN
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
10d6f2: 2801 cmp r0, #1
10d6f4: d00e beq.n 10d714 <rtems_bdbuf_sync+0xb8>
if (waiters->count > 0)
10d6f6: f8d5 30b4 ldr.w r3, [r5, #180] ; 0xb4
10d6fa: 2b00 cmp r3, #0
10d6fc: d0c2 beq.n 10d684 <rtems_bdbuf_sync+0x28>
_Condition_Broadcast( condition_variable );
10d6fe: 4811 ldr r0, [pc, #68] ; (10d744 <rtems_bdbuf_sync+0xe8>)
10d700: f000 feb4 bl 10e46c <_Condition_Broadcast>
}
10d704: e7be b.n 10d684 <rtems_bdbuf_sync+0x28>
_Condition_Broadcast( condition_variable );
10d706: f105 0088 add.w r0, r5, #136 ; 0x88
10d70a: f000 feaf bl 10e46c <_Condition_Broadcast>
}
10d70e: e7d3 b.n 10d6b8 <rtems_bdbuf_sync+0x5c>
return RTEMS_INVALID_ADDRESS;
10d710: 2009 movs r0, #9 <== NOT EXECUTED
}
10d712: 4770 bx lr <== NOT EXECUTED
if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)
10d714: e9d4 0105 ldrd r0, r1, [r4, #20]
10d718: f7fe fc24 bl 10bf64 <rtems_bdbuf_avl_remove.constprop.0.isra.0>
10d71c: b950 cbnz r0, 10d734 <rtems_bdbuf_sync+0xd8>
before_node = after_node->next;
10d71e: 6e2b ldr r3, [r5, #96] ; 0x60
the_node->previous = after_node;
10d720: 4a09 ldr r2, [pc, #36] ; (10d748 <rtems_bdbuf_sync+0xec>)
bd->state = state;
10d722: 6220 str r0, [r4, #32]
10d724: 6062 str r2, [r4, #4]
after_node->next = the_node;
10d726: 662c str r4, [r5, #96] ; 0x60
the_node->next = before_node;
10d728: 6023 str r3, [r4, #0]
before_node->previous = the_node;
10d72a: 605c str r4, [r3, #4]
}
10d72c: e7e3 b.n 10d6f6 <rtems_bdbuf_sync+0x9a>
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);
10d72e: 2007 movs r0, #7 <== NOT EXECUTED
10d730: f7fe fc04 bl 10bf3c <rtems_bdbuf_fatal> <== NOT EXECUTED
10d734: 6a20 ldr r0, [r4, #32] <== NOT EXECUTED
10d736: f7fe fd35 bl 10c1a4 <rtems_bdbuf_remove_from_tree.part.0.isra.0> <== NOT EXECUTED
10d73a: bf00 nop <== NOT EXECUTED
10d73c: 00202868 .word 0x00202868 <== NOT EXECUTED
10d740: 002028dc .word 0x002028dc <== NOT EXECUTED
10d744: 002028f8 .word 0x002028f8 <== NOT EXECUTED
10d748: 002028a0 .word 0x002028a0 <== NOT EXECUTED
0010d74c <rtems_bdbuf_syncdev>:
{
10d74c: b530 push {r4, r5, lr}
_Mutex_Acquire( mutex );
10d74e: f642 0440 movw r4, #10304 ; 0x2840
10d752: f2c0 0420 movt r4, #32
10d756: b083 sub sp, #12
10d758: 4605 mov r5, r0
10d75a: f104 003c add.w r0, r4, #60 ; 0x3c
10d75e: f7fc fb8d bl 109e7c <_Mutex_Acquire>
10d762: f104 0028 add.w r0, r4, #40 ; 0x28
10d766: f7fc fb89 bl 109e7c <_Mutex_Acquire>
bdbuf_cache.sync_active = true;
10d76a: 2301 movs r3, #1
10d76c: f884 3050 strb.w r3, [r4, #80] ; 0x50
bdbuf_cache.sync_requester = rtems_task_self ();
10d770: f000 fe1a bl 10e3a8 <rtems_task_self>
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
10d774: 2104 movs r1, #4
bdbuf_cache.sync_requester = rtems_task_self ();
10d776: 4603 mov r3, r0
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
10d778: 6820 ldr r0, [r4, #0]
bdbuf_cache.sync_device = dd;
10d77a: e9c4 3515 strd r3, r5, [r4, #84] ; 0x54
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
10d77e: f000 fd1b bl 10e1b8 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
10d782: b9a0 cbnz r0, 10d7ae <rtems_bdbuf_syncdev+0x62>
_Mutex_Release( mutex );
10d784: 4605 mov r5, r0
10d786: f104 0028 add.w r0, r4, #40 ; 0x28
10d78a: f7fc fba3 bl 109ed4 <_Mutex_Release>
return rtems_event_system_receive(
10d78e: 462a mov r2, r5
10d790: 4629 mov r1, r5
10d792: ab01 add r3, sp, #4
10d794: f04f 4000 mov.w r0, #2147483648 ; 0x80000000
10d798: f000 fd70 bl 10e27c <rtems_event_system_receive>
if (sc != RTEMS_SUCCESSFUL)
10d79c: 4605 mov r5, r0
10d79e: b948 cbnz r0, 10d7b4 <rtems_bdbuf_syncdev+0x68>
10d7a0: f104 003c add.w r0, r4, #60 ; 0x3c
10d7a4: f7fc fb96 bl 109ed4 <_Mutex_Release>
}
10d7a8: 4628 mov r0, r5
10d7aa: b003 add sp, #12
10d7ac: bd30 pop {r4, r5, pc}
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);
10d7ae: 2007 movs r0, #7 <== NOT EXECUTED
10d7b0: f7fe fbc4 bl 10bf3c <rtems_bdbuf_fatal> <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_TRANS_EVNT);
10d7b4: 2016 movs r0, #22 <== NOT EXECUTED
10d7b6: f7fe fbc1 bl 10bf3c <rtems_bdbuf_fatal> <== NOT EXECUTED
10d7ba: bf00 nop
00104b00 <rtems_bdpart_create>:
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
104b00: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
104b04: b087 sub sp, #28
104b06: f8dd 8040 ldr.w r8, [sp, #64] ; 0x40
104b0a: 4691 mov r9, r2
104b0c: 461c mov r4, r3
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
104b0e: 460d mov r5, r1
104b10: b111 cbz r1, 104b18 <rtems_bdpart_create+0x18>
&& format->type == RTEMS_BDPART_FORMAT_MBR
104b12: 680b ldr r3, [r1, #0]
104b14: 2b00 cmp r3, #0
104b16: d032 beq.n 104b7e <rtems_bdpart_create+0x7e> <== NEVER TAKEN
104b18: 2300 movs r3, #0 <== NOT EXECUTED
&& format->mbr.dos_compatibility;
104b1a: f04f 0b00 mov.w fp, #0 <== NOT EXECUTED
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
104b1e: f04f 0a01 mov.w sl, #1 <== NOT EXECUTED
104b22: 9305 str r3, [sp, #20] <== NOT EXECUTED
rtems_blkdev_bnum overhead = 0;
rtems_blkdev_bnum free_space = 0;
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
104b24: f1b8 0f00 cmp.w r8, #0 <== NOT EXECUTED
104b28: d03a beq.n 104ba0 <rtems_bdpart_create+0xa0> <== NOT EXECUTED
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
104b2a: 429c cmp r4, r3
104b2c: bf18 it ne
104b2e: 4599 cmpne r9, r3
104b30: bf0c ite eq
104b32: 2201 moveq r2, #1
104b34: 2200 movne r2, #0
104b36: 429d cmp r5, r3
104b38: bf08 it eq
104b3a: f042 0201 orreq.w r2, r2, #1
104b3e: 2a00 cmp r2, #0
104b40: d132 bne.n 104ba8 <rtems_bdpart_create+0xa8> <== ALWAYS TAKEN
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, NULL, NULL, &disk_end);
104b42: ab05 add r3, sp, #20
104b44: 4611 mov r1, r2
104b46: f000 f9bf bl 104ec8 <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
104b4a: bb70 cbnz r0, 104baa <rtems_bdpart_create+0xaa>
104b4c: 1f23 subs r3, r4, #4
return sc;
}
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
104b4e: 4607 mov r7, r0
if (sc != RTEMS_SUCCESSFUL) {
104b50: 469c mov ip, r3
104b52: e002 b.n 104b5a <rtems_bdpart_create+0x5a>
for (i = 0; i < count; ++i) {
104b54: 45a0 cmp r8, r4
104b56: d02b beq.n 104bb0 <rtems_bdpart_create+0xb0>
104b58: 4627 mov r7, r4
unsigned prev_sum = dist_sum;
dist_sum += dist [i];
104b5a: f85c 2f04 ldr.w r2, [ip, #4]!
for (i = 0; i < count; ++i) {
104b5e: 1c7c adds r4, r7, #1
104b60: 1816 adds r6, r2, r0
104b62: bf2c ite cs
104b64: 2101 movcs r1, #1
104b66: 2100 movcc r1, #0
if (dist_sum < prev_sum) {
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
104b68: 2a00 cmp r2, #0
104b6a: bf08 it eq
104b6c: f041 0101 orreq.w r1, r1, #1
dist_sum += dist [i];
104b70: 4630 mov r0, r6
if (dist [i] == 0) {
104b72: 2900 cmp r1, #0
104b74: d0ee beq.n 104b54 <rtems_bdpart_create+0x54> <== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
104b76: 200a movs r0, #10 <== NOT EXECUTED
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
return RTEMS_SUCCESSFUL;
}
104b78: b007 add sp, #28 <== NOT EXECUTED
104b7a: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
&& format->mbr.dos_compatibility;
104b7e: 7a0b ldrb r3, [r1, #8]
104b80: 2b00 cmp r3, #0
104b82: f04f 0300 mov.w r3, #0
104b86: bf0b itete eq
104b88: f04f 0b00 moveq.w fp, #0
104b8c: f04f 0b01 movne.w fp, #1
104b90: f04f 0a01 moveq.w sl, #1
104b94: f04f 0a3f movne.w sl, #63 ; 0x3f
104b98: 9305 str r3, [sp, #20]
if (count == 0) {
104b9a: f1b8 0f00 cmp.w r8, #0
104b9e: d1c4 bne.n 104b2a <rtems_bdpart_create+0x2a> <== NEVER TAKEN
return RTEMS_SUCCESSFUL;
104ba0: 4640 mov r0, r8 <== NOT EXECUTED
}
104ba2: b007 add sp, #28 <== NOT EXECUTED
104ba4: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
104ba8: 2009 movs r0, #9 <== NOT EXECUTED
}
104baa: b007 add sp, #28
104bac: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
104bb0: 682a ldr r2, [r5, #0]
return RTEMS_NOT_IMPLEMENTED;
104bb2: 2018 movs r0, #24
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
104bb4: 2a00 cmp r2, #0
104bb6: d1f8 bne.n 104baa <rtems_bdpart_create+0xaa> <== ALWAYS TAKEN
disk_end -= (disk_end % record_space);
104bb8: 9a05 ldr r2, [sp, #20]
104bba: 4615 mov r5, r2
104bbc: 9202 str r2, [sp, #8]
if (dos_compatibility) {
104bbe: f1bb 0f00 cmp.w fp, #0
104bc2: d146 bne.n 104c52 <rtems_bdpart_create+0x152> <== NEVER TAKEN
if (count > 4) {
104bc4: 2c04 cmp r4, #4 <== NOT EXECUTED
overhead += record_space;
104bc6: bf98 it ls <== NOT EXECUTED
104bc8: 4652 movls r2, sl <== NOT EXECUTED
if (count > 4) {
104bca: d902 bls.n 104bd2 <rtems_bdpart_create+0xd2> <== NOT EXECUTED
overhead += (count - 3) * record_space;
104bcc: 1e7a subs r2, r7, #1 <== NOT EXECUTED
104bce: fb0a f202 mul.w r2, sl, r2 <== NOT EXECUTED
if ((overhead + count) > disk_end) {
104bd2: 9802 ldr r0, [sp, #8]
104bd4: 1911 adds r1, r2, r4
104bd6: 4281 cmp r1, r0
return RTEMS_IO_ERROR;
104bd8: bf88 it hi
104bda: 201b movhi r0, #27
if ((overhead + count) > disk_end) {
104bdc: d8e5 bhi.n 104baa <rtems_bdpart_create+0xaa> <== ALWAYS TAKEN
free_space = disk_end - overhead;
104bde: 1a81 subs r1, r0, r2
for (i = 0; i < count; ++i) {
104be0: 464a mov r2, r9
104be2: e9cd 4700 strd r4, r7, [sp]
104be6: f04f 0b00 mov.w fp, #0
104bea: 4634 mov r4, r6
104bec: f8cd 900c str.w r9, [sp, #12]
104bf0: 461f mov r7, r3
104bf2: 4689 mov r9, r1
104bf4: 4656 mov r6, sl
104bf6: 4690 mov r8, r2
104bf8: e01e b.n 104c38 <rtems_bdpart_create+0x138>
if (s == 0) {
104bfa: 42a0 cmp r0, r4
104bfc: d302 bcc.n 104c04 <rtems_bdpart_create+0x104> <== ALWAYS TAKEN
s /= dist_sum;
104bfe: f00b fa3b bl 110078 <__udivsi3>
104c02: 4605 mov r5, r0
s += record_space - (s % record_space);
104c04: 4628 mov r0, r5
104c06: 4651 mov r1, sl
104c08: f00b fb64 bl 1102d4 <__aeabi_uidivmod>
if (count > 4 && i > 2) {
104c0c: 9b00 ldr r3, [sp, #0]
104c0e: 4455 add r5, sl
s += record_space - (s % record_space);
104c10: 1a6d subs r5, r5, r1
for (i = 0; i < count; ++i) {
104c12: f10b 0101 add.w r1, fp, #1
104c16: f108 0830 add.w r8, r8, #48 ; 0x30
if (count > 4 && i > 2) {
104c1a: 2b04 cmp r3, #4
104c1c: bf88 it hi
104c1e: f1bb 0f02 cmphi.w fp, #2
for (i = 0; i < count; ++i) {
104c22: 9b01 ldr r3, [sp, #4]
pos += record_space;
104c24: bf88 it hi
104c26: 4456 addhi r6, sl
p->begin = pos;
104c28: f848 6c30 str.w r6, [r8, #-48]
pos += s;
104c2c: 442e add r6, r5
for (i = 0; i < count; ++i) {
104c2e: 455b cmp r3, fp
p->end = pos;
104c30: f848 6c2c str.w r6, [r8, #-44]
for (i = 0; i < count; ++i) {
104c34: 468b mov fp, r1
104c36: d01b beq.n 104c70 <rtems_bdpart_create+0x170>
rtems_blkdev_bnum s = free_space * dist [i];
104c38: f857 0f04 ldr.w r0, [r7, #4]!
s /= dist_sum;
104c3c: 4621 mov r1, r4
s = 1;
104c3e: 2501 movs r5, #1
if (s < free_space || s < dist [i]) {
104c40: 4684 mov ip, r0
104c42: 4548 cmp r0, r9
rtems_blkdev_bnum s = free_space * dist [i];
104c44: fb09 f000 mul.w r0, r9, r0
if (s < free_space || s < dist [i]) {
104c48: bf38 it cc
104c4a: 46cc movcc ip, r9
104c4c: 4560 cmp r0, ip
104c4e: d2d4 bcs.n 104bfa <rtems_bdpart_create+0xfa> <== NEVER TAKEN
104c50: e791 b.n 104b76 <rtems_bdpart_create+0x76> <== NOT EXECUTED
disk_end -= (disk_end % record_space);
104c52: 4610 mov r0, r2
104c54: 4651 mov r1, sl
104c56: 9300 str r3, [sp, #0]
104c58: f00b fb3c bl 1102d4 <__aeabi_uidivmod>
if (count > 4) {
104c5c: 2c04 cmp r4, #4
disk_end -= (disk_end % record_space);
104c5e: eba5 0301 sub.w r3, r5, r1
104c62: 9302 str r3, [sp, #8]
if (count > 4) {
104c64: 9b00 ldr r3, [sp, #0]
104c66: d80f bhi.n 104c88 <rtems_bdpart_create+0x188> <== NEVER TAKEN
overhead += record_space;
104c68: 4652 mov r2, sl <== NOT EXECUTED
overhead += (count - 1) * record_space;
104c6a: fb07 220a mla r2, r7, sl, r2
104c6e: e7b0 b.n 104bd2 <rtems_bdpart_create+0xd2>
pt [count - 1].end = disk_end;
104c70: 9c00 ldr r4, [sp, #0]
return RTEMS_SUCCESSFUL;
104c72: 2000 movs r0, #0
pt [count - 1].end = disk_end;
104c74: f8dd 900c ldr.w r9, [sp, #12]
104c78: 9b02 ldr r3, [sp, #8]
104c7a: eb04 0444 add.w r4, r4, r4, lsl #1
104c7e: eb09 1904 add.w r9, r9, r4, lsl #4
104c82: f849 3c2c str.w r3, [r9, #-44]
return RTEMS_SUCCESSFUL;
104c86: e790 b.n 104baa <rtems_bdpart_create+0xaa>
overhead += (count - 3) * record_space;
104c88: 1e7a subs r2, r7, #1
104c8a: fb0a f202 mul.w r2, sl, r2
if (dos_compatibility) {
104c8e: e7ec b.n 104c6a <rtems_bdpart_create+0x16a>
00104c90 <rtems_bdpart_dump>:
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
104c90: e92d 43f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, lr}
104c94: 4604 mov r4, r0
104c96: 460e mov r6, r1
size_t i = 0;
printf(
104c98: f647 20e4 movw r0, #31460 ; 0x7ae4
{
104c9c: b08f sub sp, #60 ; 0x3c
printf(
104c9e: f2c0 0011 movt r0, #17
104ca2: f7ff ff25 bl 104af0 <__wrap_puts>
"------------+------------+-----------------------------------------------------\n"
" BEGIN | LAST | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
104ca6: 2e00 cmp r6, #0
104ca8: d041 beq.n 104d2e <rtems_bdpart_dump+0x9e> <== ALWAYS TAKEN
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
104caa: f647 4824 movw r8, #31780 ; 0x7c24
type = "DATA";
104cae: f647 27dc movw r7, #31452 ; 0x7adc
type = "FAT 12";
104cb2: f647 29ac movw r9, #31404 ; 0x7aac
104cb6: 3408 adds r4, #8
for (i = 0; i < count; ++i) {
104cb8: 2500 movs r5, #0
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
104cba: f2c0 0811 movt r8, #17
type = "DATA";
104cbe: f2c0 0711 movt r7, #17
type = "FAT 12";
104cc2: f2c0 0911 movt r9, #17
uint8_t type_mbr = 0;
104cc6: 2300 movs r3, #0
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
104cc8: f10d 0103 add.w r1, sp, #3
104ccc: 4620 mov r0, r4
uint8_t type_mbr = 0;
104cce: f88d 3003 strb.w r3, [sp, #3]
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
104cd2: f000 f8e9 bl 104ea8 <rtems_bdpart_to_mbr_partition_type>
104cd6: 2800 cmp r0, #0
104cd8: d043 beq.n 104d62 <rtems_bdpart_dump+0xd2> <== ALWAYS TAKEN
switch (type_mbr) {
104cda: f89d 3003 ldrb.w r3, [sp, #3]
104cde: 2b0e cmp r3, #14
104ce0: d80c bhi.n 104cfc <rtems_bdpart_dump+0x6c> <== ALWAYS TAKEN
104ce2: b17b cbz r3, 104d04 <rtems_bdpart_dump+0x74>
104ce4: 1e5a subs r2, r3, #1
104ce6: 2a0d cmp r2, #13
104ce8: d80c bhi.n 104d04 <rtems_bdpart_dump+0x74> <== ALWAYS TAKEN
104cea: e8df f002 tbb [pc, r2]
104cee: 0b38 .short 0x0b38
104cf0: 0b0b400b .word 0x0b0b400b
104cf4: 0b0b0b0b .word 0x0b0b0b0b
104cf8: 290b2e33 .word 0x290b2e33
104cfc: 2bda cmp r3, #218 ; 0xda <== NOT EXECUTED
type = "DATA";
104cfe: bf08 it eq <== NOT EXECUTED
104d00: 463b moveq r3, r7 <== NOT EXECUTED
switch (type_mbr) {
104d02: d005 beq.n 104d10 <rtems_bdpart_dump+0x80> <== NOT EXECUTED
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
104d04: 4642 mov r2, r8 <== NOT EXECUTED
104d06: 2134 movs r1, #52 ; 0x34 <== NOT EXECUTED
104d08: a801 add r0, sp, #4 <== NOT EXECUTED
104d0a: f00c f9fb bl 111104 <snprintf> <== NOT EXECUTED
type = type_buffer;
104d0e: ab01 add r3, sp, #4 <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
104d10: f854 2c04 ldr.w r2, [r4, #-4]
104d14: f647 4030 movw r0, #31792 ; 0x7c30
104d18: f854 1c08 ldr.w r1, [r4, #-8]
104d1c: f2c0 0011 movt r0, #17
for (i = 0; i < count; ++i) {
104d20: 3501 adds r5, #1
104d22: 3430 adds r4, #48 ; 0x30
printf(
104d24: 3a01 subs r2, #1
104d26: f7ff fed1 bl 104acc <__wrap_printf>
for (i = 0; i < count; ++i) {
104d2a: 42ae cmp r6, r5
104d2c: d1cb bne.n 104cc6 <rtems_bdpart_dump+0x36>
p->end - 1U,
type
);
}
puts( "------------+------------+-----------------------------------------------------");
104d2e: f647 30d4 movw r0, #31700 ; 0x7bd4
104d32: f2c0 0011 movt r0, #17
}
104d36: b00f add sp, #60 ; 0x3c
104d38: e8bd 43f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, lr}
puts( "------------+------------+-----------------------------------------------------");
104d3c: f7ff bed8 b.w 104af0 <__wrap_puts>
type = "FAT 16 LBA";
104d40: f647 23b4 movw r3, #31412 ; 0x7ab4 <== NOT EXECUTED
104d44: f2c0 0311 movt r3, #17 <== NOT EXECUTED
break;
104d48: e7e2 b.n 104d10 <rtems_bdpart_dump+0x80> <== NOT EXECUTED
type = "FAT 32 LBA";
104d4a: f647 23c8 movw r3, #31432 ; 0x7ac8 <== NOT EXECUTED
104d4e: f2c0 0311 movt r3, #17 <== NOT EXECUTED
break;
104d52: e7dd b.n 104d10 <rtems_bdpart_dump+0x80> <== NOT EXECUTED
type = "FAT 32";
104d54: f647 23d4 movw r3, #31444 ; 0x7ad4
104d58: f2c0 0311 movt r3, #17
break;
104d5c: e7d8 b.n 104d10 <rtems_bdpart_dump+0x80>
type = "FAT 12";
104d5e: 464b mov r3, r9 <== NOT EXECUTED
104d60: e7d6 b.n 104d10 <rtems_bdpart_dump+0x80> <== NOT EXECUTED
uuid_unparse_lower( type, str);
104d62: 4620 mov r0, r4 <== NOT EXECUTED
104d64: a901 add r1, sp, #4 <== NOT EXECUTED
104d66: f003 fe03 bl 108970 <uuid_unparse_lower> <== NOT EXECUTED
type = type_buffer;
104d6a: ab01 add r3, sp, #4 <== NOT EXECUTED
104d6c: e7d0 b.n 104d10 <rtems_bdpart_dump+0x80> <== NOT EXECUTED
switch (type_mbr) {
104d6e: f647 23c0 movw r3, #31424 ; 0x7ac0 <== NOT EXECUTED
104d72: f2c0 0311 movt r3, #17 <== NOT EXECUTED
104d76: e7cb b.n 104d10 <rtems_bdpart_dump+0x80> <== NOT EXECUTED
00104ec8 <rtems_bdpart_get_disk_data>:
{
104ec8: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
rtems_disk_device *dd = NULL;
104ecc: 2400 movs r4, #0
{
104ece: b082 sub sp, #8
104ed0: 460f mov r7, r1
fd = open( disk_name, O_RDWR);
104ed2: 2102 movs r1, #2
{
104ed4: 4616 mov r6, r2
rtems_disk_device *dd = NULL;
104ed6: 9401 str r4, [sp, #4]
{
104ed8: 4698 mov r8, r3
fd = open( disk_name, O_RDWR);
104eda: f001 fdc9 bl 106a70 <open>
if (fd < 0) {
104ede: 1e05 subs r5, r0, #0
sc = RTEMS_INVALID_NAME;
104ee0: bfb8 it lt
104ee2: 2403 movlt r4, #3
if (fd < 0) {
104ee4: db19 blt.n 104f1a <rtems_bdpart_get_disk_data+0x52> <== ALWAYS TAKEN
104ee6: f244 2109 movw r1, #16905 ; 0x4209
104eea: aa01 add r2, sp, #4
104eec: f2c4 0104 movt r1, #16388 ; 0x4004
104ef0: f001 fa34 bl 10635c <ioctl>
if (rv != 0) {
104ef4: b9a8 cbnz r0, 104f22 <rtems_bdpart_get_disk_data+0x5a>
disk_begin = dd->start;
104ef6: 9a01 ldr r2, [sp, #4]
104ef8: e9d2 3106 ldrd r3, r1, [r2, #24]
*disk_end = dd->size;
104efc: f8c8 1000 str.w r1, [r8]
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
104f00: 6a54 ldr r4, [r2, #36] ; 0x24
if (disk_begin != 0) {
104f02: f5b4 7f00 cmp.w r4, #512 ; 0x200
104f06: bf28 it cs
104f08: 2b00 cmpcs r3, #0
104f0a: bf16 itet ne
104f0c: 2401 movne r4, #1
104f0e: 2400 moveq r4, #0
sc = RTEMS_IO_ERROR;
104f10: 241b movne r4, #27
if (disk_begin != 0) {
104f12: d008 beq.n 104f26 <rtems_bdpart_get_disk_data+0x5e> <== NEVER TAKEN
close( fd);
104f14: 4628 mov r0, r5
104f16: f001 f8ed bl 1060f4 <close>
}
104f1a: 4620 mov r0, r4
104f1c: b002 add sp, #8
104f1e: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
sc = RTEMS_INVALID_NAME;
104f22: 2403 movs r4, #3 <== NOT EXECUTED
104f24: e7f6 b.n 104f14 <rtems_bdpart_get_disk_data+0x4c> <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
104f26: 2f00 cmp r7, #0
104f28: bf18 it ne
104f2a: 2e00 cmpne r6, #0
104f2c: bf14 ite ne
104f2e: 2301 movne r3, #1
104f30: 2300 moveq r3, #0
104f32: d005 beq.n 104f40 <rtems_bdpart_get_disk_data+0x78>
}
104f34: 4620 mov r0, r4
*fd_ptr = fd;
104f36: 603d str r5, [r7, #0]
*dd_ptr = dd;
104f38: 6032 str r2, [r6, #0]
}
104f3a: b002 add sp, #8
104f3c: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
rtems_status_code sc = RTEMS_SUCCESSFUL;
104f40: 461c mov r4, r3
104f42: e7e7 b.n 104f14 <rtems_bdpart_get_disk_data+0x4c>
00104f44 <rtems_bdpart_read>:
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
104f44: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
104f48: 4615 mov r5, r2
104f4a: b086 sub sp, #24
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
104f4c: 2200 movs r2, #0
{
104f4e: 460f mov r7, r1
rtems_bdpart_partition *p = pt - 1;
104f50: f1a5 0130 sub.w r1, r5, #48 ; 0x30
rtems_bdbuf_buffer *block = NULL;
104f54: 9200 str r2, [sp, #0]
rtems_bdpart_partition *p = pt - 1;
104f56: 9101 str r1, [sp, #4]
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
104f58: 2b00 cmp r3, #0
104f5a: d032 beq.n 104fc2 <rtems_bdpart_read+0x7e> <== ALWAYS TAKEN
const uint8_t *data = NULL;
int fd = -1;
rtems_disk_device *dd = NULL;
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
104f5c: 2d00 cmp r5, #0
104f5e: bf18 it ne
104f60: 2f00 cmpne r7, #0
104f62: 461e mov r6, r3
int fd = -1;
104f64: f04f 33ff mov.w r3, #4294967295 ; 0xffffffff
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
104f68: f8d6 8000 ldr.w r8, [r6]
int fd = -1;
104f6c: 9304 str r3, [sp, #16]
if (format == NULL || pt == NULL || count == NULL) {
104f6e: bf0c ite eq
104f70: 2301 moveq r3, #1
104f72: 2300 movne r3, #0
rtems_blkdev_bnum disk_end = 0;
104f74: e9cd 2202 strd r2, r2, [sp, #8]
rtems_disk_device *dd = NULL;
104f78: 9205 str r2, [sp, #20]
if (format == NULL || pt == NULL || count == NULL) {
104f7a: d022 beq.n 104fc2 <rtems_bdpart_read+0x7e> <== ALWAYS TAKEN
return RTEMS_INVALID_ADDRESS;
}
/* Set count to a save value */
*count = 0;
104f7c: 6033 str r3, [r6, #0]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
104f7e: aa05 add r2, sp, #20
104f80: ab03 add r3, sp, #12
104f82: a904 add r1, sp, #16
104f84: f7ff ffa0 bl 104ec8 <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
104f88: 4604 mov r4, r0
104f8a: b118 cbz r0, 104f94 <rtems_bdpart_read+0x50>
if (block != NULL) {
rtems_bdbuf_release( block);
}
return esc;
}
104f8c: 4620 mov r0, r4 <== NOT EXECUTED
104f8e: b006 add sp, #24 <== NOT EXECUTED
104f90: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
sc = rtems_bdpart_read_record( dd, 0, &block);
104f94: 4601 mov r1, r0
104f96: 466a mov r2, sp
104f98: 9805 ldr r0, [sp, #20]
104f9a: f7ff ff49 bl 104e30 <rtems_bdpart_read_record>
if (sc != RTEMS_SUCCESSFUL) {
104f9e: 4604 mov r4, r0
104fa0: b1a0 cbz r0, 104fcc <rtems_bdpart_read+0x88>
if (fd >= 0) {
104fa2: 9804 ldr r0, [sp, #16]
104fa4: 2800 cmp r0, #0
104fa6: f280 8096 bge.w 1050d6 <rtems_bdpart_read+0x192> <== NEVER TAKEN
if (block != NULL) {
104faa: f8dd e000 ldr.w lr, [sp] <== NOT EXECUTED
104fae: f1be 0f00 cmp.w lr, #0 <== NOT EXECUTED
104fb2: d0eb beq.n 104f8c <rtems_bdpart_read+0x48> <== NOT EXECUTED
rtems_bdbuf_release( block);
104fb4: 4670 mov r0, lr
104fb6: f008 fadf bl 10d578 <rtems_bdbuf_release>
}
104fba: 4620 mov r0, r4
104fbc: b006 add sp, #24
104fbe: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
return RTEMS_INVALID_ADDRESS;
104fc2: 2409 movs r4, #9 <== NOT EXECUTED
}
104fc4: 4620 mov r0, r4 <== NOT EXECUTED
104fc6: b006 add sp, #24 <== NOT EXECUTED
104fc8: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
104fcc: 9b00 ldr r3, [sp, #0]
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
104fce: eb08 0848 add.w r8, r8, r8, lsl #1
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
104fd2: a901 add r1, sp, #4
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
104fd4: eb05 1808 add.w r8, r5, r8, lsl #4
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
104fd8: f8d3 a01c ldr.w sl, [r3, #28]
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
104fdc: ab02 add r3, sp, #8
104fde: 4642 mov r2, r8
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
104fe0: f50a 79df add.w r9, sl, #446 ; 0x1be
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
104fe4: 4648 mov r0, r9
104fe6: f7ff fec7 bl 104d78 <rtems_bdpart_read_mbr_partition>
if (sc != RTEMS_SUCCESSFUL) {
104fea: 4604 mov r4, r0
104fec: 2800 cmp r0, #0
104fee: d1d8 bne.n 104fa2 <rtems_bdpart_read+0x5e> <== ALWAYS TAKEN
104ff0: 9b01 ldr r3, [sp, #4]
if (rtems_bdpart_mbr_partition_type( p->type) == RTEMS_BDPART_MBR_GPT) {
104ff2: 7a1b ldrb r3, [r3, #8]
104ff4: 2bee cmp r3, #238 ; 0xee
104ff6: d079 beq.n 1050ec <rtems_bdpart_read+0x1a8> <== ALWAYS TAKEN
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
104ff8: 9b00 ldr r3, [sp, #0]
format->type = RTEMS_BDPART_FORMAT_MBR;
104ffa: 6038 str r0, [r7, #0]
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
104ffc: 69da ldr r2, [r3, #28]
104ffe: f502 73de add.w r3, r2, #444 ; 0x1bc
105002: f502 72dc add.w r2, r2, #440 ; 0x1b8
value = (value << 8) + data [i];
105006: f813 1d01 ldrb.w r1, [r3, #-1]!
for (i = 3; i >= 0; --i) {
10500a: 429a cmp r2, r3
value = (value << 8) + data [i];
10500c: eb01 2404 add.w r4, r1, r4, lsl #8
for (i = 3; i >= 0; --i) {
105010: d1f9 bne.n 105006 <rtems_bdpart_read+0xc2>
}
return value;
105012: f50a 7af7 add.w sl, sl, #494 ; 0x1ee
format->mbr.dos_compatibility = true;
105016: 2301 movs r3, #1
format->mbr.disk_id = rtems_uint32_from_little_endian(
105018: 607c str r4, [r7, #4]
format->mbr.dos_compatibility = true;
10501a: 723b strb r3, [r7, #8]
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
10501c: f109 0910 add.w r9, r9, #16
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
105020: ab02 add r3, sp, #8
105022: 4642 mov r2, r8
105024: a901 add r1, sp, #4
105026: 4648 mov r0, r9
105028: f7ff fea6 bl 104d78 <rtems_bdpart_read_mbr_partition>
if (sc != RTEMS_SUCCESSFUL) {
10502c: 4604 mov r4, r0
10502e: 2800 cmp r0, #0
105030: d1b7 bne.n 104fa2 <rtems_bdpart_read+0x5e> <== ALWAYS TAKEN
for (i = 1; i < 4; ++i) {
105032: 45ca cmp sl, r9
105034: d1f2 bne.n 10501c <rtems_bdpart_read+0xd8>
ebr = ep_begin;
105036: 9f02 ldr r7, [sp, #8]
while (ebr != 0) {
105038: 2f00 cmp r7, #0
10503a: d05d beq.n 1050f8 <rtems_bdpart_read+0x1b4> <== ALWAYS TAKEN
sc = rtems_bdpart_read_record( dd, ebr, &block);
10503c: 9805 ldr r0, [sp, #20]
10503e: 466a mov r2, sp
105040: 4639 mov r1, r7
105042: f7ff fef5 bl 104e30 <rtems_bdpart_read_record>
if (sc != RTEMS_SUCCESSFUL) {
105046: 4603 mov r3, r0
105048: 2800 cmp r0, #0
10504a: d151 bne.n 1050f0 <rtems_bdpart_read+0x1ac> <== ALWAYS TAKEN
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
10504c: 9a00 ldr r2, [sp, #0]
sc = rtems_bdpart_read_mbr_partition(
10504e: a901 add r1, sp, #4
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
105050: 69d0 ldr r0, [r2, #28]
sc = rtems_bdpart_read_mbr_partition(
105052: 4642 mov r2, r8
105054: f500 70df add.w r0, r0, #446 ; 0x1be
105058: f7ff fe8e bl 104d78 <rtems_bdpart_read_mbr_partition>
if (sc != RTEMS_SUCCESSFUL) {
10505c: 4684 mov ip, r0
10505e: 2800 cmp r0, #0
105060: d148 bne.n 1050f4 <rtems_bdpart_read+0x1b0> <== ALWAYS TAKEN
tmp = p->begin + ebr;
105062: 9801 ldr r0, [sp, #4]
105064: 6803 ldr r3, [r0, #0]
105066: 19da adds r2, r3, r7
if (tmp > p->begin) {
105068: 4293 cmp r3, r2
10506a: d23d bcs.n 1050e8 <rtems_bdpart_read+0x1a4> <== ALWAYS TAKEN
tmp = p->end + ebr;
10506c: 6843 ldr r3, [r0, #4]
p->begin = tmp;
10506e: 6002 str r2, [r0, #0]
tmp = p->end + ebr;
105070: 441f add r7, r3
if (tmp > p->end) {
105072: 42bb cmp r3, r7
105074: d238 bcs.n 1050e8 <rtems_bdpart_read+0x1a4> <== ALWAYS TAKEN
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
105076: f8dd e000 ldr.w lr, [sp]
p->end = tmp;
10507a: 6047 str r7, [r0, #4]
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
10507c: f8de 701c ldr.w r7, [lr, #28]
for (i = 3; i >= 0; --i) {
105080: f507 71ed add.w r1, r7, #474 ; 0x1da
105084: f507 72eb add.w r2, r7, #470 ; 0x1d6
value = (value << 8) + data [i];
105088: f811 3d01 ldrb.w r3, [r1, #-1]!
for (i = 3; i >= 0; --i) {
10508c: 428a cmp r2, r1
value = (value << 8) + data [i];
10508e: eb03 2c0c add.w ip, r3, ip, lsl #8
for (i = 3; i >= 0; --i) {
105092: d1f9 bne.n 105088 <rtems_bdpart_read+0x144>
if (type == RTEMS_BDPART_MBR_EXTENDED) {
105094: f897 21d2 ldrb.w r2, [r7, #466] ; 0x1d2
if (ebr != 0) {
105098: f1bc 0f00 cmp.w ip, #0
10509c: f1a2 0205 sub.w r2, r2, #5
1050a0: fab2 f282 clz r2, r2
1050a4: ea4f 1252 mov.w r2, r2, lsr #5
1050a8: bf08 it eq
1050aa: 2200 moveq r2, #0
1050ac: b952 cbnz r2, 1050c4 <rtems_bdpart_read+0x180>
*count = (size_t) (p - pt + 1);
1050ae: 1b43 subs r3, r0, r5
1050b0: f64a 22ab movw r2, #43691 ; 0xaaab
1050b4: 111b asrs r3, r3, #4
1050b6: f6ca 22aa movt r2, #43690 ; 0xaaaa
1050ba: fb02 f303 mul.w r3, r2, r3
1050be: 3301 adds r3, #1
1050c0: 6033 str r3, [r6, #0]
1050c2: e76e b.n 104fa2 <rtems_bdpart_read+0x5e>
tmp = ebr + ep_begin;
1050c4: 9f02 ldr r7, [sp, #8]
1050c6: 4467 add r7, ip
if (tmp > ebr) {
1050c8: 4567 cmp r7, ip
1050ca: d8b7 bhi.n 10503c <rtems_bdpart_read+0xf8> <== NEVER TAKEN
if (fd >= 0) {
1050cc: 9804 ldr r0, [sp, #16] <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
1050ce: 241b movs r4, #27 <== NOT EXECUTED
if (fd >= 0) {
1050d0: 2800 cmp r0, #0 <== NOT EXECUTED
1050d2: f6ff af6f blt.w 104fb4 <rtems_bdpart_read+0x70> <== NOT EXECUTED
close( fd);
1050d6: f001 f80d bl 1060f4 <close>
if (block != NULL) {
1050da: f8dd e000 ldr.w lr, [sp]
1050de: f1be 0f00 cmp.w lr, #0
1050e2: f47f af67 bne.w 104fb4 <rtems_bdpart_read+0x70> <== NEVER TAKEN
1050e6: e751 b.n 104f8c <rtems_bdpart_read+0x48> <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
1050e8: 241b movs r4, #27 <== NOT EXECUTED
1050ea: e75a b.n 104fa2 <rtems_bdpart_read+0x5e> <== NOT EXECUTED
esc = RTEMS_NOT_IMPLEMENTED;
1050ec: 2418 movs r4, #24 <== NOT EXECUTED
1050ee: e758 b.n 104fa2 <rtems_bdpart_read+0x5e> <== NOT EXECUTED
1050f0: 4604 mov r4, r0 <== NOT EXECUTED
1050f2: e756 b.n 104fa2 <rtems_bdpart_read+0x5e> <== NOT EXECUTED
1050f4: 4604 mov r4, r0 <== NOT EXECUTED
1050f6: e754 b.n 104fa2 <rtems_bdpart_read+0x5e> <== NOT EXECUTED
*count = (size_t) (p - pt + 1);
1050f8: 9801 ldr r0, [sp, #4] <== NOT EXECUTED
1050fa: e7d8 b.n 1050ae <rtems_bdpart_read+0x16a> <== NOT EXECUTED
001050fc <rtems_bdpart_register>:
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
1050fc: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_blkdev_bnum disk_end = 0;
105100: 2300 movs r3, #0
{
105102: b085 sub sp, #20
105104: 4690 mov r8, r2
char *logical_disk_name = NULL;
char *logical_disk_marker = NULL;
size_t i = 0;
int fd = -1;
105106: f04f 32ff mov.w r2, #4294967295 ; 0xffffffff
{
10510a: 460c mov r4, r1
rtems_blkdev_bnum disk_end = 0;
10510c: 9301 str r3, [sp, #4]
rtems_disk_device *dd = NULL;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
10510e: a902 add r1, sp, #8
rtems_disk_device *dd = NULL;
105110: 9303 str r3, [sp, #12]
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
105112: ab01 add r3, sp, #4
int fd = -1;
105114: 9202 str r2, [sp, #8]
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
105116: aa03 add r2, sp, #12
{
105118: 4606 mov r6, r0
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
10511a: f7ff fed5 bl 104ec8 <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
10511e: 4607 mov r7, r0
105120: b118 cbz r0, 10512a <rtems_bdpart_register+0x2e>
free( logical_disk_name);
close( fd);
return esc;
}
105122: 4638 mov r0, r7 <== NOT EXECUTED
105124: b005 add sp, #20 <== NOT EXECUTED
105126: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
size_t disk_name_size = strlen( disk_name);
10512a: 4630 mov r0, r6
10512c: f00c faa8 bl 111680 <strlen>
105130: 4605 mov r5, r0
char *logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
105132: 3004 adds r0, #4
105134: f001 fa38 bl 1065a8 <malloc>
if (logical_disk_name != NULL) {
105138: 4681 mov r9, r0
10513a: b318 cbz r0, 105184 <rtems_bdpart_register+0x88>
memcpy( logical_disk_name, disk_name, disk_name_size);
10513c: 462a mov r2, r5
10513e: 4631 mov r1, r6
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
105140: f647 4a54 movw sl, #31828 ; 0x7c54
*marker = logical_disk_name + disk_name_size;
105144: eb00 0b05 add.w fp, r0, r5
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
105148: f2c0 0a11 movt sl, #17
for (i = 0; i < count; ++i) {
10514c: 463d mov r5, r7
memcpy( logical_disk_name, disk_name, disk_name_size);
10514e: f00b ecb8 blx 110ac0 <memcpy>
if (logical_disk_name == NULL) {
105152: e006 b.n 105162 <rtems_bdpart_register+0x66>
sc = rtems_blkdev_create_partition(
105154: e9d4 2300 ldrd r2, r3, [r4]
if (sc != RTEMS_SUCCESSFUL) {
105158: 3430 adds r4, #48 ; 0x30
sc = rtems_blkdev_create_partition(
10515a: 1a9b subs r3, r3, r2
10515c: f000 fb78 bl 105850 <rtems_blkdev_create_partition>
if (sc != RTEMS_SUCCESSFUL) {
105160: b9d0 cbnz r0, 105198 <rtems_bdpart_register+0x9c>
for (i = 0; i < count; ++i) {
105162: 4545 cmp r5, r8
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
105164: f105 0501 add.w r5, r5, #1
105168: 4652 mov r2, sl
10516a: f04f 0104 mov.w r1, #4
10516e: 4658 mov r0, fp
105170: 462b mov r3, r5
for (i = 0; i < count; ++i) {
105172: d007 beq.n 105184 <rtems_bdpart_register+0x88>
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
105174: f00b ffc6 bl 111104 <snprintf>
105178: 4603 mov r3, r0
sc = rtems_blkdev_create_partition(
10517a: 4631 mov r1, r6
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
10517c: 2b03 cmp r3, #3
sc = rtems_blkdev_create_partition(
10517e: 4648 mov r0, r9
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
105180: dde8 ble.n 105154 <rtems_bdpart_register+0x58> <== NEVER TAKEN
sc = RTEMS_INVALID_NAME;
105182: 2703 movs r7, #3 <== NOT EXECUTED
free( logical_disk_name);
105184: 4648 mov r0, r9
105186: f001 f837 bl 1061f8 <free>
close( fd);
10518a: 9802 ldr r0, [sp, #8]
10518c: f000 ffb2 bl 1060f4 <close>
}
105190: 4638 mov r0, r7
105192: b005 add sp, #20
105194: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
105198: 4607 mov r7, r0 <== NOT EXECUTED
10519a: e7f3 b.n 105184 <rtems_bdpart_register+0x88> <== NOT EXECUTED
00104ea8 <rtems_bdpart_to_mbr_partition_type>:
{
104ea8: b508 push {r3, lr}
104eaa: 460b mov r3, r1
static inline uint8_t rtems_bdpart_mbr_partition_type(
const uuid_t type
)
{
return type [0];
104eac: f810 cb01 ldrb.w ip, [r0], #1
return memcmp(
104eb0: 220f movs r2, #15
104eb2: 4904 ldr r1, [pc, #16] ; (104ec4 <rtems_bdpart_to_mbr_partition_type+0x1c>)
*mbr_type = rtems_bdpart_mbr_partition_type( type);
104eb4: f883 c000 strb.w ip, [r3]
return memcmp(
104eb8: f00b fdb6 bl 110a28 <memcmp>
}
104ebc: fab0 f080 clz r0, r0
104ec0: 0940 lsrs r0, r0, #5
104ec2: bd08 pop {r3, pc}
104ec4: 00117c45 .word 0x00117c45
001051c4 <rtems_bdpart_unregister>:
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt RTEMS_UNUSED,
size_t count
)
{
1051c4: e92d 43f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_blkdev_bnum disk_end = 0;
1051c8: 2100 movs r1, #0
{
1051ca: b085 sub sp, #20
char *logical_disk_name = NULL;
char *logical_disk_marker = NULL;
size_t i = 0;
int fd = -1;
1051cc: f04f 33ff mov.w r3, #4294967295 ; 0xffffffff
{
1051d0: 4616 mov r6, r2
rtems_disk_device *dd = NULL;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
1051d2: aa03 add r2, sp, #12
int fd = -1;
1051d4: e9cd 1301 strd r1, r3, [sp, #4]
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
1051d8: ab01 add r3, sp, #4
rtems_disk_device *dd = NULL;
1051da: 9103 str r1, [sp, #12]
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
1051dc: a902 add r1, sp, #8
{
1051de: 4604 mov r4, r0
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
1051e0: f7ff fe72 bl 104ec8 <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
1051e4: 4607 mov r7, r0
1051e6: b118 cbz r0, 1051f0 <rtems_bdpart_unregister+0x2c>
free( logical_disk_name);
close( fd);
return esc;
}
1051e8: 4638 mov r0, r7 <== NOT EXECUTED
1051ea: b005 add sp, #20 <== NOT EXECUTED
1051ec: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
size_t disk_name_size = strlen( disk_name);
1051f0: 4620 mov r0, r4
1051f2: f00c fa45 bl 111680 <strlen>
1051f6: 4605 mov r5, r0
char *logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
1051f8: 3004 adds r0, #4
1051fa: f001 f9d5 bl 1065a8 <malloc>
if (logical_disk_name != NULL) {
1051fe: 4680 mov r8, r0
105200: b1e8 cbz r0, 10523e <rtems_bdpart_unregister+0x7a>
memcpy( logical_disk_name, disk_name, disk_name_size);
105202: 4621 mov r1, r4
105204: 462a mov r2, r5
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
105206: f647 4954 movw r9, #31828 ; 0x7c54
*marker = logical_disk_name + disk_name_size;
10520a: 4445 add r5, r8
for (i = 0; i < count; ++i) {
10520c: 463c mov r4, r7
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
10520e: f2c0 0911 movt r9, #17
memcpy( logical_disk_name, disk_name, disk_name_size);
105212: f00b ec56 blx 110ac0 <memcpy>
if (logical_disk_name == NULL) {
105216: e002 b.n 10521e <rtems_bdpart_unregister+0x5a>
rv = unlink( logical_disk_name);
105218: f002 fa46 bl 1076a8 <unlink>
if (rv != 0) {
10521c: b978 cbnz r0, 10523e <rtems_bdpart_unregister+0x7a>
for (i = 0; i < count; ++i) {
10521e: 42b4 cmp r4, r6
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
105220: f104 0401 add.w r4, r4, #1
105224: 464a mov r2, r9
105226: f04f 0104 mov.w r1, #4
10522a: 4628 mov r0, r5
10522c: 4623 mov r3, r4
for (i = 0; i < count; ++i) {
10522e: d006 beq.n 10523e <rtems_bdpart_unregister+0x7a>
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
105230: f00b ff68 bl 111104 <snprintf>
105234: 4603 mov r3, r0
rv = unlink( logical_disk_name);
105236: 4640 mov r0, r8
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
105238: 2b03 cmp r3, #3
10523a: dded ble.n 105218 <rtems_bdpart_unregister+0x54> <== NEVER TAKEN
sc = RTEMS_INVALID_NAME;
10523c: 2703 movs r7, #3 <== NOT EXECUTED
free( logical_disk_name);
10523e: 4640 mov r0, r8
105240: f000 ffda bl 1061f8 <free>
close( fd);
105244: 9802 ldr r0, [sp, #8]
105246: f000 ff55 bl 1060f4 <close>
}
10524a: 4638 mov r0, r7
10524c: b005 add sp, #20
10524e: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
105252: bf00 nop
001052a4 <rtems_bdpart_write>:
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
1052a4: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1052a8: 4690 mov r8, r2
1052aa: b089 sub sp, #36 ; 0x24
1052ac: 461f mov r7, r3
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
1052ae: 4689 mov r9, r1
1052b0: b111 cbz r1, 1052b8 <rtems_bdpart_write+0x14>
&& format->type == RTEMS_BDPART_FORMAT_MBR
1052b2: 680b ldr r3, [r1, #0]
1052b4: 2b00 cmp r3, #0
1052b6: d03e beq.n 105336 <rtems_bdpart_write+0x92> <== NEVER TAKEN
rtems_bdbuf_buffer *block = NULL;
1052b8: 2300 movs r3, #0 <== NOT EXECUTED
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
1052ba: 2501 movs r5, #1 <== NOT EXECUTED
&& format->mbr.dos_compatibility;
1052bc: 469a mov sl, r3 <== NOT EXECUTED
rtems_blkdev_bnum disk_end = 0;
1052be: e9cd 3304 strd r3, r3, [sp, #16] <== NOT EXECUTED
size_t ppc = 0; /* Primary partition count */
size_t i = 0;
uint8_t *data = NULL;
int fd = -1;
rtems_disk_device *dd = NULL;
1052c2: f04f 32ff mov.w r2, #4294967295 ; 0xffffffff
1052c6: 2300 movs r3, #0
/* Check if we have something to do */
if (count == 0) {
/* Nothing to do */
return RTEMS_SUCCESSFUL;
1052c8: 463c mov r4, r7
rtems_disk_device *dd = NULL;
1052ca: e9cd 2306 strd r2, r3, [sp, #24]
if (count == 0) {
1052ce: b377 cbz r7, 10532e <rtems_bdpart_write+0x8a>
}
/* Check parameter */
if (format == NULL || pt == NULL) {
1052d0: 4598 cmp r8, r3
1052d2: bf18 it ne
1052d4: 4599 cmpne r9, r3
return RTEMS_INVALID_ADDRESS;
1052d6: bf08 it eq
1052d8: 2409 moveq r4, #9
if (format == NULL || pt == NULL) {
1052da: d028 beq.n 10532e <rtems_bdpart_write+0x8a> <== ALWAYS TAKEN
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
1052dc: ab05 add r3, sp, #20
1052de: aa07 add r2, sp, #28
1052e0: a906 add r1, sp, #24
1052e2: f7ff fdf1 bl 104ec8 <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
1052e6: 4604 mov r4, r0
1052e8: bb08 cbnz r0, 10532e <rtems_bdpart_write+0x8a>
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
1052ea: f8dd b014 ldr.w fp, [sp, #20]
if (dos_compatibility) {
1052ee: f1ba 0f00 cmp.w sl, #0
1052f2: d129 bne.n 105348 <rtems_bdpart_write+0xa4> <== NEVER TAKEN
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
1052f4: 4640 mov r0, r8
1052f6: e009 b.n 10530c <rtems_bdpart_write+0x68>
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that partitions do not overlap */
if (i > 0 && pt [i - 1].end > p->begin) {
1052f8: b11c cbz r4, 105302 <rtems_bdpart_write+0x5e>
1052fa: f850 2c2c ldr.w r2, [r0, #-44]
1052fe: 4293 cmp r3, r2
105300: d30d bcc.n 10531e <rtems_bdpart_write+0x7a> <== ALWAYS TAKEN
for (i = 0; i < count; ++i) {
105302: 42b7 cmp r7, r6
105304: f100 0030 add.w r0, r0, #48 ; 0x30
105308: d02d beq.n 105366 <rtems_bdpart_write+0xc2>
10530a: 4634 mov r4, r6
if (p->begin >= disk_end || p->end > disk_end) {
10530c: 6803 ldr r3, [r0, #0]
for (i = 0; i < count; ++i) {
10530e: 1c66 adds r6, r4, #1
if (p->begin >= disk_end || p->end > disk_end) {
105310: 455b cmp r3, fp
105312: d204 bcs.n 10531e <rtems_bdpart_write+0x7a> <== ALWAYS TAKEN
105314: 6842 ldr r2, [r0, #4]
if (p->begin >= p->end) {
105316: 455a cmp r2, fp
105318: bf98 it ls
10531a: 4293 cmpls r3, r2
10531c: d3ec bcc.n 1052f8 <rtems_bdpart_write+0x54> <== NEVER TAKEN
esc = RTEMS_INVALID_NUMBER;
10531e: 240a movs r4, #10 <== NOT EXECUTED
}
}
cleanup:
if (fd >= 0) {
105320: 9806 ldr r0, [sp, #24]
105322: 2800 cmp r0, #0
105324: da19 bge.n 10535a <rtems_bdpart_write+0xb6> <== NEVER TAKEN
close( fd);
}
if (block != NULL) {
105326: 9804 ldr r0, [sp, #16] <== NOT EXECUTED
105328: b108 cbz r0, 10532e <rtems_bdpart_write+0x8a> <== NOT EXECUTED
rtems_bdbuf_sync( block);
10532a: f008 f997 bl 10d65c <rtems_bdbuf_sync>
}
return esc;
}
10532e: 4620 mov r0, r4
105330: b009 add sp, #36 ; 0x24
105332: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
&& format->mbr.dos_compatibility;
105336: 7a0a ldrb r2, [r1, #8]
105338: 2a00 cmp r2, #0
10533a: d0bd beq.n 1052b8 <rtems_bdpart_write+0x14> <== ALWAYS TAKEN
10533c: f04f 0a01 mov.w sl, #1
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
105340: 253f movs r5, #63 ; 0x3f
rtems_blkdev_bnum disk_end = 0;
105342: e9cd 3304 strd r3, r3, [sp, #16]
rtems_blkdev_bnum record_space =
105346: e7bc b.n 1052c2 <rtems_bdpart_write+0x1e>
disk_end -= (disk_end % record_space);
105348: 4658 mov r0, fp
10534a: 4629 mov r1, r5
10534c: f00a ffc2 bl 1102d4 <__aeabi_uidivmod>
105350: ebab 0b01 sub.w fp, fp, r1
105354: f8cd b014 str.w fp, [sp, #20]
105358: e7cc b.n 1052f4 <rtems_bdpart_write+0x50>
close( fd);
10535a: f000 fecb bl 1060f4 <close>
if (block != NULL) {
10535e: 9804 ldr r0, [sp, #16]
105360: 2800 cmp r0, #0
105362: d1e2 bne.n 10532a <rtems_bdpart_write+0x86> <== NEVER TAKEN
105364: e7e3 b.n 10532e <rtems_bdpart_write+0x8a> <== NOT EXECUTED
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
105366: f8d9 3000 ldr.w r3, [r9]
10536a: b9cb cbnz r3, 1053a0 <rtems_bdpart_write+0xfc>
ppc = count <= 4 ? count : 3;
10536c: 2f04 cmp r7, #4
10536e: d919 bls.n 1053a4 <rtems_bdpart_write+0x100> <== ALWAYS TAKEN
if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
105370: f1ba 0f00 cmp.w sl, #0
105374: f040 8124 bne.w 1055c0 <rtems_bdpart_write+0x31c> <== NEVER TAKEN
105378: ea4f 0c46 mov.w ip, r6, lsl #1
10537c: f108 0390 add.w r3, r8, #144 ; 0x90
105380: eb0c 0006 add.w r0, ip, r6
105384: eb08 1000 add.w r0, r8, r0, lsl #4
105388: e002 b.n 105390 <rtems_bdpart_write+0xec>
for (i = ppc; i < count; ++i) {
10538a: 4298 cmp r0, r3
10538c: f000 810f beq.w 1055ae <rtems_bdpart_write+0x30a>
if ((pt [i].begin - pt [i - 1].end) < record_space) {
105390: 681a ldr r2, [r3, #0]
for (i = ppc; i < count; ++i) {
105392: 3330 adds r3, #48 ; 0x30
if ((pt [i].begin - pt [i - 1].end) < record_space) {
105394: f853 1c5c ldr.w r1, [r3, #-92]
105398: 1a52 subs r2, r2, r1
10539a: 42aa cmp r2, r5
10539c: d2f5 bcs.n 10538a <rtems_bdpart_write+0xe6> <== NEVER TAKEN
10539e: e7be b.n 10531e <rtems_bdpart_write+0x7a> <== NOT EXECUTED
esc = RTEMS_NOT_IMPLEMENTED;
1053a0: 2418 movs r4, #24 <== NOT EXECUTED
1053a2: e7bd b.n 105320 <rtems_bdpart_write+0x7c> <== NOT EXECUTED
if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
1053a4: f1ba 0f00 cmp.w sl, #0 <== NOT EXECUTED
1053a8: d003 beq.n 1053b2 <rtems_bdpart_write+0x10e> <== NOT EXECUTED
1053aa: f8d8 3000 ldr.w r3, [r8] <== NOT EXECUTED
1053ae: 2b3f cmp r3, #63 ; 0x3f <== NOT EXECUTED
1053b0: d1b5 bne.n 10531e <rtems_bdpart_write+0x7a> <== NOT EXECUTED
1053b2: ea4f 0c46 mov.w ip, r6, lsl #1 <== NOT EXECUTED
1053b6: 9600 str r6, [sp, #0] <== NOT EXECUTED
1053b8: 44b4 add ip, r6
1053ba: f108 0708 add.w r7, r8, #8
uint8_t type = 0;
1053be: f04f 0b00 mov.w fp, #0
1053c2: eb07 1a0c add.w sl, r7, ip, lsl #4
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
1053c6: 4638 mov r0, r7
uint8_t type = 0;
1053c8: f88d b00f strb.w fp, [sp, #15]
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
1053cc: f10d 010f add.w r1, sp, #15
1053d0: f7ff fd6a bl 104ea8 <rtems_bdpart_to_mbr_partition_type>
1053d4: 2800 cmp r0, #0
1053d6: f000 80ed beq.w 1055b4 <rtems_bdpart_write+0x310> <== ALWAYS TAKEN
if (p->flags > 0xffU) {
1053da: e9d7 2308 ldrd r2, r3, [r7, #32]
for (i = 0; i < count; ++i) {
1053de: 3730 adds r7, #48 ; 0x30
if (p->flags > 0xffU) {
1053e0: f5b2 7f80 cmp.w r2, #256 ; 0x100
1053e4: f173 0300 sbcs.w r3, r3, #0
1053e8: f080 80e4 bcs.w 1055b4 <rtems_bdpart_write+0x310> <== ALWAYS TAKEN
for (i = 0; i < count; ++i) {
1053ec: 45ba cmp sl, r7
1053ee: d1ea bne.n 1053c6 <rtems_bdpart_write+0x122>
sc = rtems_bdpart_new_record( dd, 0, &block);
1053f0: 9807 ldr r0, [sp, #28]
1053f2: aa04 add r2, sp, #16
1053f4: 2100 movs r1, #0
1053f6: f7ff ff2d bl 105254 <rtems_bdpart_new_record>
if (sc != RTEMS_SUCCESSFUL) {
1053fa: 2800 cmp r0, #0
1053fc: f040 80de bne.w 1055bc <rtems_bdpart_write+0x318> <== ALWAYS TAKEN
rtems_uint32_to_little_endian(
105400: 9a00 ldr r2, [sp, #0]
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
105402: 4640 mov r0, r8
rtems_uint32_to_little_endian(
105404: f8d9 3004 ldr.w r3, [r9, #4]
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
105408: 9904 ldr r1, [sp, #16]
10540a: ea4f 1902 mov.w r9, r2, lsl #4
10540e: 69ca ldr r2, [r1, #28]
{
int i;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
value >>= 8;
105410: ea4f 2c13 mov.w ip, r3, lsr #8
data [i] = (uint8_t) value;
105414: f882 31b8 strb.w r3, [r2, #440] ; 0x1b8
105418: f882 c1b9 strb.w ip, [r2, #441] ; 0x1b9
value >>= 8;
10541c: ea4f 4c13 mov.w ip, r3, lsr #16
105420: 0e1b lsrs r3, r3, #24
data [i] = (uint8_t) value;
105422: f882 c1ba strb.w ip, [r2, #442] ; 0x1ba
105426: f882 31bb strb.w r3, [r2, #443] ; 0x1bb
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
10542a: f8d1 c01c ldr.w ip, [r1, #28]
for (i = 0; i < ppc; ++i) {
10542e: 4663 mov r3, ip
105430: eb0c 0e09 add.w lr, ip, r9
rtems_bdpart_write_mbr_partition(
105434: e9d0 2100 ldrd r2, r1, [r0]
for (i = 0; i < ppc; ++i) {
105438: 3310 adds r3, #16
rtems_bdpart_write_mbr_partition(
10543a: f890 7028 ldrb.w r7, [r0, #40] ; 0x28
for (i = 0; i < ppc; ++i) {
10543e: 3030 adds r0, #48 ; 0x30
105440: f810 ac28 ldrb.w sl, [r0, #-40]
rtems_bdpart_write_mbr_partition(
105444: 1a89 subs r1, r1, r2
105446: f883 21b6 strb.w r2, [r3, #438] ; 0x1b6
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
10544a: f883 71ae strb.w r7, [r3, #430] ; 0x1ae
value >>= 8;
10544e: 0a17 lsrs r7, r2, #8
data [i] = (uint8_t) value;
105450: f883 11ba strb.w r1, [r3, #442] ; 0x1ba
105454: f883 71b7 strb.w r7, [r3, #439] ; 0x1b7
value >>= 8;
105458: 0c17 lsrs r7, r2, #16
10545a: 0e12 lsrs r2, r2, #24
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
10545c: f883 a1b2 strb.w sl, [r3, #434] ; 0x1b2
data [i] = (uint8_t) value;
105460: f883 71b8 strb.w r7, [r3, #440] ; 0x1b8
105464: f883 21b9 strb.w r2, [r3, #441] ; 0x1b9
value >>= 8;
105468: 0a0a lsrs r2, r1, #8
data [i] = (uint8_t) value;
10546a: f883 21bb strb.w r2, [r3, #443] ; 0x1bb
value >>= 8;
10546e: 0c0a lsrs r2, r1, #16
105470: 0e09 lsrs r1, r1, #24
data [i] = (uint8_t) value;
105472: f883 21bc strb.w r2, [r3, #444] ; 0x1bc
105476: f883 11bd strb.w r1, [r3, #445] ; 0x1bd
for (i = 0; i < ppc; ++i) {
10547a: 459e cmp lr, r3
10547c: d1da bne.n 105434 <rtems_bdpart_write+0x190>
if (ppc != count) {
10547e: 9b00 ldr r3, [sp, #0]
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
105480: f509 79df add.w r9, r9, #446 ; 0x1be
105484: eb0c 0209 add.w r2, ip, r9
if (ppc != count) {
105488: 429e cmp r6, r3
10548a: f000 8095 beq.w 1055b8 <rtems_bdpart_write+0x314> <== ALWAYS TAKEN
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
10548e: 9b00 ldr r3, [sp, #0]
105490: eb03 0143 add.w r1, r3, r3, lsl #1
rtems_bdpart_write_mbr_partition(
105494: 9b05 ldr r3, [sp, #20]
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
105496: ea4f 1101 mov.w r1, r1, lsl #4
rtems_bdpart_write_mbr_partition(
10549a: 442b add r3, r5
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
10549c: f858 0001 ldr.w r0, [r8, r1]
rtems_bdpart_write_mbr_partition(
1054a0: eba3 0300 sub.w r3, r3, r0
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
1054a4: 9001 str r0, [sp, #4]
1054a6: eba0 0005 sub.w r0, r0, r5
1054aa: 7313 strb r3, [r2, #12]
value >>= 8;
1054ac: ea4f 2610 mov.w r6, r0, lsr #8
data [i] = (uint8_t) value;
1054b0: 7210 strb r0, [r2, #8]
1054b2: 7256 strb r6, [r2, #9]
value >>= 8;
1054b4: ea4f 4610 mov.w r6, r0, lsr #16
1054b8: ea4f 6010 mov.w r0, r0, lsr #24
data [i] = (uint8_t) value;
1054bc: 7296 strb r6, [r2, #10]
1054be: eb08 0601 add.w r6, r8, r1
1054c2: 72d0 strb r0, [r2, #11]
value >>= 8;
1054c4: ea4f 2013 mov.w r0, r3, lsr #8
data [i] = (uint8_t) value;
1054c8: 7350 strb r0, [r2, #13]
value >>= 8;
1054ca: ea4f 4013 mov.w r0, r3, lsr #16
1054ce: ea4f 6313 mov.w r3, r3, lsr #24
data [i] = (uint8_t) value;
1054d2: 7390 strb r0, [r2, #14]
1054d4: 73d3 strb r3, [r2, #15]
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
1054d6: f04f 0305 mov.w r3, #5
1054da: 7113 strb r3, [r2, #4]
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
1054dc: f04f 0300 mov.w r3, #0
1054e0: f80c 3009 strb.w r3, [ip, r9]
for (i = ppc; i < count; ++i) {
1054e4: d968 bls.n 1055b8 <rtems_bdpart_write+0x314> <== ALWAYS TAKEN
ebr = p->begin - record_space;
1054e6: 9f00 ldr r7, [sp, #0]
1054e8: 46b1 mov r9, r6
1054ea: f858 3001 ldr.w r3, [r8, r1]
1054ee: 46b8 mov r8, r7
1054f0: e052 b.n 105598 <rtems_bdpart_write+0x2f4>
rtems_bdpart_write_mbr_partition(
1054f2: e9d6 3200 ldrd r3, r2, [r6]
for (i = ppc; i < count; ++i) {
1054f6: 45a0 cmp r8, r4
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
1054f8: 9904 ldr r1, [sp, #16]
1054fa: f106 0630 add.w r6, r6, #48 ; 0x30
rtems_bdpart_write_mbr_partition(
1054fe: f816 ec08 ldrb.w lr, [r6, #-8]
105502: eba2 0203 sub.w r2, r2, r3
105506: f816 ac28 ldrb.w sl, [r6, #-40]
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
10550a: 69cb ldr r3, [r1, #28]
value >>= 8;
10550c: ea4f 2b12 mov.w fp, r2, lsr #8
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
105510: f883 e1be strb.w lr, [r3, #446] ; 0x1be
105514: ea4f 4e12 mov.w lr, r2, lsr #16
data [i] = (uint8_t) value;
105518: f883 21ca strb.w r2, [r3, #458] ; 0x1ca
value >>= 8;
10551c: ea4f 6212 mov.w r2, r2, lsr #24
data [i] = (uint8_t) value;
105520: f883 b1cb strb.w fp, [r3, #459] ; 0x1cb
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
105524: f883 a1c2 strb.w sl, [r3, #450] ; 0x1c2
105528: f883 51c6 strb.w r5, [r3, #454] ; 0x1c6
10552c: f883 01c7 strb.w r0, [r3, #455] ; 0x1c7
105530: f883 01c8 strb.w r0, [r3, #456] ; 0x1c8
105534: f883 01c9 strb.w r0, [r3, #457] ; 0x1c9
105538: f883 e1cc strb.w lr, [r3, #460] ; 0x1cc
10553c: f883 21cd strb.w r2, [r3, #461] ; 0x1cd
for (i = ppc; i < count; ++i) {
105540: d03a beq.n 1055b8 <rtems_bdpart_write+0x314>
if (i > ppc) {
105542: 45bc cmp ip, r7
rtems_blkdev_bnum begin = p->begin - record_space;
105544: f8d9 3030 ldr.w r3, [r9, #48] ; 0x30
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
105548: 46e0 mov r8, ip
if (i > ppc) {
10554a: d923 bls.n 105594 <rtems_bdpart_write+0x2f0> <== ALWAYS TAKEN
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,
10554c: 69c9 ldr r1, [r1, #28]
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
10554e: f04f 0205 mov.w r2, #5
105552: f881 21d2 strb.w r2, [r1, #466] ; 0x1d2
rtems_bdpart_write_mbr_partition(
105556: 9a05 ldr r2, [sp, #20]
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
105558: f881 01ce strb.w r0, [r1, #462] ; 0x1ce
rtems_bdpart_write_mbr_partition(
10555c: 9801 ldr r0, [sp, #4]
10555e: 442a add r2, r5
105560: 1ad2 subs r2, r2, r3
105562: 1a1b subs r3, r3, r0
105564: f881 21da strb.w r2, [r1, #474] ; 0x1da
value >>= 8;
105568: 0a18 lsrs r0, r3, #8
data [i] = (uint8_t) value;
10556a: f881 31d6 strb.w r3, [r1, #470] ; 0x1d6
10556e: f881 01d7 strb.w r0, [r1, #471] ; 0x1d7
value >>= 8;
105572: 0c18 lsrs r0, r3, #16
105574: 0e1b lsrs r3, r3, #24
data [i] = (uint8_t) value;
105576: f881 01d8 strb.w r0, [r1, #472] ; 0x1d8
10557a: f881 31d9 strb.w r3, [r1, #473] ; 0x1d9
value >>= 8;
10557e: 0a13 lsrs r3, r2, #8
data [i] = (uint8_t) value;
105580: f881 31db strb.w r3, [r1, #475] ; 0x1db
value >>= 8;
105584: 0c13 lsrs r3, r2, #16
105586: 0e12 lsrs r2, r2, #24
data [i] = (uint8_t) value;
105588: f881 31dc strb.w r3, [r1, #476] ; 0x1dc
10558c: f881 21dd strb.w r2, [r1, #477] ; 0x1dd
ebr = p->begin - record_space;
105590: f8d9 3030 ldr.w r3, [r9, #48] ; 0x30
105594: f109 0930 add.w r9, r9, #48 ; 0x30
sc = rtems_bdpart_new_record( dd, ebr, &block);
105598: 9807 ldr r0, [sp, #28]
10559a: 1b59 subs r1, r3, r5
10559c: aa04 add r2, sp, #16
10559e: f7ff fe59 bl 105254 <rtems_bdpart_new_record>
for (i = ppc; i < count; ++i) {
1055a2: f108 0c01 add.w ip, r8, #1
if (sc != RTEMS_SUCCESSFUL) {
1055a6: 2800 cmp r0, #0
1055a8: d0a3 beq.n 1054f2 <rtems_bdpart_write+0x24e> <== NEVER TAKEN
1055aa: 4604 mov r4, r0 <== NOT EXECUTED
1055ac: e6b8 b.n 105320 <rtems_bdpart_write+0x7c> <== NOT EXECUTED
1055ae: 2303 movs r3, #3
1055b0: 9300 str r3, [sp, #0]
1055b2: e701 b.n 1053b8 <rtems_bdpart_write+0x114>
goto cleanup;
1055b4: 2404 movs r4, #4 <== NOT EXECUTED
1055b6: e6b3 b.n 105320 <rtems_bdpart_write+0x7c> <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
1055b8: 2400 movs r4, #0
1055ba: e6b1 b.n 105320 <rtems_bdpart_write+0x7c>
1055bc: 4604 mov r4, r0 <== NOT EXECUTED
1055be: e6af b.n 105320 <rtems_bdpart_write+0x7c> <== NOT EXECUTED
if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
1055c0: f8d8 3000 ldr.w r3, [r8]
1055c4: 2b3f cmp r3, #63 ; 0x3f
1055c6: f43f aed7 beq.w 105378 <rtems_bdpart_write+0xd4> <== NEVER TAKEN
1055ca: e6a8 b.n 10531e <rtems_bdpart_write+0x7a> <== NOT EXECUTED
00105020 <rtems_blkdev_generic_ioctl>:
{
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
if (args->command != RTEMS_BLKIO_REQUEST)
105020: 6851 ldr r1, [r2, #4]
105022: f244 2301 movw r3, #16897 ; 0x4201
105026: f2cc 0318 movt r3, #49176 ; 0xc018
{
10502a: b510 push {r4, lr}
10502c: 4614 mov r4, r2
if (args->command != RTEMS_BLKIO_REQUEST)
10502e: 4299 cmp r1, r3
105030: d007 beq.n 105042 <rtems_blkdev_generic_ioctl+0x22> <== ALWAYS TAKEN
rtems_disk_device *dd = iop->data1;
105032: 6813 ldr r3, [r2, #0]
{
args->ioctl_return = dd->ioctl(dd,
105034: 6892 ldr r2, [r2, #8]
rtems_disk_device *dd = iop->data1;
105036: 6ad8 ldr r0, [r3, #44] ; 0x2c
args->ioctl_return = dd->ioctl(dd,
105038: 6b83 ldr r3, [r0, #56] ; 0x38
10503a: 4798 blx r3
10503c: 60e0 str r0, [r4, #12]
*/
args->ioctl_return = -1;
}
return RTEMS_SUCCESSFUL;
}
10503e: 2000 movs r0, #0
105040: bd10 pop {r4, pc}
args->ioctl_return = -1;
105042: f04f 33ff mov.w r3, #4294967295 ; 0xffffffff <== NOT EXECUTED
}
105046: 2000 movs r0, #0 <== NOT EXECUTED
args->ioctl_return = -1;
105048: 60d3 str r3, [r2, #12] <== NOT EXECUTED
}
10504a: bd10 pop {r4, pc} <== NOT EXECUTED
00104ee0 <rtems_blkdev_generic_read>:
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
104ee0: 6813 ldr r3, [r2, #0] <== NOT EXECUTED
{
104ee2: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
104ee6: 4691 mov r9, r2 <== NOT EXECUTED
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
104ee8: 6956 ldr r6, [r2, #20] <== NOT EXECUTED
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
104eea: 2400 movs r4, #0 <== NOT EXECUTED
{
104eec: b083 sub sp, #12 <== NOT EXECUTED
rtems_disk_device *dd = iop->data1;
104eee: f8d3 a02c ldr.w sl, [r3, #44] ; 0x2c <== NOT EXECUTED
uint32_t block_size = dd->block_size;
104ef2: 4623 mov r3, r4 <== NOT EXECUTED
char *buf = args->buffer;
104ef4: f8d2 8010 ldr.w r8, [r2, #16] <== NOT EXECUTED
104ef8: e9d9 0102 ldrd r0, r1, [r9, #8] <== NOT EXECUTED
uint32_t block_size = dd->block_size;
104efc: f8da b024 ldr.w fp, [sl, #36] ; 0x24 <== NOT EXECUTED
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
104f00: 465a mov r2, fp <== NOT EXECUTED
104f02: f009 fbaf bl 10e664 <__aeabi_ldivmod> <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
args->bytes_moved = 0;
104f06: f8c9 401c str.w r4, [r9, #28] <== NOT EXECUTED
while (count > 0)
104f0a: 4607 mov r7, r0 <== NOT EXECUTED
104f0c: 4615 mov r5, r2 <== NOT EXECUTED
104f0e: b98e cbnz r6, 104f34 <rtems_blkdev_generic_read+0x54> <== NOT EXECUTED
104f10: e025 b.n 104f5e <rtems_blkdev_generic_read+0x7e> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
104f12: 9b01 ldr r3, [sp, #4] <== NOT EXECUTED
104f14: 69d9 ldr r1, [r3, #28] <== NOT EXECUTED
104f16: 4429 add r1, r5 <== NOT EXECUTED
104f18: f00a ea52 blx 10f3c0 <memcpy> <== NOT EXECUTED
rc = rtems_bdbuf_release(diskbuf);
104f1c: 9801 ldr r0, [sp, #4] <== NOT EXECUTED
104f1e: f006 fde1 bl 10bae4 <rtems_bdbuf_release> <== NOT EXECUTED
args->bytes_moved += copy;
104f22: f8d9 301c ldr.w r3, [r9, #28] <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
104f26: 4605 mov r5, r0 <== NOT EXECUTED
args->bytes_moved += copy;
104f28: 4423 add r3, r4 <== NOT EXECUTED
104f2a: f8c9 301c str.w r3, [r9, #28] <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
104f2e: b9d8 cbnz r0, 104f68 <rtems_blkdev_generic_read+0x88> <== NOT EXECUTED
while (count > 0)
104f30: 1b36 subs r6, r6, r4 <== NOT EXECUTED
104f32: d014 beq.n 104f5e <rtems_blkdev_generic_read+0x7e> <== NOT EXECUTED
copy = block_size - blkofs;
104f34: ebab 0405 sub.w r4, fp, r5 <== NOT EXECUTED
rc = rtems_bdbuf_read(dd, block, &diskbuf);
104f38: 4639 mov r1, r7 <== NOT EXECUTED
104f3a: aa01 add r2, sp, #4 <== NOT EXECUTED
104f3c: 4650 mov r0, sl <== NOT EXECUTED
104f3e: f006 fd41 bl 10b9c4 <rtems_bdbuf_read> <== NOT EXECUTED
copy = block_size - blkofs;
104f42: 42b4 cmp r4, r6 <== NOT EXECUTED
rc = rtems_bdbuf_read(dd, block, &diskbuf);
104f44: 4603 mov r3, r0 <== NOT EXECUTED
if (copy > count)
104f46: bf28 it cs <== NOT EXECUTED
104f48: 4634 movcs r4, r6 <== NOT EXECUTED
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
104f4a: 4640 mov r0, r8 <== NOT EXECUTED
break;
count -= copy;
buf += copy;
blkofs = 0;
block++;
104f4c: 3701 adds r7, #1 <== NOT EXECUTED
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
104f4e: 4622 mov r2, r4 <== NOT EXECUTED
buf += copy;
104f50: 44a0 add r8, r4 <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
104f52: 2b00 cmp r3, #0 <== NOT EXECUTED
104f54: d0dd beq.n 104f12 <rtems_blkdev_generic_read+0x32> <== NOT EXECUTED
}
return rc;
}
104f56: 4618 mov r0, r3 <== NOT EXECUTED
104f58: b003 add sp, #12 <== NOT EXECUTED
104f5a: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
104f5e: 2300 movs r3, #0 <== NOT EXECUTED
}
104f60: 4618 mov r0, r3 <== NOT EXECUTED
104f62: b003 add sp, #12 <== NOT EXECUTED
104f64: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
104f68: 4603 mov r3, r0 <== NOT EXECUTED
}
104f6a: 4618 mov r0, r3 <== NOT EXECUTED
104f6c: b003 add sp, #12 <== NOT EXECUTED
104f6e: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
104f72: bf00 nop
00104f74 <rtems_blkdev_generic_write>:
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
104f74: 6813 ldr r3, [r2, #0] <== NOT EXECUTED
{
104f76: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
104f7a: 4690 mov r8, r2 <== NOT EXECUTED
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
104f7c: 6956 ldr r6, [r2, #20] <== NOT EXECUTED
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
104f7e: 2400 movs r4, #0 <== NOT EXECUTED
{
104f80: b083 sub sp, #12 <== NOT EXECUTED
rtems_disk_device *dd = iop->data1;
104f82: f8d3 a02c ldr.w sl, [r3, #44] ; 0x2c <== NOT EXECUTED
uint32_t block_size = dd->block_size;
104f86: 4623 mov r3, r4 <== NOT EXECUTED
char *buf = args->buffer;
104f88: 6917 ldr r7, [r2, #16] <== NOT EXECUTED
104f8a: e9d8 0102 ldrd r0, r1, [r8, #8] <== NOT EXECUTED
uint32_t block_size = dd->block_size;
104f8e: f8da 9024 ldr.w r9, [sl, #36] ; 0x24 <== NOT EXECUTED
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
104f92: 464a mov r2, r9 <== NOT EXECUTED
104f94: f009 fb66 bl 10e664 <__aeabi_ldivmod> <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
args->bytes_moved = 0;
104f98: f8c8 401c str.w r4, [r8, #28] <== NOT EXECUTED
while (count > 0)
104f9c: 4683 mov fp, r0 <== NOT EXECUTED
104f9e: 4615 mov r5, r2 <== NOT EXECUTED
104fa0: b9f6 cbnz r6, 104fe0 <rtems_blkdev_generic_write+0x6c> <== NOT EXECUTED
104fa2: e027 b.n 104ff4 <rtems_blkdev_generic_write+0x80> <== NOT EXECUTED
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dd, block, &diskbuf);
104fa4: f006 fcd0 bl 10b948 <rtems_bdbuf_get> <== NOT EXECUTED
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
104fa8: eba9 0405 sub.w r4, r9, r5 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
104fac: 4639 mov r1, r7 <== NOT EXECUTED
104fae: 42b4 cmp r4, r6 <== NOT EXECUTED
break;
count -= copy;
buf += copy;
blkofs = 0;
block++;
104fb0: f10b 0b01 add.w fp, fp, #1 <== NOT EXECUTED
104fb4: bf28 it cs <== NOT EXECUTED
104fb6: 4634 movcs r4, r6 <== NOT EXECUTED
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
104fb8: 4622 mov r2, r4 <== NOT EXECUTED
buf += copy;
104fba: 4427 add r7, r4 <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
104fbc: b9d8 cbnz r0, 104ff6 <rtems_blkdev_generic_write+0x82> <== NOT EXECUTED
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
104fbe: 9b01 ldr r3, [sp, #4] <== NOT EXECUTED
104fc0: 69d8 ldr r0, [r3, #28] <== NOT EXECUTED
104fc2: 4428 add r0, r5 <== NOT EXECUTED
104fc4: f00a e9fc blx 10f3c0 <memcpy> <== NOT EXECUTED
args->bytes_moved += copy;
104fc8: f8d8 301c ldr.w r3, [r8, #28] <== NOT EXECUTED
rc = rtems_bdbuf_release_modified(diskbuf);
104fcc: 9801 ldr r0, [sp, #4] <== NOT EXECUTED
args->bytes_moved += copy;
104fce: 4423 add r3, r4 <== NOT EXECUTED
104fd0: f8c8 301c str.w r3, [r8, #28] <== NOT EXECUTED
rc = rtems_bdbuf_release_modified(diskbuf);
104fd4: f006 fdd4 bl 10bb80 <rtems_bdbuf_release_modified> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
104fd8: 4605 mov r5, r0 <== NOT EXECUTED
104fda: b960 cbnz r0, 104ff6 <rtems_blkdev_generic_write+0x82> <== NOT EXECUTED
while (count > 0)
104fdc: 1b36 subs r6, r6, r4 <== NOT EXECUTED
104fde: d009 beq.n 104ff4 <rtems_blkdev_generic_write+0x80> <== NOT EXECUTED
if ((blkofs == 0) && (count >= block_size))
104fe0: 45b1 cmp r9, r6 <== NOT EXECUTED
104fe2: bf98 it ls <== NOT EXECUTED
104fe4: 2d00 cmpls r5, #0 <== NOT EXECUTED
rc = rtems_bdbuf_read(dd, block, &diskbuf);
104fe6: 4659 mov r1, fp <== NOT EXECUTED
104fe8: aa01 add r2, sp, #4 <== NOT EXECUTED
104fea: 4650 mov r0, sl <== NOT EXECUTED
if ((blkofs == 0) && (count >= block_size))
104fec: d0da beq.n 104fa4 <rtems_blkdev_generic_write+0x30> <== NOT EXECUTED
rc = rtems_bdbuf_read(dd, block, &diskbuf);
104fee: f006 fce9 bl 10b9c4 <rtems_bdbuf_read> <== NOT EXECUTED
104ff2: e7d9 b.n 104fa8 <rtems_blkdev_generic_write+0x34> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
104ff4: 2000 movs r0, #0 <== NOT EXECUTED
}
return rc;
}
104ff6: b003 add sp, #12 <== NOT EXECUTED
104ff8: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0010d8f8 <rtems_blkdev_ioctl>:
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
10d8f8: f244 230b movw r3, #16907 ; 0x420b
{
10d8fc: b510 push {r4, lr}
switch (req)
10d8fe: f2c4 0304 movt r3, #16388 ; 0x4004
10d902: 4299 cmp r1, r3
10d904: d814 bhi.n 10d930 <rtems_blkdev_ioctl+0x38>
10d906: f244 2301 movw r3, #16897 ; 0x4201
10d90a: f2c4 0304 movt r3, #16388 ; 0x4004
10d90e: 4299 cmp r1, r3
10d910: d91b bls.n 10d94a <rtems_blkdev_ioctl+0x52>
10d912: f64b 53fe movw r3, #48638 ; 0xbdfe
10d916: 4604 mov r4, r0
10d918: f6cb 73fb movt r3, #49147 ; 0xbffb
10d91c: 440b add r3, r1
10d91e: 2b09 cmp r3, #9
10d920: d835 bhi.n 10d98e <rtems_blkdev_ioctl+0x96> <== ALWAYS TAKEN
10d922: e8df f003 tbb [pc, r3]
10d926: 403c .short 0x403c
10d928: 34344434 .word 0x34344434
10d92c: 4b344834 .word 0x4b344834
10d930: f244 2304 movw r3, #16900 ; 0x4204
10d934: f2c8 0304 movt r3, #32772 ; 0x8004
10d938: 4299 cmp r1, r3
10d93a: d128 bne.n 10d98e <rtems_blkdev_ioctl+0x96> <== ALWAYS TAKEN
case RTEMS_BLKIO_GETBLKSIZE:
*(uint32_t *) argp = dd->block_size;
break;
case RTEMS_BLKIO_SETBLKSIZE:
sc = rtems_bdbuf_set_block_size(dd, *(uint32_t *) argp, true);
10d93c: 6811 ldr r1, [r2, #0]
10d93e: 2201 movs r2, #1
10d940: f7ff ff4c bl 10d7dc <rtems_bdbuf_set_block_size>
if (sc != RTEMS_SUCCESSFUL) {
10d944: b9d8 cbnz r0, 10d97e <rtems_blkdev_ioctl+0x86>
int rc = 0;
10d946: 2000 movs r0, #0
rc = -1;
break;
}
return rc;
}
10d948: bd10 pop {r4, pc}
switch (req)
10d94a: f244 230a movw r3, #16906 ; 0x420a
10d94e: f2c2 0300 movt r3, #8192 ; 0x2000
10d952: 4299 cmp r1, r3
10d954: d037 beq.n 10d9c6 <rtems_blkdev_ioctl+0xce>
10d956: f244 230c movw r3, #16908 ; 0x420c
10d95a: f2c2 0300 movt r3, #8192 ; 0x2000
10d95e: 4299 cmp r1, r3
10d960: d103 bne.n 10d96a <rtems_blkdev_ioctl+0x72>
rtems_bdbuf_reset_device_stats(dd);
10d962: f7ff ffb5 bl 10d8d0 <rtems_bdbuf_reset_device_stats>
int rc = 0;
10d966: 2000 movs r0, #0
}
10d968: bd10 pop {r4, pc}
switch (req)
10d96a: f244 2306 movw r3, #16902 ; 0x4206
10d96e: f2c2 0300 movt r3, #8192 ; 0x2000
10d972: 4299 cmp r1, r3
10d974: d10b bne.n 10d98e <rtems_blkdev_ioctl+0x96>
sc = rtems_bdbuf_syncdev(dd);
10d976: f7ff fee9 bl 10d74c <rtems_bdbuf_syncdev>
if (sc != RTEMS_SUCCESSFUL) {
10d97a: 2800 cmp r0, #0
10d97c: d0e3 beq.n 10d946 <rtems_blkdev_ioctl+0x4e> <== NEVER TAKEN
errno = EIO;
10d97e: f002 fed5 bl 11072c <__errno> <== NOT EXECUTED
10d982: 2205 movs r2, #5 <== NOT EXECUTED
10d984: 4603 mov r3, r0 <== NOT EXECUTED
10d986: 601a str r2, [r3, #0] <== NOT EXECUTED
rc = -1;
10d988: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
}
10d98c: bd10 pop {r4, pc} <== NOT EXECUTED
errno = EINVAL;
10d98e: f002 fecd bl 11072c <__errno>
10d992: 2216 movs r2, #22
10d994: 4603 mov r3, r0
10d996: 601a str r2, [r3, #0]
rc = -1;
10d998: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
}
10d99c: bd10 pop {r4, pc}
*(uint32_t *) argp = dd->media_block_size;
10d99e: 6a03 ldr r3, [r0, #32]
int rc = 0;
10d9a0: 2000 movs r0, #0
*(uint32_t *) argp = dd->media_block_size;
10d9a2: 6013 str r3, [r2, #0]
}
10d9a4: bd10 pop {r4, pc}
*(uint32_t *) argp = dd->block_size;
10d9a6: 6a43 ldr r3, [r0, #36] ; 0x24
int rc = 0;
10d9a8: 2000 movs r0, #0
*(uint32_t *) argp = dd->block_size;
10d9aa: 6013 str r3, [r2, #0]
}
10d9ac: bd10 pop {r4, pc}
*(rtems_blkdev_bnum *) argp = dd->size;
10d9ae: 69c3 ldr r3, [r0, #28]
int rc = 0;
10d9b0: 2000 movs r0, #0
*(rtems_blkdev_bnum *) argp = dd->size;
10d9b2: 6013 str r3, [r2, #0]
}
10d9b4: bd10 pop {r4, pc}
int rc = 0;
10d9b6: 2000 movs r0, #0
*(rtems_disk_device **) argp = dd;
10d9b8: 6014 str r4, [r2, #0]
}
10d9ba: bd10 pop {r4, pc}
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
10d9bc: 4611 mov r1, r2
10d9be: f7ff ff6d bl 10d89c <rtems_bdbuf_get_device_stats>
int rc = 0;
10d9c2: 2000 movs r0, #0
10d9c4: e7c0 b.n 10d948 <rtems_blkdev_ioctl+0x50>
rtems_bdbuf_purge_dev(dd);
10d9c6: f7ff fef9 bl 10d7bc <rtems_bdbuf_purge_dev>
int rc = 0;
10d9ca: 2000 movs r0, #0
}
10d9cc: bd10 pop {r4, pc}
10d9ce: bf00 nop
001240e4 <rtems_blkstats>:
#include <unistd.h>
#include <errno.h>
#include <string.h>
void rtems_blkstats(const rtems_printer* printer, const char *device, bool reset)
{
1240e4: 460b mov r3, r1 <== NOT EXECUTED
1240e6: b570 push {r4, r5, r6, lr} <== NOT EXECUTED
int fd = open(device, O_RDONLY);
1240e8: 2100 movs r1, #0 <== NOT EXECUTED
{
1240ea: b0a8 sub sp, #160 ; 0xa0 <== NOT EXECUTED
1240ec: 4606 mov r6, r0 <== NOT EXECUTED
int fd = open(device, O_RDONLY);
1240ee: 4618 mov r0, r3 <== NOT EXECUTED
{
1240f0: 4614 mov r4, r2 <== NOT EXECUTED
int fd = open(device, O_RDONLY);
1240f2: f7e5 f975 bl 1093e0 <open> <== NOT EXECUTED
if (fd >= 0) {
1240f6: 1e05 subs r5, r0, #0 <== NOT EXECUTED
1240f8: db39 blt.n 12416e <rtems_blkstats+0x8a> <== NOT EXECUTED
struct stat st;
int rv;
rv = fstat(fd, &st);
1240fa: a90e add r1, sp, #56 ; 0x38 <== NOT EXECUTED
1240fc: f7e4 fd7c bl 108bf8 <fstat> <== NOT EXECUTED
if (rv == 0) {
124100: 2800 cmp r0, #0 <== NOT EXECUTED
124102: d144 bne.n 12418e <rtems_blkstats+0xaa> <== NOT EXECUTED
if (S_ISBLK(st.st_mode)) {
124104: 9b12 ldr r3, [sp, #72] ; 0x48 <== NOT EXECUTED
124106: f403 4370 and.w r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
12410a: f5b3 4fc0 cmp.w r3, #24576 ; 0x6000 <== NOT EXECUTED
12410e: d177 bne.n 124200 <rtems_blkstats+0x11c> <== NOT EXECUTED
if (reset) {
124110: 2c00 cmp r4, #0 <== NOT EXECUTED
124112: d14f bne.n 1241b4 <rtems_blkstats+0xd0> <== NOT EXECUTED
return ioctl(fd, RTEMS_BLKIO_GETMEDIABLKSIZE, media_block_size);
124114: f244 2102 movw r1, #16898 ; 0x4202 <== NOT EXECUTED
124118: aa03 add r2, sp, #12 <== NOT EXECUTED
12411a: f2c4 0104 movt r1, #16388 ; 0x4004 <== NOT EXECUTED
12411e: 4628 mov r0, r5 <== NOT EXECUTED
if (rv != 0) {
rtems_printf(printer, "error: reset stats: %s\n", strerror(errno));
}
} else {
uint32_t media_block_size = 0;
uint32_t media_block_count = 0;
124120: e9cd 4403 strd r4, r4, [sp, #12] <== NOT EXECUTED
uint32_t block_size = 0;
124124: 9405 str r4, [sp, #20] <== NOT EXECUTED
124126: f7e4 fdc9 bl 108cbc <ioctl> <== NOT EXECUTED
return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);
12412a: f244 2105 movw r1, #16901 ; 0x4205 <== NOT EXECUTED
12412e: aa04 add r2, sp, #16 <== NOT EXECUTED
124130: f2c4 0104 movt r1, #16388 ; 0x4004 <== NOT EXECUTED
124134: 4628 mov r0, r5 <== NOT EXECUTED
124136: f7e4 fdc1 bl 108cbc <ioctl> <== NOT EXECUTED
return ioctl(fd, RTEMS_BLKIO_GETBLKSIZE, block_size);
12413a: f244 2103 movw r1, #16899 ; 0x4203 <== NOT EXECUTED
12413e: aa05 add r2, sp, #20 <== NOT EXECUTED
124140: f2c4 0104 movt r1, #16388 ; 0x4004 <== NOT EXECUTED
124144: 4628 mov r0, r5 <== NOT EXECUTED
124146: f7e4 fdb9 bl 108cbc <ioctl> <== NOT EXECUTED
static inline int rtems_disk_fd_get_device_stats(
int fd,
rtems_blkdev_stats *stats
)
{
return ioctl(fd, RTEMS_BLKIO_GETDEVSTATS, stats);
12414a: f244 210b movw r1, #16907 ; 0x420b <== NOT EXECUTED
12414e: aa06 add r2, sp, #24 <== NOT EXECUTED
124150: f2c4 0104 movt r1, #16388 ; 0x4004 <== NOT EXECUTED
124154: 4628 mov r0, r5 <== NOT EXECUTED
124156: f7e4 fdb1 bl 108cbc <ioctl> <== NOT EXECUTED
rtems_disk_fd_get_media_block_size(fd, &media_block_size);
rtems_disk_fd_get_block_count(fd, &media_block_count);
rtems_disk_fd_get_block_size(fd, &block_size);
rv = rtems_disk_fd_get_device_stats(fd, &stats);
if (rv == 0) {
12415a: 2800 cmp r0, #0 <== NOT EXECUTED
12415c: d158 bne.n 124210 <rtems_blkstats+0x12c> <== NOT EXECUTED
rtems_blkdev_print_stats(
12415e: e9dd 2304 ldrd r2, r3, [sp, #16] <== NOT EXECUTED
124162: a806 add r0, sp, #24 <== NOT EXECUTED
124164: 9903 ldr r1, [sp, #12] <== NOT EXECUTED
124166: 9600 str r6, [sp, #0] <== NOT EXECUTED
124168: f000 f8cc bl 124304 <rtems_blkdev_print_stats> <== NOT EXECUTED
12416c: e01c b.n 1241a8 <rtems_blkstats+0xc4> <== NOT EXECUTED
rv = close(fd);
if (rv != 0) {
rtems_printf(printer, "error: close device: %s\n", strerror(errno));
}
} else {
rtems_printf(printer, "error: open device: %s\n", strerror(errno));
12416e: f01a f8f1 bl 13e354 <__errno> <== NOT EXECUTED
124172: 6800 ldr r0, [r0, #0] <== NOT EXECUTED
124174: f01f f928 bl 1433c8 <strerror> <== NOT EXECUTED
124178: f646 5118 movw r1, #27928 ; 0x6d18 <== NOT EXECUTED
12417c: 4602 mov r2, r0 <== NOT EXECUTED
12417e: f2c0 0115 movt r1, #21 <== NOT EXECUTED
124182: 4630 mov r0, r6 <== NOT EXECUTED
}
}
124184: b028 add sp, #160 ; 0xa0 <== NOT EXECUTED
124186: e8bd 4070 ldmia.w sp!, {r4, r5, r6, lr} <== NOT EXECUTED
rtems_printf(printer, "error: open device: %s\n", strerror(errno));
12418a: f000 be1f b.w 124dcc <rtems_printf> <== NOT EXECUTED
rtems_printf(printer, "error: get file stats: %s\n", strerror(errno));
12418e: f01a f8e1 bl 13e354 <__errno> <== NOT EXECUTED
124192: 6800 ldr r0, [r0, #0] <== NOT EXECUTED
124194: f01f f918 bl 1433c8 <strerror> <== NOT EXECUTED
124198: f646 41e0 movw r1, #27872 ; 0x6ce0 <== NOT EXECUTED
12419c: 4602 mov r2, r0 <== NOT EXECUTED
12419e: f2c0 0115 movt r1, #21 <== NOT EXECUTED
1241a2: 4630 mov r0, r6 <== NOT EXECUTED
1241a4: f000 fe12 bl 124dcc <rtems_printf> <== NOT EXECUTED
rv = close(fd);
1241a8: 4628 mov r0, r5 <== NOT EXECUTED
1241aa: f7e4 fbf5 bl 108998 <close> <== NOT EXECUTED
if (rv != 0) {
1241ae: b9c0 cbnz r0, 1241e2 <rtems_blkstats+0xfe> <== NOT EXECUTED
}
1241b0: b028 add sp, #160 ; 0xa0 <== NOT EXECUTED
1241b2: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
}
static inline int rtems_disk_fd_reset_device_stats(int fd)
{
return ioctl(fd, RTEMS_BLKIO_RESETDEVSTATS);
1241b4: f244 210c movw r1, #16908 ; 0x420c <== NOT EXECUTED
1241b8: 4628 mov r0, r5 <== NOT EXECUTED
1241ba: f2c2 0100 movt r1, #8192 ; 0x2000 <== NOT EXECUTED
1241be: f7e4 fd7d bl 108cbc <ioctl> <== NOT EXECUTED
if (rv != 0) {
1241c2: 2800 cmp r0, #0 <== NOT EXECUTED
1241c4: d0f0 beq.n 1241a8 <rtems_blkstats+0xc4> <== NOT EXECUTED
rtems_printf(printer, "error: reset stats: %s\n", strerror(errno));
1241c6: f01a f8c5 bl 13e354 <__errno> <== NOT EXECUTED
1241ca: 6800 ldr r0, [r0, #0] <== NOT EXECUTED
1241cc: f01f f8fc bl 1433c8 <strerror> <== NOT EXECUTED
1241d0: f646 4194 movw r1, #27796 ; 0x6c94 <== NOT EXECUTED
1241d4: 4602 mov r2, r0 <== NOT EXECUTED
1241d6: f2c0 0115 movt r1, #21 <== NOT EXECUTED
1241da: 4630 mov r0, r6 <== NOT EXECUTED
1241dc: f000 fdf6 bl 124dcc <rtems_printf> <== NOT EXECUTED
1241e0: e7e2 b.n 1241a8 <rtems_blkstats+0xc4> <== NOT EXECUTED
rtems_printf(printer, "error: close device: %s\n", strerror(errno));
1241e2: f01a f8b7 bl 13e354 <__errno> <== NOT EXECUTED
1241e6: 6800 ldr r0, [r0, #0] <== NOT EXECUTED
1241e8: f01f f8ee bl 1433c8 <strerror> <== NOT EXECUTED
1241ec: f646 41fc movw r1, #27900 ; 0x6cfc <== NOT EXECUTED
1241f0: 4602 mov r2, r0 <== NOT EXECUTED
1241f2: f2c0 0115 movt r1, #21 <== NOT EXECUTED
1241f6: 4630 mov r0, r6 <== NOT EXECUTED
1241f8: f000 fde8 bl 124dcc <rtems_printf> <== NOT EXECUTED
}
1241fc: b028 add sp, #160 ; 0xa0 <== NOT EXECUTED
1241fe: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
rtems_printf(printer, "error: not a block device\n");
124200: f646 41c4 movw r1, #27844 ; 0x6cc4 <== NOT EXECUTED
124204: 4630 mov r0, r6 <== NOT EXECUTED
124206: f2c0 0115 movt r1, #21 <== NOT EXECUTED
12420a: f000 fddf bl 124dcc <rtems_printf> <== NOT EXECUTED
12420e: e7cb b.n 1241a8 <rtems_blkstats+0xc4> <== NOT EXECUTED
rtems_printf(printer, "error: get stats: %s\n", strerror(errno));
124210: f01a f8a0 bl 13e354 <__errno> <== NOT EXECUTED
124214: 6800 ldr r0, [r0, #0] <== NOT EXECUTED
124216: f01f f8d7 bl 1433c8 <strerror> <== NOT EXECUTED
12421a: f646 41ac movw r1, #27820 ; 0x6cac <== NOT EXECUTED
12421e: 4602 mov r2, r0 <== NOT EXECUTED
124220: f2c0 0115 movt r1, #21 <== NOT EXECUTED
124224: 4630 mov r0, r6 <== NOT EXECUTED
124226: f000 fdd1 bl 124dcc <rtems_printf> <== NOT EXECUTED
12422a: e7bd b.n 1241a8 <rtems_blkstats+0xc4> <== NOT EXECUTED
00105634 <rtems_disk_io_done>:
rtems_status_code
rtems_disk_io_done(void)
{
105634: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
105638: f641 77a8 movw r7, #8104 ; 0x1fa8
10563c: f2c0 0720 movt r7, #32
rtems_disk_device_table *dtab = disktab + major;
105640: f641 78a4 movw r8, #8100 ; 0x1fa4
105644: f2c0 0820 movt r8, #32
for (major = 0; major < disktab_size; ++major) {
105648: 683b ldr r3, [r7, #0]
rtems_disk_device_table *dtab = disktab + major;
10564a: f8d8 4000 ldr.w r4, [r8]
for (major = 0; major < disktab_size; ++major) {
10564e: b1d3 cbz r3, 105686 <rtems_disk_io_done+0x52>
105650: 2600 movs r6, #0
rtems_disk_device_table *dtab = disktab + major;
105652: eb04 05c6 add.w r5, r4, r6, lsl #3
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
105656: f854 3036 ldr.w r3, [r4, r6, lsl #3]
for (minor = 0; minor < dtab->size; ++minor) {
10565a: 686a ldr r2, [r5, #4]
10565c: b162 cbz r2, 105678 <rtems_disk_io_done+0x44>
10565e: 2400 movs r4, #0
rtems_disk_device *dd = dtab->minor [minor];
105660: f853 0024 ldr.w r0, [r3, r4, lsl #2]
for (minor = 0; minor < dtab->size; ++minor) {
105664: 3401 adds r4, #1
if (dd != NULL) {
105666: b118 cbz r0, 105670 <rtems_disk_io_done+0x3c>
free_disk_device(dd);
105668: f7ff fdb0 bl 1051cc <free_disk_device> <== NOT EXECUTED
}
}
free(dtab->minor);
10566c: e9d5 3200 ldrd r3, r2, [r5] <== NOT EXECUTED
for (minor = 0; minor < dtab->size; ++minor) {
105670: 42a2 cmp r2, r4
105672: d8f5 bhi.n 105660 <rtems_disk_io_done+0x2c>
}
free(disktab);
105674: f8d8 4000 ldr.w r4, [r8]
free(dtab->minor);
105678: 4618 mov r0, r3
for (major = 0; major < disktab_size; ++major) {
10567a: 3601 adds r6, #1
free(dtab->minor);
10567c: f000 f9ae bl 1059dc <free>
for (major = 0; major < disktab_size; ++major) {
105680: 683b ldr r3, [r7, #0]
105682: 42b3 cmp r3, r6
105684: d8e5 bhi.n 105652 <rtems_disk_io_done+0x1e>
free(disktab);
105686: 4620 mov r0, r4
105688: f000 f9a8 bl 1059dc <free>
disktab = NULL;
10568c: 2000 movs r0, #0
10568e: f8c8 0000 str.w r0, [r8]
disktab_size = 0;
105692: 6038 str r0, [r7, #0]
return RTEMS_SUCCESSFUL;
}
105694: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
001055f4 <rtems_disk_io_initialize>:
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
1055f4: b538 push {r3, r4, r5, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
1055f6: f641 74a8 movw r4, #8104 ; 0x1fa8
1055fa: f2c0 0420 movt r4, #32
return RTEMS_SUCCESSFUL;
1055fe: 2000 movs r0, #0
if (disktab_size > 0) {
105600: 6823 ldr r3, [r4, #0]
105602: b103 cbz r3, 105606 <rtems_disk_io_initialize+0x12>
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
}
105604: bd38 pop {r3, r4, r5, pc} <== NOT EXECUTED
disktab = calloc(size, sizeof(rtems_disk_device_table));
105606: 2108 movs r1, #8
105608: f641 75a4 movw r5, #8100 ; 0x1fa4
10560c: 4608 mov r0, r1
10560e: f2c0 0520 movt r5, #32
105612: f000 f957 bl 1058c4 <calloc>
105616: 6028 str r0, [r5, #0]
if (disktab == NULL) {
105618: b150 cbz r0, 105630 <rtems_disk_io_initialize+0x3c>
sc = rtems_bdbuf_init();
10561a: f006 f985 bl 10b928 <rtems_bdbuf_init>
if (sc != RTEMS_SUCCESSFUL) {
10561e: b910 cbnz r0, 105626 <rtems_disk_io_initialize+0x32>
disktab_size = size;
105620: 2308 movs r3, #8
105622: 6023 str r3, [r4, #0]
}
105624: bd38 pop {r3, r4, r5, pc}
free(disktab);
105626: 6828 ldr r0, [r5, #0] <== NOT EXECUTED
105628: f000 f9d8 bl 1059dc <free> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
10562c: 200d movs r0, #13 <== NOT EXECUTED
}
10562e: bd38 pop {r3, r4, r5, pc} <== NOT EXECUTED
return RTEMS_NO_MEMORY;
105630: 201a movs r0, #26 <== NOT EXECUTED
}
105632: bd38 pop {r3, r4, r5, pc} <== NOT EXECUTED
00105520 <rtems_disk_obtain>:
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
105520: b5f8 push {r3, r4, r5, r6, r7, lr}
* advantage. Without operating system support, the FIQs can execute at any
* time (of course not during the service of another FIQ). If someone needs
* operating system support for a FIQ, she can trigger a software interrupt and
* service the request in a two-step process.
*/
__asm__ volatile (
105522: f3ef 8700 mrs r7, CPSR
105526: f047 0380 orr.w r3, r7, #128 ; 0x80
10552a: f383 8900 msr CPSR_fc, r3
rtems_disk_device *dd = NULL;
rtems_interrupt_lock_context lock_context;
rtems_interrupt_lock_acquire(&diskdevs_lock, &lock_context);
if (!diskdevs_protected) {
10552e: f641 74a0 movw r4, #8096 ; 0x1fa0
105532: f2c0 0420 movt r4, #32
105536: 7823 ldrb r3, [r4, #0]
105538: b943 cbnz r3, 10554c <rtems_disk_obtain+0x2c>
10553a: f003 02ff and.w r2, r3, #255 ; 0xff
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
10553e: f7ff fd85 bl 10504c <get_disk_entry>
105542: 4605 mov r5, r0
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
105544: f387 8900 msr CPSR_fc, r7
dd = get_disk_entry(dev, false);
disk_unlock();
}
return dd;
}
105548: 4628 mov r0, r5
10554a: bdf8 pop {r3, r4, r5, r6, r7, pc}
10554c: 4606 mov r6, r0 <== NOT EXECUTED
10554e: 460d mov r5, r1 <== NOT EXECUTED
105550: f387 8900 msr CPSR_fc, r7 <== NOT EXECUTED
_Mutex_Acquire( mutex );
105554: f240 007c movw r0, #124 ; 0x7c <== NOT EXECUTED
105558: f2c0 0020 movt r0, #32 <== NOT EXECUTED
10555c: f003 f8b8 bl 1086d0 <_Mutex_Acquire> <== NOT EXECUTED
dd = get_disk_entry(dev, false);
105560: 4629 mov r1, r5 <== NOT EXECUTED
diskdevs_protected = true;
105562: 2301 movs r3, #1 <== NOT EXECUTED
dd = get_disk_entry(dev, false);
105564: 2200 movs r2, #0 <== NOT EXECUTED
105566: 4630 mov r0, r6 <== NOT EXECUTED
diskdevs_protected = true;
105568: 7023 strb r3, [r4, #0] <== NOT EXECUTED
dd = get_disk_entry(dev, false);
10556a: f7ff fd6f bl 10504c <get_disk_entry> <== NOT EXECUTED
10556e: 4605 mov r5, r0 <== NOT EXECUTED
_Mutex_Release( mutex );
105570: f240 007c movw r0, #124 ; 0x7c <== NOT EXECUTED
diskdevs_protected = false;
105574: 2300 movs r3, #0 <== NOT EXECUTED
105576: f2c0 0020 movt r0, #32 <== NOT EXECUTED
10557a: 7023 strb r3, [r4, #0] <== NOT EXECUTED
10557c: f003 f8d4 bl 108728 <_Mutex_Release> <== NOT EXECUTED
}
105580: 4628 mov r0, r5 <== NOT EXECUTED
105582: bdf8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
0010705c <rtems_fdisk_initialize>:
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg RTEMS_UNUSED)
{
10705c: 4603 mov r3, r0
10705e: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
107062: f44f 7000 mov.w r0, #512 ; 0x200
{
107066: b093 sub sp, #76 ; 0x4c
107068: 930a str r3, [sp, #40] ; 0x28
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
10706a: f000 fca1 bl 1079b0 <malloc>
10706e: f242 53a0 movw r3, #9632 ; 0x25a0
107072: f2c0 0321 movt r3, #33 ; 0x21
107076: 6018 str r0, [r3, #0]
if (!rtems_fdisk_crc16_factor)
107078: 2800 cmp r0, #0
10707a: f000 818d beq.w 107398 <rtems_fdisk_initialize+0x33c> <== ALWAYS TAKEN
10707e: 1e85 subs r5, r0, #2
for (b = 0; b < 256; b++)
107080: 2400 movs r4, #0
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
107082: f248 4008 movw r0, #33800 ; 0x8408
uint16_t v = b;
107086: b2a3 uxth r3, r4
for (b = 0; b < 256; b++)
107088: f04f 0a08 mov.w sl, #8
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
10708c: f003 0201 and.w r2, r3, #1
107090: 085b lsrs r3, r3, #1
107092: ea83 0100 eor.w r1, r3, r0
107096: b102 cbz r2, 10709a <rtems_fdisk_initialize+0x3e>
107098: b28b uxth r3, r1
for (i = 8; i--;)
10709a: f1ba 0a01 subs.w sl, sl, #1
10709e: d1f5 bne.n 10708c <rtems_fdisk_initialize+0x30>
for (b = 0; b < 256; b++)
1070a0: 3401 adds r4, #1
rtems_fdisk_crc16_factor[b] = v & 0xffff;
1070a2: f825 3f02 strh.w r3, [r5, #2]!
for (b = 0; b < 256; b++)
1070a6: f5b4 7f80 cmp.w r4, #256 ; 0x100
1070aa: d1ec bne.n 107086 <rtems_fdisk_initialize+0x2a>
sc = rtems_fdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
fd = calloc (rtems_flashdisk_configuration_size, sizeof (*fd));
1070ac: f240 0390 movw r3, #144 ; 0x90
1070b0: 2184 movs r1, #132 ; 0x84
1070b2: f2c0 0320 movt r3, #32
1070b6: 681c ldr r4, [r3, #0]
1070b8: 930b str r3, [sp, #44] ; 0x2c
1070ba: 4620 mov r0, r4
1070bc: f000 f9ce bl 10745c <calloc>
if (!fd)
1070c0: 9006 str r0, [sp, #24]
1070c2: 2800 cmp r0, #0
1070c4: f000 8168 beq.w 107398 <rtems_fdisk_initialize+0x33c> <== ALWAYS TAKEN
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++, fd++)
1070c8: 2c00 cmp r4, #0
1070ca: f000 8109 beq.w 1072e0 <rtems_fdisk_initialize+0x284> <== ALWAYS TAKEN
1070ce: 4bbe ldr r3, [pc, #760] ; (1073c8 <rtems_fdisk_initialize+0x36c>)
static __inline void
_Mutex_Initialize_named(struct _Mutex_Control *_mutex, const char *_name)
{
struct _Mutex_Control _init = _MUTEX_NAMED_INITIALIZER(_name);
*_mutex = _init;
1070d0: 46d1 mov r9, sl
1070d2: f8cd a020 str.w sl, [sp, #32]
1070d6: f8cd a034 str.w sl, [sp, #52] ; 0x34
1070da: 9307 str r3, [sp, #28]
1070dc: f240 53b8 movw r3, #1464 ; 0x5b8
1070e0: f2c0 0312 movt r3, #18
1070e4: 930c str r3, [sp, #48] ; 0x30
uint32_t blocks = 0;
int ret;
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
1070e6: 9a06 ldr r2, [sp, #24]
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
1070e8: ab0f add r3, sp, #60 ; 0x3c
fd->minor = minor;
1070ea: 9e08 ldr r6, [sp, #32]
fd->major = major;
1070ec: 990a ldr r1, [sp, #40] ; 0x28
1070ee: 4614 mov r4, r2
fd->minor = minor;
1070f0: 6056 str r6, [r2, #4]
fd->major = major;
1070f2: 6011 str r1, [r2, #0]
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
1070f4: 9a0c ldr r2, [sp, #48] ; 0x30
1070f6: ca07 ldmia r2, {r0, r1, r2}
1070f8: c303 stmia r3!, {r0, r1}
fd->flags = c->flags;
1070fa: 9807 ldr r0, [sp, #28]
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
1070fc: 801a strh r2, [r3, #0]
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
1070fe: f88d 6045 strb.w r6, [sp, #69] ; 0x45
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
107102: e950 2303 ldrd r2, r3, [r0, #-12]
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
107106: f850 6c10 ldr.w r6, [r0, #-16]
fd->flags = c->flags;
10710a: f850 1c14 ldr.w r1, [r0, #-20]
fd->block_size = c->block_size;
10710e: f850 5c20 ldr.w r5, [r0, #-32]
fd->compact_segs = c->compact_segs;
107112: 60e2 str r2, [r4, #12]
fd->avail_compact_segs = c->avail_compact_segs;
107114: 4622 mov r2, r4
107116: 6123 str r3, [r4, #16]
fd->flags = c->flags;
107118: 60a1 str r1, [r4, #8]
fd->block_size = c->block_size;
10711a: 6165 str r5, [r4, #20]
fd->unavail_blocks = c->unavail_blocks;
10711c: 6226 str r6, [r4, #32]
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
10711e: f850 4c1c ldr.w r4, [r0, #-28]
fd->info_level = c->info_level;
107122: f850 3c04 ldr.w r3, [r0, #-4]
fd->unavail_blocks = c->unavail_blocks;
107126: 9605 str r6, [sp, #20]
for (device = 0; device < c->device_count; device++)
107128: 9404 str r4, [sp, #16]
fd->info_level = c->info_level;
10712a: 67d3 str r3, [r2, #124] ; 0x7c
for (device = 0; device < c->device_count; device++)
10712c: 2c00 cmp r4, #0
10712e: f000 80e5 beq.w 1072fc <rtems_fdisk_initialize+0x2a0> <== ALWAYS TAKEN
107132: f850 7c18 ldr.w r7, [r0, #-24]
107136: eb04 0344 add.w r3, r4, r4, lsl #1
uint32_t blocks = 0;
10713a: f04f 0800 mov.w r8, #0
10713e: 46ab mov fp, r5
107140: eb07 0383 add.w r3, r7, r3, lsl #2
107144: 9303 str r3, [sp, #12]
for (s = 0; s < dd->segment_count; s++)
107146: 683b ldr r3, [r7, #0]
107148: b1bb cbz r3, 10717a <rtems_fdisk_initialize+0x11e>
10714a: 687e ldr r6, [r7, #4]
10714c: eb03 0343 add.w r3, r3, r3, lsl #1
uint32_t count = 0;
107150: 2500 movs r5, #0
107152: eb06 0a83 add.w sl, r6, r3, lsl #2
return sd->size / page_size;
107156: 68b0 ldr r0, [r6, #8]
107158: 4659 mov r1, fp
10715a: f010 f939 bl 1173d0 <__udivsi3>
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
10715e: 00c3 lsls r3, r0, #3
(rtems_fdisk_pages_in_segment (sd, page_size) -
107160: 1e44 subs r4, r0, #1
return ((bytes - 1) / page_size) + 1;
107162: 4659 mov r1, fp
107164: 1e58 subs r0, r3, #1
107166: f010 f933 bl 1173d0 <__udivsi3>
rtems_fdisk_page_desc_pages (sd, page_size)) * sd->count;
10716a: f836 3b0c ldrh.w r3, [r6], #12
(rtems_fdisk_pages_in_segment (sd, page_size) -
10716e: 1a20 subs r0, r4, r0
for (s = 0; s < dd->segment_count; s++)
107170: 4556 cmp r6, sl
count +=
107172: fb03 5500 mla r5, r3, r0, r5
for (s = 0; s < dd->segment_count; s++)
107176: d1ee bne.n 107156 <rtems_fdisk_initialize+0xfa> <== ALWAYS TAKEN
blocks += rtems_fdisk_blocks_in_device (&c->devices[device],
107178: 44a8 add r8, r5
for (device = 0; device < c->device_count; device++)
10717a: 9b03 ldr r3, [sp, #12]
10717c: 370c adds r7, #12
10717e: 42bb cmp r3, r7
107180: d1e1 bne.n 107146 <rtems_fdisk_initialize+0xea> <== ALWAYS TAKEN
107182: 465d mov r5, fp
c->block_size);
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
107184: 4628 mov r0, r5
107186: f000 fc13 bl 1079b0 <malloc>
10718a: 9c06 ldr r4, [sp, #24]
10718c: 67a0 str r0, [r4, #120] ; 0x78
if (!fd->copy_buffer)
10718e: 2800 cmp r0, #0
107190: f000 8116 beq.w 1073c0 <rtems_fdisk_initialize+0x364> <== ALWAYS TAKEN
return RTEMS_NO_MEMORY;
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
107194: 2108 movs r1, #8
107196: 4640 mov r0, r8
107198: f000 f960 bl 10745c <calloc>
10719c: 61a0 str r0, [r4, #24]
if (!fd->blocks)
10719e: 2800 cmp r0, #0
1071a0: f000 810e beq.w 1073c0 <rtems_fdisk_initialize+0x364> <== ALWAYS TAKEN
return RTEMS_NO_MEMORY;
fd->block_count = blocks;
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
1071a4: 9804 ldr r0, [sp, #16]
1071a6: 210c movs r1, #12
fd->block_count = blocks;
1071a8: f8c4 801c str.w r8, [r4, #28]
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
1071ac: f000 f956 bl 10745c <calloc>
1071b0: 62e0 str r0, [r4, #44] ; 0x2c
if (!fd->devices)
1071b2: 2800 cmp r0, #0
1071b4: f000 8104 beq.w 1073c0 <rtems_fdisk_initialize+0x364> <== ALWAYS TAKEN
return RTEMS_NO_MEMORY;
rtems_mutex_init (&fd->lock, "Flash Disk");
sc = rtems_blkdev_create(name, c->block_size, blocks - fd->unavail_blocks,
1071b8: 9a05 ldr r2, [sp, #20]
1071ba: f240 534c movw r3, #1356 ; 0x54c
1071be: f2c0 0312 movt r3, #18
1071c2: e9c4 9919 strd r9, r9, [r4, #100] ; 0x64
1071c6: 6763 str r3, [r4, #116] ; 0x74
1071c8: f246 2391 movw r3, #25233 ; 0x6291
1071cc: eba8 0202 sub.w r2, r8, r2
1071d0: e9c4 991b strd r9, r9, [r4, #108] ; 0x6c
1071d4: 4629 mov r1, r5
1071d6: a80f add r0, sp, #60 ; 0x3c
1071d8: f2c0 0310 movt r3, #16
1071dc: 9400 str r4, [sp, #0]
1071de: f007 fffd bl 10f1dc <rtems_blkdev_create>
rtems_fdisk_ioctl, fd);
if (sc != RTEMS_SUCCESSFUL)
1071e2: 4680 mov r8, r0
1071e4: 2800 cmp r0, #0
1071e6: f040 808c bne.w 107302 <rtems_fdisk_initialize+0x2a6> <== ALWAYS TAKEN
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
1071ea: 9b07 ldr r3, [sp, #28]
1071ec: f853 3c1c ldr.w r3, [r3, #-28]
1071f0: 9309 str r3, [sp, #36] ; 0x24
1071f2: 2b00 cmp r3, #0
1071f4: d054 beq.n 1072a0 <rtems_fdisk_initialize+0x244> <== ALWAYS TAKEN
{
rtems_fdisk_segment_ctl* sc;
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
1071f6: 9b07 ldr r3, [sp, #28]
for (device = 0; device < c->device_count; device++)
1071f8: 4605 mov r5, r0
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
1071fa: f853 bc18 ldr.w fp, [r3, #-24]
fd->devices[device].segments = calloc (segment_count,
1071fe: 9b06 ldr r3, [sp, #24]
107200: f8d3 a02c ldr.w sl, [r3, #44] ; 0x2c
107204: 9b09 ldr r3, [sp, #36] ; 0x24
107206: eb03 0343 add.w r3, r3, r3, lsl #1
10720a: 9305 str r3, [sp, #20]
for (segment = 0; segment < dd->segment_count; segment++)
10720c: f85b 7028 ldr.w r7, [fp, r8, lsl #2]
107210: eb0b 0388 add.w r3, fp, r8, lsl #2
107214: 9303 str r3, [sp, #12]
107216: 2f00 cmp r7, #0
107218: d066 beq.n 1072e8 <rtems_fdisk_initialize+0x28c> <== ALWAYS TAKEN
10721a: 007b lsls r3, r7, #1
count += dd->segments[segment].count;
10721c: f10b 0104 add.w r1, fp, #4
107220: f851 4028 ldr.w r4, [r1, r8, lsl #2]
107224: 2100 movs r1, #0
107226: eb03 0c07 add.w ip, r3, r7
uint32_t count = 0;
10722a: 460e mov r6, r1
10722c: ea4f 0c4c mov.w ip, ip, lsl #1
count += dd->segments[segment].count;
107230: f834 2011 ldrh.w r2, [r4, r1, lsl #1]
for (segment = 0; segment < dd->segment_count; segment++)
107234: 3106 adds r1, #6
107236: 458c cmp ip, r1
count += dd->segments[segment].count;
107238: 4416 add r6, r2
for (segment = 0; segment < dd->segment_count; segment++)
10723a: d1f9 bne.n 107230 <rtems_fdisk_initialize+0x1d4> <== ALWAYS TAKEN
fd->devices[device].segments = calloc (segment_count,
10723c: 2130 movs r1, #48 ; 0x30
10723e: 4630 mov r0, r6
107240: 9304 str r3, [sp, #16]
107242: f000 f90b bl 10745c <calloc>
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
107246: 9b04 ldr r3, [sp, #16]
fd->devices[device].segments = calloc (segment_count,
107248: f84a 0028 str.w r0, [sl, r8, lsl #2]
if (!fd->devices[device].segments)
10724c: 2800 cmp r0, #0
10724e: f000 80a6 beq.w 10739e <rtems_fdisk_initialize+0x342> <== ALWAYS TAKEN
107252: 441f add r7, r3
107254: eb04 0787 add.w r7, r4, r7, lsl #2
const rtems_fdisk_segment_desc* sd;
uint32_t seg_segment;
sd = &c->devices[device].segments[segment];
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
107258: 8821 ldrh r1, [r4, #0]
10725a: b179 cbz r1, 10727c <rtems_fdisk_initialize+0x220>
10725c: 2200 movs r2, #0
10725e: 4603 mov r3, r0
{
sc->descriptor = sd;
sc->device = device;
sc->segment = seg_segment;
107260: 60da str r2, [r3, #12]
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
107262: 3201 adds r2, #1
107264: 428a cmp r2, r1
sc->device = device;
107266: e9c3 4501 strd r4, r5, [r3, #4]
sc->erased = 0;
10726a: f8c3 902c str.w r9, [r3, #44] ; 0x2c
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
10726e: f103 0330 add.w r3, r3, #48 ; 0x30
107272: d1f5 bne.n 107260 <rtems_fdisk_initialize+0x204>
107274: eb02 0242 add.w r2, r2, r2, lsl #1
107278: eb00 1002 add.w r0, r0, r2, lsl #4
for (segment = 0; segment < c->devices[device].segment_count; segment++)
10727c: 340c adds r4, #12
10727e: 42a7 cmp r7, r4
107280: d1ea bne.n 107258 <rtems_fdisk_initialize+0x1fc> <== ALWAYS TAKEN
}
}
fd->devices[device].segment_count = segment_count;
fd->devices[device].descriptor = &c->devices[device];
107282: 9a03 ldr r2, [sp, #12]
fd->devices[device].segment_count = segment_count;
107284: f10a 0304 add.w r3, sl, #4
107288: f843 6028 str.w r6, [r3, r8, lsl #2]
fd->devices[device].descriptor = &c->devices[device];
10728c: f10a 0308 add.w r3, sl, #8
for (device = 0; device < c->device_count; device++)
107290: 3501 adds r5, #1
fd->devices[device].descriptor = &c->devices[device];
107292: f843 2028 str.w r2, [r3, r8, lsl #2]
for (device = 0; device < c->device_count; device++)
107296: f108 0803 add.w r8, r8, #3
10729a: 9b05 ldr r3, [sp, #20]
10729c: 4543 cmp r3, r8
10729e: d1b5 bne.n 10720c <rtems_fdisk_initialize+0x1b0> <== ALWAYS TAKEN
}
fd->device_count = c->device_count;
ret = rtems_fdisk_recover_block_mappings (fd);
1072a0: 9b06 ldr r3, [sp, #24]
1072a2: 4618 mov r0, r3
fd->device_count = c->device_count;
1072a4: 9b09 ldr r3, [sp, #36] ; 0x24
1072a6: 6303 str r3, [r0, #48] ; 0x30
ret = rtems_fdisk_recover_block_mappings (fd);
1072a8: f7fe feba bl 106020 <rtems_fdisk_recover_block_mappings>
if (ret)
1072ac: 4604 mov r4, r0
1072ae: 2800 cmp r0, #0
1072b0: d13c bne.n 10732c <rtems_fdisk_initialize+0x2d0> <== ALWAYS TAKEN
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
strerror (ret), ret);
return ret;
}
ret = rtems_fdisk_compact (fd);
1072b2: 9806 ldr r0, [sp, #24]
1072b4: f7fe fdd6 bl 105e64 <rtems_fdisk_compact>
if (ret)
1072b8: 4604 mov r4, r0
1072ba: 2800 cmp r0, #0
1072bc: d151 bne.n 107362 <rtems_fdisk_initialize+0x306> <== ALWAYS TAKEN
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++, fd++)
1072be: 9906 ldr r1, [sp, #24]
1072c0: 9b0b ldr r3, [sp, #44] ; 0x2c
1072c2: 9a08 ldr r2, [sp, #32]
1072c4: 3184 adds r1, #132 ; 0x84
1072c6: 681b ldr r3, [r3, #0]
1072c8: 9106 str r1, [sp, #24]
1072ca: 3201 adds r2, #1
1072cc: 9907 ldr r1, [sp, #28]
1072ce: 4293 cmp r3, r2
1072d0: 9208 str r2, [sp, #32]
1072d2: f101 0120 add.w r1, r1, #32
1072d6: 9107 str r1, [sp, #28]
1072d8: f63f af05 bhi.w 1070e6 <rtems_fdisk_initialize+0x8a> <== ALWAYS TAKEN
1072dc: f8dd a034 ldr.w sl, [sp, #52] ; 0x34
return ret;
}
}
return RTEMS_SUCCESSFUL;
}
1072e0: 4650 mov r0, sl
1072e2: b013 add sp, #76 ; 0x4c
1072e4: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
fd->devices[device].segments = calloc (segment_count,
1072e8: 2130 movs r1, #48 ; 0x30 <== NOT EXECUTED
1072ea: 4638 mov r0, r7 <== NOT EXECUTED
1072ec: f000 f8b6 bl 10745c <calloc> <== NOT EXECUTED
1072f0: f84a 0028 str.w r0, [sl, r8, lsl #2] <== NOT EXECUTED
if (!fd->devices[device].segments)
1072f4: 2800 cmp r0, #0 <== NOT EXECUTED
1072f6: d052 beq.n 10739e <rtems_fdisk_initialize+0x342> <== NOT EXECUTED
uint32_t count = 0;
1072f8: 463e mov r6, r7 <== NOT EXECUTED
1072fa: e7c2 b.n 107282 <rtems_fdisk_initialize+0x226> <== NOT EXECUTED
uint32_t blocks = 0;
1072fc: f8dd 8010 ldr.w r8, [sp, #16] <== NOT EXECUTED
107300: e740 b.n 107184 <rtems_fdisk_initialize+0x128> <== NOT EXECUTED
free (fd->copy_buffer);
107302: 9c06 ldr r4, [sp, #24] <== NOT EXECUTED
return RTEMS_NO_MEMORY;
107304: 46c2 mov sl, r8 <== NOT EXECUTED
free (fd->copy_buffer);
107306: 6fa0 ldr r0, [r4, #120] ; 0x78 <== NOT EXECUTED
107308: f000 f97a bl 107600 <free> <== NOT EXECUTED
free (fd->blocks);
10730c: 69a0 ldr r0, [r4, #24] <== NOT EXECUTED
10730e: f000 f977 bl 107600 <free> <== NOT EXECUTED
free (fd->devices);
107312: 6ae0 ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
107314: f000 f974 bl 107600 <free> <== NOT EXECUTED
rtems_fdisk_error ("disk create phy failed");
107318: f240 5058 movw r0, #1368 ; 0x558 <== NOT EXECUTED
10731c: f2c0 0012 movt r0, #18 <== NOT EXECUTED
107320: f7fe f9e6 bl 1056f0 <rtems_fdisk_error> <== NOT EXECUTED
}
107324: 4650 mov r0, sl <== NOT EXECUTED
107326: b013 add sp, #76 ; 0x4c <== NOT EXECUTED
107328: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
unlink (name);
10732c: a80f add r0, sp, #60 ; 0x3c <== NOT EXECUTED
return ret;
10732e: 46a0 mov r8, r4 <== NOT EXECUTED
unlink (name);
107330: f001 fc3a bl 108ba8 <unlink> <== NOT EXECUTED
free (fd->copy_buffer);
107334: 9d06 ldr r5, [sp, #24] <== NOT EXECUTED
return RTEMS_NO_MEMORY;
107336: 46c2 mov sl, r8 <== NOT EXECUTED
free (fd->copy_buffer);
107338: 6fa8 ldr r0, [r5, #120] ; 0x78 <== NOT EXECUTED
10733a: f000 f961 bl 107600 <free> <== NOT EXECUTED
free (fd->blocks);
10733e: 69a8 ldr r0, [r5, #24] <== NOT EXECUTED
107340: f000 f95e bl 107600 <free> <== NOT EXECUTED
free (fd->devices);
107344: 6ae8 ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED
107346: f000 f95b bl 107600 <free> <== NOT EXECUTED
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
10734a: 4620 mov r0, r4 <== NOT EXECUTED
10734c: f012 f98e bl 11966c <strerror> <== NOT EXECUTED
107350: 4601 mov r1, r0 <== NOT EXECUTED
107352: f240 5070 movw r0, #1392 ; 0x570 <== NOT EXECUTED
107356: 4622 mov r2, r4 <== NOT EXECUTED
107358: f2c0 0012 movt r0, #18 <== NOT EXECUTED
10735c: f7fe f9c8 bl 1056f0 <rtems_fdisk_error> <== NOT EXECUTED
return ret;
107360: e7e0 b.n 107324 <rtems_fdisk_initialize+0x2c8> <== NOT EXECUTED
unlink (name);
107362: a80f add r0, sp, #60 ; 0x3c <== NOT EXECUTED
return ret;
107364: 46a0 mov r8, r4 <== NOT EXECUTED
unlink (name);
107366: f001 fc1f bl 108ba8 <unlink> <== NOT EXECUTED
free (fd->copy_buffer);
10736a: 9d06 ldr r5, [sp, #24] <== NOT EXECUTED
return RTEMS_NO_MEMORY;
10736c: 46c2 mov sl, r8 <== NOT EXECUTED
free (fd->copy_buffer);
10736e: 6fa8 ldr r0, [r5, #120] ; 0x78 <== NOT EXECUTED
107370: f000 f946 bl 107600 <free> <== NOT EXECUTED
free (fd->blocks);
107374: 69a8 ldr r0, [r5, #24] <== NOT EXECUTED
107376: f000 f943 bl 107600 <free> <== NOT EXECUTED
free (fd->devices);
10737a: 6ae8 ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED
10737c: f000 f940 bl 107600 <free> <== NOT EXECUTED
rtems_fdisk_error ("compacting of disk failed: %s (%d)",
107380: 4620 mov r0, r4 <== NOT EXECUTED
107382: f012 f973 bl 11966c <strerror> <== NOT EXECUTED
107386: 4601 mov r1, r0 <== NOT EXECUTED
107388: f240 5094 movw r0, #1428 ; 0x594 <== NOT EXECUTED
10738c: 4622 mov r2, r4 <== NOT EXECUTED
10738e: f2c0 0012 movt r0, #18 <== NOT EXECUTED
107392: f7fe f9ad bl 1056f0 <rtems_fdisk_error> <== NOT EXECUTED
return ret;
107396: e7c5 b.n 107324 <rtems_fdisk_initialize+0x2c8> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
107398: f04f 0a1a mov.w sl, #26 <== NOT EXECUTED
10739c: e7a0 b.n 1072e0 <rtems_fdisk_initialize+0x284> <== NOT EXECUTED
unlink (name);
10739e: a80f add r0, sp, #60 ; 0x3c <== NOT EXECUTED
return RTEMS_NO_MEMORY;
1073a0: f04f 081a mov.w r8, #26 <== NOT EXECUTED
unlink (name);
1073a4: f001 fc00 bl 108ba8 <unlink> <== NOT EXECUTED
free (fd->copy_buffer);
1073a8: 9c06 ldr r4, [sp, #24] <== NOT EXECUTED
return RTEMS_NO_MEMORY;
1073aa: 46c2 mov sl, r8 <== NOT EXECUTED
free (fd->copy_buffer);
1073ac: 6fa0 ldr r0, [r4, #120] ; 0x78 <== NOT EXECUTED
1073ae: f000 f927 bl 107600 <free> <== NOT EXECUTED
free (fd->blocks);
1073b2: 69a0 ldr r0, [r4, #24] <== NOT EXECUTED
1073b4: f000 f924 bl 107600 <free> <== NOT EXECUTED
free (fd->devices);
1073b8: 6ae0 ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
1073ba: f000 f921 bl 107600 <free> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
1073be: e7b1 b.n 107324 <rtems_fdisk_initialize+0x2c8> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
1073c0: f04f 081a mov.w r8, #26 <== NOT EXECUTED
1073c4: 46c2 mov sl, r8 <== NOT EXECUTED
1073c6: e7ad b.n 107324 <rtems_fdisk_initialize+0x2c8> <== NOT EXECUTED
1073c8: 0011f744 .word 0x0011f744 <== NOT EXECUTED
00105e00 <rtems_ide_part_table_initialize>:
* RTEMS_NO_MEMOTY if cannot have not enough memory,
* RTEMS_INTERNAL_ERROR if other error occurs.
*/
rtems_status_code
rtems_ide_part_table_initialize(const char *dev_name)
{
105e00: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_part_desc_t *part_desc;
/* logical device name /dev/hdxyy */
char name[RTEMS_IDE_PARTITION_DEV_NAME_LENGTH_MAX];
disk_desc = (rtems_disk_desc_t *) calloc(1, sizeof(rtems_disk_desc_t));
105e04: f44f 718e mov.w r1, #284 ; 0x11c
{
105e08: b085 sub sp, #20
105e0a: 4605 mov r5, r0
disk_desc = (rtems_disk_desc_t *) calloc(1, sizeof(rtems_disk_desc_t));
105e0c: 2001 movs r0, #1
105e0e: f000 f963 bl 1060d8 <calloc>
if (disk_desc == NULL)
105e12: 2800 cmp r0, #0
105e14: d05a beq.n 105ecc <rtems_ide_part_table_initialize+0xcc> <== ALWAYS TAKEN
{
return RTEMS_NO_MEMORY;
}
/* get partition table */
rc = partition_table_get(dev_name, disk_desc);
105e16: 4601 mov r1, r0
105e18: 4606 mov r6, r0
105e1a: 4628 mov r0, r5
105e1c: f7ff fe6a bl 105af4 <partition_table_get>
if (rc != RTEMS_SUCCESSFUL)
105e20: 4681 mov r9, r0
105e22: 2800 cmp r0, #0
105e24: d14b bne.n 105ebe <rtems_ide_part_table_initialize+0xbe> <== ALWAYS TAKEN
free(disk_desc);
return rc;
}
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
105e26: 69f3 ldr r3, [r6, #28]
105e28: 2b00 cmp r3, #0
105e2a: dd2d ble.n 105e88 <rtems_ide_part_table_initialize+0x88> <== ALWAYS TAKEN
{
sprintf(name, "%s%d", dev_name, part_num + 1);
105e2c: f647 48a8 movw r8, #31912 ; 0x7ca8
rc = rtems_blkdev_create_partition(name, dev_name, part_desc->start,
part_desc->size);
if (rc != RTEMS_SUCCESSFUL)
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
105e30: f647 4ab0 movw sl, #31920 ; 0x7cb0
105e34: f106 071c add.w r7, r6, #28
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
105e38: 4604 mov r4, r0
sprintf(name, "%s%d", dev_name, part_num + 1);
105e3a: f2c0 0811 movt r8, #17
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
105e3e: f2c0 0a11 movt sl, #17
105e42: e002 b.n 105e4a <rtems_ide_part_table_initialize+0x4a>
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
105e44: 69f3 ldr r3, [r6, #28]
105e46: 429c cmp r4, r3
105e48: da1e bge.n 105e88 <rtems_ide_part_table_initialize+0x88>
sprintf(name, "%s%d", dev_name, part_num + 1);
105e4a: 3401 adds r4, #1
105e4c: 462a mov r2, r5
105e4e: 4641 mov r1, r8
105e50: 4623 mov r3, r4
105e52: 4668 mov r0, sp
105e54: f00b f99a bl 11118c <sprintf>
part_desc = disk_desc->partitions[part_num];
105e58: f857 2f04 ldr.w r2, [r7, #4]!
rc = rtems_blkdev_create_partition(name, dev_name, part_desc->start,
105e5c: 4629 mov r1, r5
105e5e: 4668 mov r0, sp
if (part_desc == NULL)
105e60: 2a00 cmp r2, #0
105e62: d0ef beq.n 105e44 <rtems_ide_part_table_initialize+0x44>
rc = rtems_blkdev_create_partition(name, dev_name, part_desc->start,
105e64: e9d2 2301 ldrd r2, r3, [r2, #4]
105e68: f7ff fcf2 bl 105850 <rtems_blkdev_create_partition>
if (rc != RTEMS_SUCCESSFUL)
105e6c: 4683 mov fp, r0
105e6e: 2800 cmp r0, #0
105e70: d0e8 beq.n 105e44 <rtems_ide_part_table_initialize+0x44> <== NEVER TAKEN
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
105e72: f7fe fde3 bl 104a3c <__getreent> <== NOT EXECUTED
105e76: 465b mov r3, fp <== NOT EXECUTED
105e78: 6880 ldr r0, [r0, #8] <== NOT EXECUTED
105e7a: 466a mov r2, sp <== NOT EXECUTED
105e7c: 4651 mov r1, sl <== NOT EXECUTED
105e7e: f00a fd03 bl 110888 <fprintf> <== NOT EXECUTED
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
105e82: 69f3 ldr r3, [r6, #28] <== NOT EXECUTED
105e84: 429c cmp r4, r3 <== NOT EXECUTED
105e86: dbe0 blt.n 105e4a <rtems_ide_part_table_initialize+0x4a> <== NOT EXECUTED
105e88: f106 0720 add.w r7, r6, #32
105e8c: f106 0830 add.w r8, r6, #48 ; 0x30
partition_free(disk_desc->partitions[part_num]);
105e90: f857 5b04 ldr.w r5, [r7], #4
if (part_desc == NULL)
105e94: b18d cbz r5, 105eba <rtems_ide_part_table_initialize+0xba>
return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
105e96: 786b ldrb r3, [r5, #1]
if (is_extended(part_desc->sys_type))
105e98: f003 037f and.w r3, r3, #127 ; 0x7f
105e9c: 2b05 cmp r3, #5
105e9e: d109 bne.n 105eb4 <rtems_ide_part_table_initialize+0xb4> <== NEVER TAKEN
105ea0: f105 0418 add.w r4, r5, #24 <== NOT EXECUTED
105ea4: f105 0a28 add.w sl, r5, #40 ; 0x28 <== NOT EXECUTED
partition_free(part_desc->sub_part[part_num]);
105ea8: f854 0b04 ldr.w r0, [r4], #4 <== NOT EXECUTED
105eac: f7ff fec6 bl 105c3c <partition_free> <== NOT EXECUTED
for (part_num = 0;
105eb0: 4554 cmp r4, sl <== NOT EXECUTED
105eb2: d1f9 bne.n 105ea8 <rtems_ide_part_table_initialize+0xa8> <== NOT EXECUTED
free(part_desc);
105eb4: 4628 mov r0, r5
105eb6: f000 f99f bl 1061f8 <free>
for (part_num = 0;
105eba: 4547 cmp r7, r8
105ebc: d1e8 bne.n 105e90 <rtems_ide_part_table_initialize+0x90>
free(disk_desc);
105ebe: 4630 mov r0, r6
105ec0: f000 f99a bl 1061f8 <free>
}
partition_table_free(disk_desc);
return RTEMS_SUCCESSFUL;
}
105ec4: 4648 mov r0, r9
105ec6: b005 add sp, #20
105ec8: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_NO_MEMORY;
105ecc: f04f 091a mov.w r9, #26 <== NOT EXECUTED
105ed0: e7f8 b.n 105ec4 <rtems_ide_part_table_initialize+0xc4> <== NOT EXECUTED
105ed2: bf00 nop
00107cf8 <rtems_nvdisk_initialize>:
*/
rtems_device_driver
rtems_nvdisk_initialize (rtems_device_major_number major RTEMS_UNUSED,
rtems_device_minor_number minor RTEMS_UNUSED,
void* arg RTEMS_UNUSED)
{
107cf8: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
107cfc: f44f 7000 mov.w r0, #512 ; 0x200 <== NOT EXECUTED
{
107d00: b08d sub sp, #52 ; 0x34 <== NOT EXECUTED
rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
107d02: f001 f8cb bl 108e9c <malloc> <== NOT EXECUTED
107d06: f648 7370 movw r3, #36720 ; 0x8f70 <== NOT EXECUTED
107d0a: f2c0 0320 movt r3, #32 <== NOT EXECUTED
107d0e: 6018 str r0, [r3, #0] <== NOT EXECUTED
if (!rtems_nvdisk_crc16_factor)
107d10: 2800 cmp r0, #0 <== NOT EXECUTED
107d12: f000 80b3 beq.w 107e7c <rtems_nvdisk_initialize+0x184> <== NOT EXECUTED
107d16: 1e86 subs r6, r0, #2 <== NOT EXECUTED
for (b = 0; b < 256; b++)
107d18: 2500 movs r5, #0 <== NOT EXECUTED
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
107d1a: f248 4008 movw r0, #33800 ; 0x8408 <== NOT EXECUTED
uint16_t v = b;
107d1e: b2ab uxth r3, r5 <== NOT EXECUTED
for (b = 0; b < 256; b++)
107d20: 2408 movs r4, #8 <== NOT EXECUTED
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
107d22: f003 0201 and.w r2, r3, #1 <== NOT EXECUTED
107d26: 085b lsrs r3, r3, #1 <== NOT EXECUTED
107d28: ea83 0100 eor.w r1, r3, r0 <== NOT EXECUTED
107d2c: b102 cbz r2, 107d30 <rtems_nvdisk_initialize+0x38> <== NOT EXECUTED
107d2e: b28b uxth r3, r1 <== NOT EXECUTED
for (i = 8; i--;)
107d30: 3c01 subs r4, #1 <== NOT EXECUTED
107d32: d1f6 bne.n 107d22 <rtems_nvdisk_initialize+0x2a> <== NOT EXECUTED
for (b = 0; b < 256; b++)
107d34: 3501 adds r5, #1 <== NOT EXECUTED
rtems_nvdisk_crc16_factor[b] = v & 0xffff;
107d36: f826 3f02 strh.w r3, [r6, #2]! <== NOT EXECUTED
for (b = 0; b < 256; b++)
107d3a: f5b5 7f80 cmp.w r5, #256 ; 0x100 <== NOT EXECUTED
107d3e: d1ee bne.n 107d1e <rtems_nvdisk_initialize+0x26> <== NOT EXECUTED
sc = rtems_nvdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
nvd = calloc (rtems_nvdisk_configuration_size, sizeof (*nvd));
107d40: f240 3358 movw r3, #856 ; 0x358 <== NOT EXECUTED
107d44: 2130 movs r1, #48 ; 0x30 <== NOT EXECUTED
107d46: f2c0 0320 movt r3, #32 <== NOT EXECUTED
107d4a: 681d ldr r5, [r3, #0] <== NOT EXECUTED
107d4c: 9305 str r3, [sp, #20] <== NOT EXECUTED
107d4e: 4628 mov r0, r5 <== NOT EXECUTED
107d50: f000 fe02 bl 108958 <calloc> <== NOT EXECUTED
if (!nvd)
107d54: 4681 mov r9, r0 <== NOT EXECUTED
107d56: 2800 cmp r0, #0 <== NOT EXECUTED
107d58: f000 8090 beq.w 107e7c <rtems_nvdisk_initialize+0x184> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
for (i = 0; i < rtems_nvdisk_configuration_size; i++, c++, nvd++)
107d5c: 2d00 cmp r5, #0 <== NOT EXECUTED
107d5e: d07b beq.n 107e58 <rtems_nvdisk_initialize+0x160> <== NOT EXECUTED
107d60: 4b47 ldr r3, [pc, #284] ; (107e80 <rtems_nvdisk_initialize+0x188>) <== NOT EXECUTED
107d62: 9402 str r4, [sp, #8] <== NOT EXECUTED
107d64: 9303 str r3, [sp, #12] <== NOT EXECUTED
107d66: f641 530c movw r3, #7436 ; 0x1d0c <== NOT EXECUTED
107d6a: f2c0 0315 movt r3, #21 <== NOT EXECUTED
107d6e: 9304 str r3, [sp, #16] <== NOT EXECUTED
}
nvd->block_count = blocks;
nvd->device_count = c->device_count;
sc = rtems_blkdev_create(name, c->block_size, blocks,
107d70: f647 1361 movw r3, #31073 ; 0x7961 <== NOT EXECUTED
107d74: f2c0 0310 movt r3, #16 <== NOT EXECUTED
107d78: 9306 str r3, [sp, #24] <== NOT EXECUTED
static __inline void
_Mutex_Initialize_named(struct _Mutex_Control *_mutex, const char *_name)
{
struct _Mutex_Control _init = _MUTEX_NAMED_INITIALIZER(_name);
*_mutex = _init;
107d7a: f641 5304 movw r3, #7428 ; 0x1d04 <== NOT EXECUTED
107d7e: f2c0 0315 movt r3, #21 <== NOT EXECUTED
107d82: 9307 str r3, [sp, #28] <== NOT EXECUTED
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
107d84: 9b04 ldr r3, [sp, #16] <== NOT EXECUTED
107d86: ac09 add r4, sp, #36 ; 0x24 <== NOT EXECUTED
nvd->flags = c->flags;
107d88: 9d03 ldr r5, [sp, #12] <== NOT EXECUTED
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
107d8a: e893 0007 ldmia.w r3, {r0, r1, r2} <== NOT EXECUTED
nvd->flags = c->flags;
107d8e: f855 3c08 ldr.w r3, [r5, #-8] <== NOT EXECUTED
nvd->block_size = c->block_size;
107d92: f855 7c14 ldr.w r7, [r5, #-20] <== NOT EXECUTED
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
107d96: f855 8c10 ldr.w r8, [r5, #-16] <== NOT EXECUTED
nvd->flags = c->flags;
107d9a: f8c9 3000 str.w r3, [r9] <== NOT EXECUTED
nvd->info_level = c->info_level;
107d9e: f855 3c04 ldr.w r3, [r5, #-4] <== NOT EXECUTED
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
107da2: c403 stmia r4!, {r0, r1} <== NOT EXECUTED
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
107da4: 2114 movs r1, #20 <== NOT EXECUTED
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
107da6: 8022 strh r2, [r4, #0] <== NOT EXECUTED
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
107da8: 4640 mov r0, r8 <== NOT EXECUTED
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += i;
107daa: 9a02 ldr r2, [sp, #8] <== NOT EXECUTED
nvd->block_size = c->block_size;
107dac: f8c9 7004 str.w r7, [r9, #4] <== NOT EXECUTED
nvd->info_level = c->info_level;
107db0: f8c9 302c str.w r3, [r9, #44] ; 0x2c <== NOT EXECUTED
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += i;
107db4: f88d 202d strb.w r2, [sp, #45] ; 0x2d <== NOT EXECUTED
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
107db8: f000 fdce bl 108958 <calloc> <== NOT EXECUTED
107dbc: f8c9 000c str.w r0, [r9, #12] <== NOT EXECUTED
if (!nvd->devices)
107dc0: 2800 cmp r0, #0 <== NOT EXECUTED
107dc2: d05b beq.n 107e7c <rtems_nvdisk_initialize+0x184> <== NOT EXECUTED
for (device = 0; device < c->device_count; device++)
107dc4: f1b8 0f00 cmp.w r8, #0 <== NOT EXECUTED
107dc8: d04b beq.n 107e62 <rtems_nvdisk_initialize+0x16a> <== NOT EXECUTED
107dca: f855 ac0c ldr.w sl, [r5, #-12] <== NOT EXECUTED
uint32_t blocks = 0;
107dce: f04f 0b00 mov.w fp, #0 <== NOT EXECUTED
107dd2: 4605 mov r5, r0 <== NOT EXECUTED
for (device = 0; device < c->device_count; device++)
107dd4: 4656 mov r6, sl <== NOT EXECUTED
107dd6: 46ba mov sl, r7 <== NOT EXECUTED
107dd8: 465f mov r7, fp <== NOT EXECUTED
dc->device = device;
107dda: 602f str r7, [r5, #0] <== NOT EXECUTED
return dd->size / nvd->block_size;
107ddc: 4651 mov r1, sl <== NOT EXECUTED
107dde: 68b0 ldr r0, [r6, #8] <== NOT EXECUTED
for (device = 0; device < c->device_count; device++)
107de0: 3701 adds r7, #1 <== NOT EXECUTED
return dd->size / nvd->block_size;
107de2: f033 fe11 bl 13ba08 <__udivsi3> <== NOT EXECUTED
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
107de6: 6068 str r0, [r5, #4] <== NOT EXECUTED
return dd->size / nvd->block_size;
107de8: 4604 mov r4, r0 <== NOT EXECUTED
uint32_t bytes = pages * sizeof (uint16_t);
107dea: 0040 lsls r0, r0, #1 <== NOT EXECUTED
return ((bytes - 1) / nvd->block_size) + 1;
107dec: 4651 mov r1, sl <== NOT EXECUTED
for (device = 0; device < c->device_count; device++)
107dee: 3514 adds r5, #20 <== NOT EXECUTED
return ((bytes - 1) / nvd->block_size) + 1;
107df0: 3801 subs r0, #1 <== NOT EXECUTED
107df2: f033 fe09 bl 13ba08 <__udivsi3> <== NOT EXECUTED
for (device = 0; device < c->device_count; device++)
107df6: 45b8 cmp r8, r7 <== NOT EXECUTED
return ((bytes - 1) / nvd->block_size) + 1;
107df8: f100 0001 add.w r0, r0, #1 <== NOT EXECUTED
blocks += dc->pages - dc->pages_desc;
107dfc: eba4 0400 sub.w r4, r4, r0 <== NOT EXECUTED
dc->block_base = blocks;
107e00: f845 bc08 str.w fp, [r5, #-8] <== NOT EXECUTED
dc->descriptor = &c->devices[device];
107e04: f845 6c04 str.w r6, [r5, #-4] <== NOT EXECUTED
blocks += dc->pages - dc->pages_desc;
107e08: 44a3 add fp, r4 <== NOT EXECUTED
dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
107e0a: f845 0c0c str.w r0, [r5, #-12] <== NOT EXECUTED
for (device = 0; device < c->device_count; device++)
107e0e: f106 0610 add.w r6, r6, #16 <== NOT EXECUTED
107e12: d1e2 bne.n 107dda <rtems_nvdisk_initialize+0xe2> <== NOT EXECUTED
107e14: 4657 mov r7, sl <== NOT EXECUTED
nvd->block_count = blocks;
107e16: f8c9 b008 str.w fp, [r9, #8] <== NOT EXECUTED
sc = rtems_blkdev_create(name, c->block_size, blocks,
107e1a: 465a mov r2, fp <== NOT EXECUTED
nvd->device_count = c->device_count;
107e1c: f8c9 8010 str.w r8, [r9, #16] <== NOT EXECUTED
sc = rtems_blkdev_create(name, c->block_size, blocks,
107e20: 4639 mov r1, r7 <== NOT EXECUTED
107e22: 9b06 ldr r3, [sp, #24] <== NOT EXECUTED
107e24: a809 add r0, sp, #36 ; 0x24 <== NOT EXECUTED
107e26: f8cd 9000 str.w r9, [sp] <== NOT EXECUTED
107e2a: f7ff fc5f bl 1076ec <rtems_blkdev_create> <== NOT EXECUTED
rtems_nvdisk_ioctl, nvd);
if (sc != RTEMS_SUCCESSFUL)
107e2e: b9d0 cbnz r0, 107e66 <rtems_nvdisk_initialize+0x16e> <== NOT EXECUTED
for (i = 0; i < rtems_nvdisk_configuration_size; i++, c++, nvd++)
107e30: 9b05 ldr r3, [sp, #20] <== NOT EXECUTED
107e32: 9907 ldr r1, [sp, #28] <== NOT EXECUTED
107e34: 9a02 ldr r2, [sp, #8] <== NOT EXECUTED
107e36: 681b ldr r3, [r3, #0] <== NOT EXECUTED
107e38: f8c9 1028 str.w r1, [r9, #40] ; 0x28 <== NOT EXECUTED
107e3c: 9903 ldr r1, [sp, #12] <== NOT EXECUTED
107e3e: 3201 adds r2, #1 <== NOT EXECUTED
107e40: 4293 cmp r3, r2 <== NOT EXECUTED
107e42: e9c9 0006 strd r0, r0, [r9, #24] <== NOT EXECUTED
107e46: e9c9 0008 strd r0, r0, [r9, #32] <== NOT EXECUTED
107e4a: f109 0930 add.w r9, r9, #48 ; 0x30 <== NOT EXECUTED
107e4e: f101 0114 add.w r1, r1, #20 <== NOT EXECUTED
107e52: 9202 str r2, [sp, #8] <== NOT EXECUTED
107e54: 9103 str r1, [sp, #12] <== NOT EXECUTED
107e56: d895 bhi.n 107d84 <rtems_nvdisk_initialize+0x8c> <== NOT EXECUTED
}
rtems_mutex_init (&nvd->lock, "NV Disk");
}
return RTEMS_SUCCESSFUL;
107e58: 2500 movs r5, #0 <== NOT EXECUTED
}
107e5a: 4628 mov r0, r5 <== NOT EXECUTED
107e5c: b00d add sp, #52 ; 0x34 <== NOT EXECUTED
107e5e: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
uint32_t blocks = 0;
107e62: 46c3 mov fp, r8 <== NOT EXECUTED
107e64: e7d7 b.n 107e16 <rtems_nvdisk_initialize+0x11e> <== NOT EXECUTED
rtems_nvdisk_error ("disk create phy failed");
107e66: 4605 mov r5, r0 <== NOT EXECUTED
107e68: f641 40ec movw r0, #7404 ; 0x1cec <== NOT EXECUTED
107e6c: f2c0 0015 movt r0, #21 <== NOT EXECUTED
107e70: f7ff fd1c bl 1078ac <rtems_nvdisk_error> <== NOT EXECUTED
}
107e74: 4628 mov r0, r5 <== NOT EXECUTED
107e76: b00d add sp, #52 ; 0x34 <== NOT EXECUTED
107e78: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
return RTEMS_NO_MEMORY;
107e7c: 251a movs r5, #26 <== NOT EXECUTED
107e7e: e7ec b.n 107e5a <rtems_nvdisk_initialize+0x162> <== NOT EXECUTED
107e80: 00151a50 .word 0x00151a50 <== NOT EXECUTED
00105448 <rtems_sparse_disk_create_and_register>:
{
105448: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
10544c: 4615 mov r5, r2
+ key_table_size + data_size;
10544e: f101 0208 add.w r2, r1, #8
{
105452: b084 sub sp, #16
+ key_table_size + data_size;
105454: fb05 f202 mul.w r2, r5, r2
{
105458: 4607 mov r7, r0
10545a: f89d 8028 ldrb.w r8, [sp, #40] ; 0x28
10545e: 460c mov r4, r1
105460: 461e mov r6, r3
rtems_sparse_disk *const sd = (rtems_sparse_disk *) malloc(
105462: f102 002c add.w r0, r2, #44 ; 0x2c
105466: f000 f9fd bl 105864 <malloc>
if ( sparse_disk != NULL ) {
10546a: b180 cbz r0, 10548e <rtems_sparse_disk_create_and_register+0x46>
sc = rtems_sparse_disk_register(
10546c: 4622 mov r2, r4
10546e: f245 14e1 movw r4, #20961 ; 0x51e1
105472: f2c0 0410 movt r4, #16
105476: 4601 mov r1, r0
105478: 462b mov r3, r5
10547a: 4638 mov r0, r7
10547c: f8cd 8004 str.w r8, [sp, #4]
105480: 9600 str r6, [sp, #0]
105482: 9402 str r4, [sp, #8]
105484: f7ff ff8e bl 1053a4 <rtems_sparse_disk_register>
}
105488: b004 add sp, #16
10548a: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
sc = RTEMS_NO_MEMORY;
10548e: 201a movs r0, #26 <== NOT EXECUTED
return sc;
105490: e7fa b.n 105488 <rtems_sparse_disk_create_and_register+0x40> <== NOT EXECUTED
105492: bf00 nop
001053a4 <rtems_sparse_disk_register>:
uint32_t media_block_size,
rtems_blkdev_bnum blocks_with_buffer,
rtems_blkdev_bnum media_block_count,
uint8_t fill_pattern,
rtems_sparse_disk_delete_handler sparse_disk_delete )
{
1053a4: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1053a8: b083 sub sp, #12
1053aa: f8dd 9030 ldr.w r9, [sp, #48] ; 0x30
1053ae: 461f mov r7, r3
1053b0: 9b0e ldr r3, [sp, #56] ; 0x38
rtems_status_code sc;
if ( blocks_with_buffer <= media_block_count ) {
1053b2: 454f cmp r7, r9
{
1053b4: f89d b034 ldrb.w fp, [sp, #52] ; 0x34
sparse_disk_ioctl,
sparse_disk
);
}
} else {
sc = RTEMS_INVALID_NUMBER;
1053b8: bf88 it hi
1053ba: 200a movhi r0, #10
{
1053bc: 9301 str r3, [sp, #4]
if ( blocks_with_buffer <= media_block_count ) {
1053be: d902 bls.n 1053c6 <rtems_sparse_disk_register+0x22> <== NEVER TAKEN
}
return sc;
}
1053c0: b003 add sp, #12 <== NOT EXECUTED
1053c2: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if ( NULL == sd )
1053c6: 460d mov r5, r1
1053c8: 2900 cmp r1, #0
1053ca: d03a beq.n 105442 <rtems_sparse_disk_register+0x9e> <== ALWAYS TAKEN
size_t const key_table_size = blocks_with_buffer
1053cc: ea4f 0ac7 mov.w sl, r7, lsl #3
size_t const data_size = blocks_with_buffer * media_block_size;
1053d0: 4616 mov r6, r2
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
1053d2: 2100 movs r1, #0
1053d4: f10a 042c add.w r4, sl, #44 ; 0x2c
1053d8: 4680 mov r8, r0
1053da: 4622 mov r2, r4
1053dc: 4628 mov r0, r5
memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
1053de: 442c add r4, r5
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
1053e0: f010 f97e bl 1156e0 <memset>
memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
1053e4: fb06 f207 mul.w r2, r6, r7
1053e8: 4659 mov r1, fp
1053ea: 4620 mov r0, r4
sd->fill_pattern = fill_pattern;
1053ec: f885 b024 strb.w fp, [r5, #36] ; 0x24
memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
1053f0: f010 f976 bl 1156e0 <memset>
sd->delete_handler = sparse_disk_delete;
1053f4: 9b01 ldr r3, [sp, #4]
sd->blocks_with_buffer = blocks_with_buffer;
1053f6: 616f str r7, [r5, #20]
sd->delete_handler = sparse_disk_delete;
1053f8: 622b str r3, [r5, #32]
static __inline void
_Mutex_Initialize_named(struct _Mutex_Control *_mutex, const char *_name)
{
struct _Mutex_Control _init = _MUTEX_NAMED_INITIALIZER(_name);
*_mutex = _init;
1053fa: f24c 233c movw r3, #49724 ; 0xc23c
1053fe: f2c0 0311 movt r3, #17
105402: 612b str r3, [r5, #16]
105404: 2300 movs r3, #0
105406: e9c5 3300 strd r3, r3, [r5]
10540a: e9c5 3302 strd r3, r3, [r5, #8]
data += sizeof( rtems_sparse_disk );
10540e: f105 032c add.w r3, r5, #44 ; 0x2c
sd->key_table = (rtems_sparse_disk_key *) data;
105412: 62ab str r3, [r5, #40] ; 0x28
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
105414: b13f cbz r7, 105426 <rtems_sparse_disk_register+0x82>
105416: eb0a 0205 add.w r2, sl, r5
10541a: 462b mov r3, r5
sd->key_table[i].data = data;
10541c: 631c str r4, [r3, #48] ; 0x30
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
10541e: 3308 adds r3, #8
105420: 429a cmp r2, r3
105422: 4434 add r4, r6
105424: d1fa bne.n 10541c <rtems_sparse_disk_register+0x78>
sc = rtems_blkdev_create(
105426: f245 13e5 movw r3, #20965 ; 0x51e5
sd->media_block_size = media_block_size;
10542a: 61ee str r6, [r5, #28]
sc = rtems_blkdev_create(
10542c: 464a mov r2, r9
10542e: f2c0 0310 movt r3, #16
105432: 4640 mov r0, r8
105434: 4631 mov r1, r6
105436: 950c str r5, [sp, #48] ; 0x30
}
105438: b003 add sp, #12
10543a: e8bd 4ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
sc = rtems_blkdev_create(
10543e: f006 bd45 b.w 10becc <rtems_blkdev_create>
return RTEMS_INVALID_ADDRESS;
105442: 2009 movs r0, #9 <== NOT EXECUTED
return sc;
105444: e7bc b.n 1053c0 <rtems_sparse_disk_register+0x1c> <== NOT EXECUTED
105446: bf00 nop