00000000400324b0 <ramdisk_allocate>:
void *area_begin,
uint32_t media_block_size,
rtems_blkdev_bnum media_block_count,
bool trace
)
{
400324b0: a9bc7bfd stp x29, x30, [sp, #-64]!
400324b4: 910003fd mov x29, sp
400324b8: a90153f3 stp x19, x20, [sp, #16]
400324bc: aa0003f4 mov x20, x0
struct ramdisk *rd = calloc(1, sizeof(*rd));
400324c0: d2800020 mov x0, #0x1 // #1
{
400324c4: a9025bf5 stp x21, x22, [sp, #32]
400324c8: 2a0103f6 mov w22, w1
400324cc: 2a0203f5 mov w21, w2
struct ramdisk *rd = calloc(1, sizeof(*rd));
400324d0: d2800301 mov x1, #0x18 // #24
{
400324d4: f9001bf7 str x23, [sp, #48]
400324d8: 12001c77 and w23, w3, #0xff
struct ramdisk *rd = calloc(1, sizeof(*rd));
400324dc: 94000041 bl 400325e0 <calloc>
400324e0: aa0003f3 mov x19, x0
if (rd == NULL) {
400324e4: b40000e0 cbz x0, 40032500 <ramdisk_allocate+0x50> <== NEVER TAKEN
return NULL;
}
if (area_begin == NULL) {
400324e8: b4000194 cbz x20, 40032518 <ramdisk_allocate+0x68>
}
rd->block_size = media_block_size;
rd->block_num = media_block_count;
rd->area = area_begin;
rd->trace = trace;
rd->initialized = true;
400324ec: 52800020 mov w0, #0x1 // #1
rd->block_num = media_block_count;
400324f0: 29005676 stp w22, w21, [x19]
rd->area = area_begin;
400324f4: f9000674 str x20, [x19, #8]
rd->initialized = true;
400324f8: 39004260 strb w0, [x19, #16]
rd->trace = trace;
400324fc: 39004a77 strb w23, [x19, #18]
return rd;
}
40032500: aa1303e0 mov x0, x19
40032504: a94153f3 ldp x19, x20, [sp, #16]
40032508: a9425bf5 ldp x21, x22, [sp, #32]
4003250c: f9401bf7 ldr x23, [sp, #48]
40032510: a8c47bfd ldp x29, x30, [sp], #64
40032514: d65f03c0 ret
area_begin = calloc(media_block_count, media_block_size);
40032518: 2a1603e1 mov w1, w22
4003251c: 2a1503e0 mov w0, w21
40032520: 94000030 bl 400325e0 <calloc>
40032524: aa0003f4 mov x20, x0
if (area_begin == NULL) {
40032528: b4000080 cbz x0, 40032538 <ramdisk_allocate+0x88> <== NEVER TAKEN
rd->malloced = true;
4003252c: 52800020 mov w0, #0x1 // #1
40032530: 39004660 strb w0, [x19, #17]
40032534: 17ffffee b 400324ec <ramdisk_allocate+0x3c>
free(rd);
40032538: aa1303e0 mov x0, x19 <== NOT EXECUTED
return NULL;
4003253c: d2800013 mov x19, #0x0 // #0 <== NOT EXECUTED
free(rd);
40032540: 97ffc09c bl 400227b0 <free> <== NOT EXECUTED
return NULL;
40032544: 17ffffef b 40032500 <ramdisk_allocate+0x50> <== NOT EXECUTED
...
00000000400231d0 <ramdisk_free>:
return rd;
}
void ramdisk_free(ramdisk *rd)
{
if (rd != NULL) {
400231d0: b4000220 cbz x0, 40023214 <ramdisk_free+0x44> <== NEVER TAKEN
{
400231d4: a9be7bfd stp x29, x30, [sp, #-32]!
400231d8: 910003fd mov x29, sp
400231dc: f9000bf3 str x19, [sp, #16]
400231e0: aa0003f3 mov x19, x0
if (rd->malloced) {
400231e4: 39404400 ldrb w0, [x0, #17]
400231e8: 350000a0 cbnz w0, 400231fc <ramdisk_free+0x2c>
free(rd->area);
}
free(rd);
400231ec: aa1303e0 mov x0, x19
} }
400231f0: f9400bf3 ldr x19, [sp, #16]
400231f4: a8c27bfd ldp x29, x30, [sp], #32
free(rd);
400231f8: 140000aa b 400234a0 <free>
free(rd->area);
400231fc: f9400660 ldr x0, [x19, #8]
40023200: 940000a8 bl 400234a0 <free>
free(rd);
40023204: aa1303e0 mov x0, x19
}
40023208: f9400bf3 ldr x19, [sp, #16]
4002320c: a8c27bfd ldp x29, x30, [sp], #32
free(rd);
40023210: 140000a4 b 400234a0 <free>
40023214: d65f03c0 ret <== NOT EXECUTED
...
0000000040022f50 <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)
{
40022f50: a9b97bfd stp x29, x30, [sp, #-112]!
* 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));
40022f54: d2800301 mov x1, #0x18 // #24
{
40022f58: 910003fd mov x29, sp
40022f5c: a90153f3 stp x19, x20, [sp, #16]
40022f60: a9025bf5 stp x21, x22, [sp, #32]
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
40022f64: d00006f6 adrp x22, 40100000 <_IO_Driver_address_table>
40022f68: f94096d4 ldr x20, [x22, #296]
40022f6c: aa1403e0 mov x0, x20
40022f70: 940000c4 bl 40023280 <calloc>
r->trace = false;
40022f74: 3900481f strb wzr, [x0, #18]
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
40022f78: b4000574 cbz x20, 40023024 <ramdisk_initialize+0xd4> <== NEVER TAKEN
rtems_ramdisk_config *c = rtems_ramdisk_configuration;
40022f7c: d00006f4 adrp x20, 40100000 <_IO_Driver_address_table>
40022f80: 91046294 add x20, x20, #0x118
40022f84: aa0003f3 mov x19, x0
40022f88: 9104a2d6 add x22, x22, #0x128
40022f8c: a90363f7 stp x23, x24, [sp, #48]
{
r->malloced = false;
r->initialized = true;
r->area = c->location;
}
rc = rtems_blkdev_create(name, c->block_size, c->block_num,
40022f90: b0000017 adrp x23, 40023000 <ramdisk_initialize+0xb0>
40022f94: 9101c2f7 add x23, x23, #0x70
40022f98: f90023f9 str x25, [sp, #64]
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
40022f9c: d28c85f9 mov x25, #0x642f // #25647
40022fa0: f2aeccb9 movk x25, #0x7665, lsl #16
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
40022fa4: 52800015 mov w21, #0x0 // #0
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
40022fa8: f2ce45f9 movk x25, #0x722f, lsl #32
40022fac: f2ec2c99 movk x25, #0x6164, lsl #48
r->initialized = true;
40022fb0: 52800038 mov w24, #0x1 // #1
40022fb4: d503201f nop
if (c->location == NULL)
40022fb8: f9400683 ldr x3, [x20, #8]
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
40022fbc: f90033f9 str x25, [sp, #96]
r->block_num = c->block_num;
40022fc0: 29400a81 ldp w1, w2, [x20]
name [sizeof(RAMDISK_DEVICE_BASE_NAME) - 1] += i;
40022fc4: 110186a0 add w0, w21, #0x61
r->block_num = c->block_num;
40022fc8: 29000a61 stp w1, w2, [x19]
name [sizeof(RAMDISK_DEVICE_BASE_NAME) - 1] += i;
40022fcc: 39019fe0 strb w0, [sp, #103]
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
40022fd0: 3901a3ff strb wzr, [sp, #104]
if (c->location == NULL)
40022fd4: b4000383 cbz x3, 40023044 <ramdisk_initialize+0xf4>
r->area = c->location;
40022fd8: f9000663 str x3, [x19, #8]
r->initialized = true;
40022fdc: 39004278 strb w24, [x19, #16]
r->malloced = false;
40022fe0: 3900467f strb wzr, [x19, #17]
rc = rtems_blkdev_create(name, c->block_size, c->block_num,
40022fe4: aa1303e4 mov x4, x19
40022fe8: aa1703e3 mov x3, x23
40022fec: 910183e0 add x0, sp, #0x60
40022ff0: 97fffccc bl 40022320 <rtems_blkdev_create>
ramdisk_ioctl, r);
if (rc != RTEMS_SUCCESSFUL)
40022ff4: 34000080 cbz w0, 40023004 <ramdisk_initialize+0xb4> <== ALWAYS TAKEN
{
if (r->malloced)
40022ff8: 39404660 ldrb w0, [x19, #17] <== NOT EXECUTED
40022ffc: 350001e0 cbnz w0, 40023038 <ramdisk_initialize+0xe8> <== NOT EXECUTED
{
free(r->area);
}
r->initialized = false;
40023000: 3900427f strb wzr, [x19, #16] <== NOT EXECUTED
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
40023004: f94002c0 ldr x0, [x22]
40023008: 110006b5 add w21, w21, #0x1
4002300c: 91004294 add x20, x20, #0x10
40023010: 91006273 add x19, x19, #0x18
40023014: eb35401f cmp x0, w21, uxtw
40023018: 54fffd08 b.hi 40022fb8 <ramdisk_initialize+0x68> // b.pmore
4002301c: a94363f7 ldp x23, x24, [sp, #48]
40023020: f94023f9 ldr x25, [sp, #64]
}
}
return RTEMS_SUCCESSFUL;
}
40023024: 52800000 mov w0, #0x0 // #0
40023028: a94153f3 ldp x19, x20, [sp, #16]
4002302c: a9425bf5 ldp x21, x22, [sp, #32]
40023030: a8c77bfd ldp x29, x30, [sp], #112
40023034: d65f03c0 ret
free(r->area);
40023038: f9400660 ldr x0, [x19, #8] <== NOT EXECUTED
4002303c: 94000119 bl 400234a0 <free> <== NOT EXECUTED
40023040: 17fffff0 b 40023000 <ramdisk_initialize+0xb0> <== NOT EXECUTED
r->area = malloc(r->block_size * r->block_num);
40023044: 1b027c20 mul w0, w1, w2
r->malloced = true;
40023048: 39004678 strb w24, [x19, #17]
r->area = malloc(r->block_size * r->block_num);
4002304c: 290b0be1 stp w1, w2, [sp, #88]
40023050: 94000290 bl 40023a90 <malloc>
40023054: f9000660 str x0, [x19, #8]
if (r->area == NULL) /* No enough memory for this disk */
40023058: 294b0be1 ldp w1, w2, [sp, #88]
4002305c: b4fffd20 cbz x0, 40023000 <ramdisk_initialize+0xb0> <== NEVER TAKEN
r->initialized = true;
40023060: 39004278 strb w24, [x19, #16]
40023064: 17ffffe0 b 40022fe4 <ramdisk_initialize+0x94>
...
0000000040023070 <ramdisk_ioctl>:
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
40023070: a9bc7bfd stp x29, x30, [sp, #-64]!
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
40023074: 528840e4 mov w4, #0x4207 // #16903
40023078: 72a40004 movk w4, #0x2000, lsl #16
{
4002307c: 910003fd mov x29, sp
40023080: a9025bf5 stp x21, x22, [sp, #32]
switch (req)
40023084: 6b04003f cmp w1, w4
static inline void *rtems_disk_get_driver_data(
const rtems_disk_device *dd
)
{
return dd->driver_data;
40023088: f9402816 ldr x22, [x0, #80]
4002308c: 540004c0 b.eq 40023124 <ramdisk_ioctl+0xb4> // b.none
40023090: 52884024 mov w4, #0x4201 // #16897
40023094: 72b80504 movk w4, #0xc028, lsl #16
40023098: 6b04003f cmp w1, w4
4002309c: 54000581 b.ne 4002314c <ramdisk_ioctl+0xdc> // b.any
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
400230a0: b9400055 ldr w21, [x2]
400230a4: a90153f3 stp x19, x20, [sp, #16]
400230a8: aa0203f3 mov x19, x2
400230ac: 34000695 cbz w21, 4002317c <ramdisk_ioctl+0x10c>
400230b0: 710006bf cmp w21, #0x1
400230b4: 54000521 b.ne 40023158 <ramdisk_ioctl+0xe8> // b.any <== NEVER TAKEN
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
400230b8: b9401c40 ldr w0, [x2, #28]
400230bc: 9100a054 add x20, x2, #0x28
400230c0: f9001bf7 str x23, [sp, #48]
uint8_t *to = rd->area;
400230c4: f94006d7 ldr x23, [x22, #8]
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
400230c8: 340001a0 cbz w0, 400230fc <ramdisk_ioctl+0x8c> <== NEVER TAKEN
400230cc: 52800015 mov w21, #0x0 // #0
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
400230d0: 29400a80 ldp w0, w2, [x20]
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
400230d4: 110006b5 add w21, w21, #0x1
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
400230d8: b94002c3 ldr w3, [x22]
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
400230dc: 91006294 add x20, x20, #0x18
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
400230e0: f85f0281 ldur x1, [x20, #-16]
400230e4: 1b037c00 mul w0, w0, w3
400230e8: 8b0002e0 add x0, x23, x0
400230ec: 940047a3 bl 40034f78 <memcpy>
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
400230f0: b9401e60 ldr w0, [x19, #28]
400230f4: 6b0002bf cmp w21, w0
400230f8: 54fffec3 b.cc 400230d0 <ramdisk_ioctl+0x60> // b.lo, b.ul, b.last
(*req->done)(req, status);
400230fc: f9400662 ldr x2, [x19, #8]
40023100: aa1303e0 mov x0, x19
40023104: 52800001 mov w1, #0x0 // #0
40023108: d63f0040 blr x2
{
case RTEMS_BLKDEV_REQ_READ:
return ramdisk_read(rd, r);
case RTEMS_BLKDEV_REQ_WRITE:
return ramdisk_write(rd, r);
4002310c: 52800000 mov w0, #0x0 // #0
40023110: a94153f3 ldp x19, x20, [sp, #16]
break;
}
errno = EINVAL;
return -1;
}
40023114: a9425bf5 ldp x21, x22, [sp, #32]
return ramdisk_write(rd, r);
40023118: f9401bf7 ldr x23, [sp, #48]
}
4002311c: a8c47bfd ldp x29, x30, [sp], #64
40023120: d65f03c0 ret
if (rd->free_at_delete_request) {
40023124: 39404ec0 ldrb w0, [x22, #19]
40023128: 350004c0 cbnz w0, 400231c0 <ramdisk_ioctl+0x150>
errno = EINVAL;
4002312c: 940045d8 bl 4003488c <__errno>
40023130: aa0003e1 mov x1, x0
40023134: 528002c2 mov w2, #0x16 // #22
return -1;
40023138: 12800000 mov w0, #0xffffffff // #-1
}
4002313c: a9425bf5 ldp x21, x22, [sp, #32]
errno = EINVAL;
40023140: b9000022 str w2, [x1]
}
40023144: a8c47bfd ldp x29, x30, [sp], #64
40023148: d65f03c0 ret
4002314c: a9425bf5 ldp x21, x22, [sp, #32]
40023150: a8c47bfd ldp x29, x30, [sp], #64
return rtems_blkdev_ioctl (dd, req, argp);
40023154: 14002fd7 b 4002f0b0 <rtems_blkdev_ioctl>
errno = EINVAL;
40023158: 940045cd bl 4003488c <__errno> <== NOT EXECUTED
4002315c: aa0003e1 mov x1, x0 <== NOT EXECUTED
40023160: 528002c2 mov w2, #0x16 // #22 <== NOT EXECUTED
return -1;
40023164: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
40023168: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
errno = EINVAL;
4002316c: b9000022 str w2, [x1] <== NOT EXECUTED
}
40023170: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40023174: a8c47bfd ldp x29, x30, [sp], #64 <== NOT EXECUTED
40023178: d65f03c0 ret <== NOT EXECUTED
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
4002317c: b9401c40 ldr w0, [x2, #28]
40023180: 9100a054 add x20, x2, #0x28
40023184: f9001bf7 str x23, [sp, #48]
uint8_t *from = rd->area;
40023188: f94006d7 ldr x23, [x22, #8]
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
4002318c: 34fffb80 cbz w0, 400230fc <ramdisk_ioctl+0x8c> <== NEVER TAKEN
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
40023190: b9400682 ldr w2, [x20, #4]
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
40023194: 110006b5 add w21, w21, #0x1
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
40023198: b94002c3 ldr w3, [x22]
4002319c: f9400680 ldr x0, [x20, #8]
400231a0: b8418681 ldr w1, [x20], #24
400231a4: 1b037c21 mul w1, w1, w3
400231a8: 8b0102e1 add x1, x23, x1
400231ac: 94004773 bl 40034f78 <memcpy>
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
400231b0: b9401e60 ldr w0, [x19, #28]
400231b4: 6b0002bf cmp w21, w0
400231b8: 54fffec3 b.cc 40023190 <ramdisk_ioctl+0x120> // b.lo, b.ul, b.last <== NEVER TAKEN
400231bc: 17ffffd0 b 400230fc <ramdisk_ioctl+0x8c>
ramdisk_free(rd);
400231c0: aa1603e0 mov x0, x22
400231c4: 94000003 bl 400231d0 <ramdisk_free>
400231c8: 17ffffd9 b 4002312c <ramdisk_ioctl+0xbc>
400231cc: 00000000 udf #0
00000000400224b0 <ramdisk_register>:
uint32_t media_block_size,
rtems_blkdev_bnum media_block_count,
bool trace,
const char *disk
)
{
400224b0: a9bd7bfd stp x29, x30, [sp, #-48]!
400224b4: 910003fd mov x29, sp
400224b8: a9025bf5 stp x21, x22, [sp, #32]
400224bc: 2a0103f5 mov w21, w1
400224c0: aa0303f6 mov x22, x3
rtems_status_code sc = RTEMS_SUCCESSFUL;
ramdisk *rd = NULL;
rd = ramdisk_allocate(NULL, media_block_size, media_block_count, trace);
400224c4: 2a0003e1 mov w1, w0
400224c8: 2a0203e3 mov w3, w2
400224cc: 2a1503e2 mov w2, w21
{
400224d0: a90153f3 stp x19, x20, [sp, #16]
400224d4: 2a0003f4 mov w20, w0
rd = ramdisk_allocate(NULL, media_block_size, media_block_count, trace);
400224d8: d2800000 mov x0, #0x0 // #0
400224dc: 94003ff5 bl 400324b0 <ramdisk_allocate>
if (rd == NULL) {
400224e0: b40001c0 cbz x0, 40022518 <ramdisk_register+0x68> <== NEVER TAKEN
return RTEMS_UNSATISFIED;
}
sc = rtems_blkdev_create(
400224e4: aa0003f3 mov x19, x0
400224e8: 90000083 adrp x3, 40032000 <rtems_blkdev_imfs_write+0xd0>
400224ec: 2a1503e2 mov w2, w21
400224f0: 2a1403e1 mov w1, w20
400224f4: aa1603e0 mov x0, x22
400224f8: aa1303e4 mov x4, x19
400224fc: 910d4063 add x3, x3, #0x350
40022500: 94003f34 bl 400321d0 <rtems_blkdev_create>
media_block_size,
media_block_count,
ramdisk_ioctl,
rd
);
if (sc != RTEMS_SUCCESSFUL) {
40022504: 35000140 cbnz w0, 4002252c <ramdisk_register+0x7c> <== NEVER TAKEN
return RTEMS_UNSATISFIED;
}
return RTEMS_SUCCESSFUL;
}
40022508: a94153f3 ldp x19, x20, [sp, #16]
4002250c: a9425bf5 ldp x21, x22, [sp, #32]
40022510: a8c37bfd ldp x29, x30, [sp], #48
40022514: d65f03c0 ret
return RTEMS_UNSATISFIED;
40022518: 528001a0 mov w0, #0xd // #13 <== NOT EXECUTED
}
4002251c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40022520: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40022524: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
40022528: d65f03c0 ret <== NOT EXECUTED
ramdisk_free(rd);
4002252c: aa1303e0 mov x0, x19 <== NOT EXECUTED
40022530: 94004008 bl 40032550 <ramdisk_free> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
40022534: 528001a0 mov w0, #0xd // #13 <== NOT EXECUTED
40022538: 17fffff4 b 40022508 <ramdisk_register+0x58> <== NOT EXECUTED
4002253c: 00000000 udf #0
000000004002e7c0 <rtems_bdbuf_get>:
{
4002e7c0: a9bd7bfd stp x29, x30, [sp, #-48]!
4002e7c4: 910003fd mov x29, sp
4002e7c8: a90153f3 stp x19, x20, [sp, #16]
4002e7cc: aa0003f3 mov x19, x0
4002e7d0: 2a0103f4 mov w20, w1
4002e7d4: a9025bf5 stp x21, x22, [sp, #32]
4002e7d8: d00006b5 adrp x21, 40104000 <rtems_libio_iops+0x260>
4002e7dc: 910c82b5 add x21, x21, #0x320
4002e7e0: 910122a0 add x0, x21, #0x48
4002e7e4: aa0203f6 mov x22, x2
4002e7e8: 97ffebe6 bl 40029780 <_Mutex_Acquire>
if (block < dd->block_count)
4002e7ec: b9403660 ldr w0, [x19, #52]
4002e7f0: 6b00029f cmp w20, w0
4002e7f4: 54000582 b.cs 4002e8a4 <rtems_bdbuf_get+0xe4> // b.hs, b.nlast <== NEVER TAKEN
4002e7f8: b9403e60 ldr w0, [x19, #60]
if (dd->block_to_media_block_shift >= 0)
4002e7fc: b9402661 ldr w1, [x19, #36]
4002e800: 29458e62 ldp w2, w3, [x19, #44]
4002e804: 37f802c0 tbnz w0, #31, 4002e85c <rtems_bdbuf_get+0x9c> <== NEVER TAKEN
return block << dd->block_to_media_block_shift;
4002e808: 1ac02294 lsl w20, w20, w0
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
4002e80c: aa1303e0 mov x0, x19
4002e810: 0b140021 add w1, w1, w20
4002e814: 97fffeef bl 4002e3d0 <rtems_bdbuf_get_buffer_for_access>
4002e818: aa0003f3 mov x19, x0
switch (bd->state)
4002e81c: b9404000 ldr w0, [x0, #64]
4002e820: 7100081f cmp w0, #0x2
4002e824: 54000300 b.eq 4002e884 <rtems_bdbuf_get+0xc4> // b.none
4002e828: 71001c1f cmp w0, #0x7
4002e82c: 54000341 b.ne 4002e894 <rtems_bdbuf_get+0xd4> // b.any
bd->state = state;
4002e830: 52800080 mov w0, #0x4 // #4
}
4002e834: 52800014 mov w20, #0x0 // #0
bd->state = state;
4002e838: b9004260 str w0, [x19, #64]
_Mutex_Release( mutex );
4002e83c: 910122a0 add x0, x21, #0x48
4002e840: 97ffebec bl 400297f0 <_Mutex_Release>
*bd_ptr = bd;
4002e844: f90002d3 str x19, [x22]
}
4002e848: 2a1403e0 mov w0, w20
4002e84c: a94153f3 ldp x19, x20, [sp, #16]
4002e850: a9425bf5 ldp x21, x22, [sp, #32]
4002e854: a8c37bfd ldp x29, x30, [sp], #48
4002e858: d65f03c0 ret
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
4002e85c: 9ba37e94 umull x20, w20, w3 <== NOT EXECUTED
4002e860: 2a0203e2 mov w2, w2 <== NOT EXECUTED
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
4002e864: aa1303e0 mov x0, x19 <== NOT EXECUTED
return (rtems_blkdev_bnum)
4002e868: 9ac20a94 udiv x20, x20, x2 <== NOT EXECUTED
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
4002e86c: 0b140021 add w1, w1, w20 <== NOT EXECUTED
4002e870: 97fffed8 bl 4002e3d0 <rtems_bdbuf_get_buffer_for_access> <== NOT EXECUTED
4002e874: aa0003f3 mov x19, x0 <== NOT EXECUTED
switch (bd->state)
4002e878: b9404000 ldr w0, [x0, #64] <== NOT EXECUTED
4002e87c: 7100081f cmp w0, #0x2 <== NOT EXECUTED
4002e880: 54fffd41 b.ne 4002e828 <rtems_bdbuf_get+0x68> // b.any <== NOT EXECUTED
bd->state = state;
4002e884: 52800060 mov w0, #0x3 // #3
}
4002e888: 52800014 mov w20, #0x0 // #0
bd->state = state;
4002e88c: b9004260 str w0, [x19, #64]
}
4002e890: 17ffffeb b 4002e83c <rtems_bdbuf_get+0x7c>
switch (bd->state)
4002e894: 7100041f cmp w0, #0x1
4002e898: 540001a0 b.eq 4002e8cc <rtems_bdbuf_get+0x10c> // b.none <== ALWAYS TAKEN
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_2);
4002e89c: 52800141 mov w1, #0xa // #10 <== NOT EXECUTED
4002e8a0: 97fff800 bl 4002c8a0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4002e8a4: 910122a0 add x0, x21, #0x48 <== NOT EXECUTED
rtems_bdbuf_buffer *bd = NULL;
4002e8a8: d2800013 mov x19, #0x0 // #0 <== NOT EXECUTED
4002e8ac: 97ffebd1 bl 400297f0 <_Mutex_Release> <== NOT EXECUTED
*bd_ptr = bd;
4002e8b0: f90002d3 str x19, [x22] <== NOT EXECUTED
sc = RTEMS_INVALID_ID;
4002e8b4: 52800094 mov w20, #0x4 // #4 <== NOT EXECUTED
}
4002e8b8: 2a1403e0 mov w0, w20 <== NOT EXECUTED
4002e8bc: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002e8c0: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002e8c4: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
4002e8c8: d65f03c0 ret <== NOT EXECUTED
bd->state = state;
4002e8cc: 528000a0 mov w0, #0x5 // #5
}
4002e8d0: 52800014 mov w20, #0x0 // #0
bd->state = state;
4002e8d4: b9004260 str w0, [x19, #64]
}
4002e8d8: 17ffffd9 b 4002e83c <rtems_bdbuf_get+0x7c>
4002e8dc: 00000000 udf #0
000000004002e8e0 <rtems_bdbuf_read>:
{
4002e8e0: a9bc7bfd stp x29, x30, [sp, #-64]!
4002e8e4: 910003fd mov x29, sp
4002e8e8: a90153f3 stp x19, x20, [sp, #16]
4002e8ec: aa0003f3 mov x19, x0
4002e8f0: a9025bf5 stp x21, x22, [sp, #32]
_Mutex_Acquire( mutex );
4002e8f4: d00006a0 adrp x0, 40104000 <rtems_libio_iops+0x260>
4002e8f8: 910c8015 add x21, x0, #0x320
4002e8fc: 2a0103f6 mov w22, w1
4002e900: 910122a0 add x0, x21, #0x48
4002e904: a90363f7 stp x23, x24, [sp, #48]
4002e908: aa0203f7 mov x23, x2
4002e90c: 97ffeb9d bl 40029780 <_Mutex_Acquire>
if (block < dd->block_count)
4002e910: b9403660 ldr w0, [x19, #52]
4002e914: 6b0002df cmp w22, w0
4002e918: 54000702 b.cs 4002e9f8 <rtems_bdbuf_read+0x118> // b.hs, b.nlast <== NEVER TAKEN
4002e91c: b9403e60 ldr w0, [x19, #60]
if (dd->block_to_media_block_shift >= 0)
4002e920: b9402661 ldr w1, [x19, #36]
4002e924: 29458e62 ldp w2, w3, [x19, #44]
4002e928: 37f803e0 tbnz w0, #31, 4002e9a4 <rtems_bdbuf_read+0xc4> <== NEVER TAKEN
return block << dd->block_to_media_block_shift;
4002e92c: 1ac022c0 lsl w0, w22, w0
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
4002e930: 0b000021 add w1, w1, w0
4002e934: aa1303e0 mov x0, x19
4002e938: 97fffea6 bl 4002e3d0 <rtems_bdbuf_get_buffer_for_access>
4002e93c: aa0003f4 mov x20, x0
switch (bd->state)
4002e940: b9404000 ldr w0, [x0, #64]
4002e944: 7100081f cmp w0, #0x2
4002e948: 54000420 b.eq 4002e9cc <rtems_bdbuf_read+0xec> // b.none
4002e94c: 71001c1f cmp w0, #0x7
4002e950: 540004c1 b.ne 4002e9e8 <rtems_bdbuf_read+0x108> // b.any
++dd->stats.read_hits;
4002e954: b9405e60 ldr w0, [x19, #92]
bd->state = state;
4002e958: 52800081 mov w1, #0x4 // #4
}
4002e95c: 52800018 mov w24, #0x0 // #0
++dd->stats.read_hits;
4002e960: 11000400 add w0, w0, #0x1
4002e964: b9005e60 str w0, [x19, #92]
bd->state = state;
4002e968: b9004281 str w1, [x20, #64]
if (bdbuf_cache.read_ahead_task != 0
4002e96c: b94182a0 ldr w0, [x21, #384]
4002e970: 34000080 cbz w0, 4002e980 <rtems_bdbuf_read+0xa0>
&& dd->read_ahead.trigger == block
4002e974: b9409261 ldr w1, [x19, #144]
4002e978: 6b0102df cmp w22, w1
4002e97c: 54000820 b.eq 4002ea80 <rtems_bdbuf_read+0x1a0> // b.none
_Mutex_Release( mutex );
4002e980: 910122a0 add x0, x21, #0x48
4002e984: 97ffeb9b bl 400297f0 <_Mutex_Release>
}
4002e988: a9425bf5 ldp x21, x22, [sp, #32]
*bd_ptr = bd;
4002e98c: f90002f4 str x20, [x23]
}
4002e990: 2a1803e0 mov w0, w24
4002e994: a94153f3 ldp x19, x20, [sp, #16]
4002e998: a94363f7 ldp x23, x24, [sp, #48]
4002e99c: a8c47bfd ldp x29, x30, [sp], #64
4002e9a0: d65f03c0 ret
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
4002e9a4: 9ba37ec3 umull x3, w22, w3 <== NOT EXECUTED
4002e9a8: 2a0203e0 mov w0, w2 <== NOT EXECUTED
return (rtems_blkdev_bnum)
4002e9ac: 9ac00860 udiv x0, x3, x0 <== NOT EXECUTED
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
4002e9b0: 0b000021 add w1, w1, w0 <== NOT EXECUTED
4002e9b4: aa1303e0 mov x0, x19 <== NOT EXECUTED
4002e9b8: 97fffe86 bl 4002e3d0 <rtems_bdbuf_get_buffer_for_access> <== NOT EXECUTED
4002e9bc: aa0003f4 mov x20, x0 <== NOT EXECUTED
switch (bd->state)
4002e9c0: b9404000 ldr w0, [x0, #64] <== NOT EXECUTED
4002e9c4: 7100081f cmp w0, #0x2 <== NOT EXECUTED
4002e9c8: 54fffc21 b.ne 4002e94c <rtems_bdbuf_read+0x6c> // b.any <== NOT EXECUTED
++dd->stats.read_hits;
4002e9cc: b9405e60 ldr w0, [x19, #92]
bd->state = state;
4002e9d0: 52800061 mov w1, #0x3 // #3
}
4002e9d4: 52800018 mov w24, #0x0 // #0
++dd->stats.read_hits;
4002e9d8: 11000400 add w0, w0, #0x1
4002e9dc: b9005e60 str w0, [x19, #92]
bd->state = state;
4002e9e0: b9004281 str w1, [x20, #64]
}
4002e9e4: 17ffffe2 b 4002e96c <rtems_bdbuf_read+0x8c>
switch (bd->state)
4002e9e8: 7100041f cmp w0, #0x1
4002e9ec: 540000c0 b.eq 4002ea04 <rtems_bdbuf_read+0x124> // b.none <== ALWAYS TAKEN
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_4);
4002e9f0: 52800161 mov w1, #0xb // #11 <== NOT EXECUTED
4002e9f4: 97fff7ab bl 4002c8a0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
rtems_bdbuf_buffer *bd = NULL;
4002e9f8: d2800014 mov x20, #0x0 // #0 <== NOT EXECUTED
sc = RTEMS_INVALID_ID;
4002e9fc: 52800098 mov w24, #0x4 // #4 <== NOT EXECUTED
4002ea00: 17ffffe0 b 4002e980 <rtems_bdbuf_read+0xa0> <== NOT EXECUTED
++dd->stats.read_misses;
4002ea04: b9406260 ldr w0, [x19, #96]
if (dd->read_ahead.trigger != block)
4002ea08: b9409261 ldr w1, [x19, #144]
++dd->stats.read_misses;
4002ea0c: 11000400 add w0, w0, #0x1
4002ea10: b9006260 str w0, [x19, #96]
if (dd->read_ahead.trigger != block)
4002ea14: 6b0102df cmp w22, w1
4002ea18: 54000140 b.eq 4002ea40 <rtems_bdbuf_read+0x160> // b.none
return node->next == NULL;
4002ea1c: f9404260 ldr x0, [x19, #128]
if (rtems_bdbuf_is_read_ahead_active (dd))
4002ea20: b40000a0 cbz x0, 4002ea34 <rtems_bdbuf_read+0x154> <== ALWAYS TAKEN
previous = the_node->previous;
4002ea24: f9404661 ldr x1, [x19, #136] <== NOT EXECUTED
next->previous = previous;
4002ea28: f9000401 str x1, [x0, #8] <== NOT EXECUTED
previous->next = next;
4002ea2c: f9000020 str x0, [x1] <== NOT EXECUTED
node->next = NULL;
4002ea30: f900427f str xzr, [x19, #128] <== NOT EXECUTED
dd->read_ahead.trigger = block + 1;
4002ea34: 110006c1 add w1, w22, #0x1
dd->read_ahead.next = block + 2;
4002ea38: 11000ac0 add w0, w22, #0x2
4002ea3c: 29120261 stp w1, w0, [x19, #144]
sc = rtems_bdbuf_execute_read_request (dd, bd, 1);
4002ea40: aa1403e1 mov x1, x20
4002ea44: aa1303e0 mov x0, x19
4002ea48: 52800022 mov w2, #0x1 // #1
4002ea4c: 97fffc4d bl 4002db80 <rtems_bdbuf_execute_read_request>
4002ea50: 2a0003f8 mov w24, w0
if (sc == RTEMS_SUCCESSFUL)
4002ea54: 35000320 cbnz w0, 4002eab8 <rtems_bdbuf_read+0x1d8>
previous = the_node->previous;
4002ea58: a9400a83 ldp x3, x2, [x20]
bd->state = state;
4002ea5c: 52800060 mov w0, #0x3 // #3
++bd->group->users;
4002ea60: f9402681 ldr x1, [x20, #72]
bd->state = state;
4002ea64: b9004280 str w0, [x20, #64]
++bd->group->users;
4002ea68: b9401820 ldr w0, [x1, #24]
next->previous = previous;
4002ea6c: f9000462 str x2, [x3, #8]
previous->next = next;
4002ea70: f9000043 str x3, [x2]
4002ea74: 11000400 add w0, w0, #0x1
4002ea78: b9001820 str w0, [x1, #24]
}
4002ea7c: 17ffffbc b 4002e96c <rtems_bdbuf_read+0x8c>
&& !rtems_bdbuf_is_read_ahead_active (dd))
4002ea80: f9404261 ldr x1, [x19, #128]
4002ea84: b5fff7e1 cbnz x1, 4002e980 <rtems_bdbuf_read+0xa0> <== NEVER TAKEN
if (rtems_chain_is_empty (chain))
4002ea88: f940c6a2 ldr x2, [x21, #392]
4002ea8c: 910642a1 add x1, x21, #0x190
4002ea90: eb01005f cmp x2, x1
4002ea94: 54000160 b.eq 4002eac0 <rtems_bdbuf_read+0x1e0> // b.none <== ALWAYS TAKEN
old_last = tail->previous;
4002ea98: f940cea2 ldr x2, [x21, #408]
the_node->next = tail;
4002ea9c: 910642a1 add x1, x21, #0x190
4002eaa0: f9004261 str x1, [x19, #128]
rtems_chain_append_unprotected (chain, &dd->read_ahead.node);
4002eaa4: 91020260 add x0, x19, #0x80
tail->previous = the_node;
4002eaa8: f900cea0 str x0, [x21, #408]
old_last->next = the_node;
4002eaac: f9000040 str x0, [x2]
the_node->previous = old_last;
4002eab0: f9004662 str x2, [x19, #136]
}
4002eab4: 17ffffb3 b 4002e980 <rtems_bdbuf_read+0xa0>
bd = NULL;
4002eab8: d2800014 mov x20, #0x0 // #0
4002eabc: 17ffffac b 4002e96c <rtems_bdbuf_read+0x8c>
sc = rtems_event_send (bdbuf_cache.read_ahead_task,
4002eac0: 52800041 mov w1, #0x2 // #2
4002eac4: 94000573 bl 40030090 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
4002eac8: 34fffe80 cbz w0, 4002ea98 <rtems_bdbuf_read+0x1b8> <== ALWAYS TAKEN
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);
4002eacc: d28000a0 mov x0, #0x5 // #5 <== NOT EXECUTED
4002ead0: 97fff76c bl 4002c880 <rtems_bdbuf_fatal> <== NOT EXECUTED
...
000000004002eae0 <rtems_bdbuf_release>:
if (bd == NULL)
4002eae0: b4000740 cbz x0, 4002ebc8 <rtems_bdbuf_release+0xe8> <== NEVER TAKEN
{
4002eae4: a9be7bfd stp x29, x30, [sp, #-32]!
4002eae8: 910003fd mov x29, sp
4002eaec: a90153f3 stp x19, x20, [sp, #16]
4002eaf0: aa0003f3 mov x19, x0
_Mutex_Acquire( mutex );
4002eaf4: d00006b4 adrp x20, 40104000 <rtems_libio_iops+0x260>
4002eaf8: 910c8294 add x20, x20, #0x320
4002eafc: 91012280 add x0, x20, #0x48
4002eb00: 97ffeb20 bl 40029780 <_Mutex_Acquire>
switch (bd->state)
4002eb04: b9404260 ldr w0, [x19, #64]
4002eb08: 7100101f cmp w0, #0x4
4002eb0c: 54000440 b.eq 4002eb94 <rtems_bdbuf_release+0xb4> // b.none
4002eb10: 54000189 b.ls 4002eb40 <rtems_bdbuf_release+0x60> // b.plast
4002eb14: 51001401 sub w1, w0, #0x5
4002eb18: 7100043f cmp w1, #0x1
4002eb1c: 540005a8 b.hi 4002ebd0 <rtems_bdbuf_release+0xf0> // b.pmore <== NEVER TAKEN
rtems_bdbuf_discard_buffer_after_access (bd);
4002eb20: aa1303e0 mov x0, x19
4002eb24: 97fff8cb bl 4002ce50 <rtems_bdbuf_discard_buffer_after_access>
_Mutex_Release( mutex );
4002eb28: 91012280 add x0, x20, #0x48
4002eb2c: 97ffeb31 bl 400297f0 <_Mutex_Release>
return RTEMS_SUCCESSFUL;
4002eb30: 52800000 mov w0, #0x0 // #0
}
4002eb34: a94153f3 ldp x19, x20, [sp, #16]
4002eb38: a8c27bfd ldp x29, x30, [sp], #32
4002eb3c: d65f03c0 ret
switch (bd->state)
4002eb40: 71000c1f cmp w0, #0x3
4002eb44: 54000461 b.ne 4002ebd0 <rtems_bdbuf_release+0xf0> // b.any <== NEVER TAKEN
--bd->group->users;
4002eb48: f9402663 ldr x3, [x19, #72]
the_node->next = tail;
4002eb4c: 9102a280 add x0, x20, #0xa8
old_last = tail->previous;
4002eb50: f9405a82 ldr x2, [x20, #176]
bd->state = state;
4002eb54: 52800045 mov w5, #0x2 // #2
--bd->group->users;
4002eb58: b9401861 ldr w1, [x3, #24]
if (bd->waiters)
4002eb5c: b9404664 ldr w4, [x19, #68]
--bd->group->users;
4002eb60: 51000421 sub w1, w1, #0x1
4002eb64: b9001861 str w1, [x3, #24]
the_node->next = tail;
4002eb68: f9000260 str x0, [x19]
bd->state = state;
4002eb6c: b9004265 str w5, [x19, #64]
tail->previous = the_node;
4002eb70: f9005a93 str x19, [x20, #176]
old_last->next = the_node;
4002eb74: f9000053 str x19, [x2]
the_node->previous = old_last;
4002eb78: f9000662 str x2, [x19, #8]
if (bd->waiters)
4002eb7c: 340001c4 cbz w4, 4002ebb4 <rtems_bdbuf_release+0xd4>
if (waiters->count > 0)
4002eb80: b940ea80 ldr w0, [x20, #232]
4002eb84: 34fffd20 cbz w0, 4002eb28 <rtems_bdbuf_release+0x48>
_Condition_Broadcast( condition_variable );
4002eb88: 9103c280 add x0, x20, #0xf0
4002eb8c: 94000659 bl 400304f0 <_Condition_Broadcast>
}
4002eb90: 17ffffe6 b 4002eb28 <rtems_bdbuf_release+0x48>
rtems_bdbuf_add_to_modified_list_after_access (bd);
4002eb94: aa1303e0 mov x0, x19
4002eb98: 97fffeba bl 4002e680 <rtems_bdbuf_add_to_modified_list_after_access>
_Mutex_Release( mutex );
4002eb9c: 91012280 add x0, x20, #0x48
4002eba0: 97ffeb14 bl 400297f0 <_Mutex_Release>
return RTEMS_SUCCESSFUL;
4002eba4: 52800000 mov w0, #0x0 // #0
}
4002eba8: a94153f3 ldp x19, x20, [sp, #16]
4002ebac: a8c27bfd ldp x29, x30, [sp], #32
4002ebb0: d65f03c0 ret
if (waiters->count > 0)
4002ebb4: b9413a80 ldr w0, [x20, #312]
4002ebb8: 34fffb80 cbz w0, 4002eb28 <rtems_bdbuf_release+0x48>
_Condition_Broadcast( condition_variable );
4002ebbc: 91050280 add x0, x20, #0x140
4002ebc0: 9400064c bl 400304f0 <_Condition_Broadcast>
}
4002ebc4: 17ffffd9 b 4002eb28 <rtems_bdbuf_release+0x48>
return RTEMS_INVALID_ADDRESS;
4002ebc8: 52800120 mov w0, #0x9 // #9 <== NOT EXECUTED
}
4002ebcc: d65f03c0 ret <== NOT EXECUTED
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_0);
4002ebd0: 52800121 mov w1, #0x9 // #9 <== NOT EXECUTED
4002ebd4: 97fff733 bl 4002c8a0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
...
000000004002ebe0 <rtems_bdbuf_release_modified>:
if (bd == NULL)
4002ebe0: b4000440 cbz x0, 4002ec68 <rtems_bdbuf_release_modified+0x88> <== NEVER TAKEN
{
4002ebe4: a9be7bfd stp x29, x30, [sp, #-32]!
4002ebe8: 910003fd mov x29, sp
4002ebec: a90153f3 stp x19, x20, [sp, #16]
4002ebf0: aa0003f3 mov x19, x0
_Mutex_Acquire( mutex );
4002ebf4: d00006b4 adrp x20, 40104000 <rtems_libio_iops+0x260>
4002ebf8: 910c8294 add x20, x20, #0x320
4002ebfc: 91012280 add x0, x20, #0x48
4002ec00: 97ffeae0 bl 40029780 <_Mutex_Acquire>
switch (bd->state)
4002ec04: b9404260 ldr w0, [x19, #64]
4002ec08: 7100141f cmp w0, #0x5
4002ec0c: 54000169 b.ls 4002ec38 <rtems_bdbuf_release_modified+0x58> // b.plast
4002ec10: 7100181f cmp w0, #0x6
4002ec14: 54000161 b.ne 4002ec40 <rtems_bdbuf_release_modified+0x60> // b.any<== NEVER TAKEN
rtems_bdbuf_discard_buffer_after_access (bd);
4002ec18: aa1303e0 mov x0, x19
4002ec1c: 97fff88d bl 4002ce50 <rtems_bdbuf_discard_buffer_after_access>
_Mutex_Release( mutex );
4002ec20: 91012280 add x0, x20, #0x48
4002ec24: 97ffeaf3 bl 400297f0 <_Mutex_Release>
return RTEMS_SUCCESSFUL;
4002ec28: 52800000 mov w0, #0x0 // #0
}
4002ec2c: a94153f3 ldp x19, x20, [sp, #16]
4002ec30: a8c27bfd ldp x29, x30, [sp], #32
4002ec34: d65f03c0 ret
switch (bd->state)
4002ec38: 7100081f cmp w0, #0x2
4002ec3c: 54000068 b.hi 4002ec48 <rtems_bdbuf_release_modified+0x68> // b.pmore<== ALWAYS TAKEN
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_6);
4002ec40: 528001a1 mov w1, #0xd // #13 <== NOT EXECUTED
4002ec44: 97fff717 bl 4002c8a0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
rtems_bdbuf_add_to_modified_list_after_access (bd);
4002ec48: aa1303e0 mov x0, x19
4002ec4c: 97fffe8d bl 4002e680 <rtems_bdbuf_add_to_modified_list_after_access>
4002ec50: 91012280 add x0, x20, #0x48
4002ec54: 97ffeae7 bl 400297f0 <_Mutex_Release>
return RTEMS_SUCCESSFUL;
4002ec58: 52800000 mov w0, #0x0 // #0
}
4002ec5c: a94153f3 ldp x19, x20, [sp, #16]
4002ec60: a8c27bfd ldp x29, x30, [sp], #32
4002ec64: d65f03c0 ret
return RTEMS_INVALID_ADDRESS;
4002ec68: 52800120 mov w0, #0x9 // #9 <== NOT EXECUTED
}
4002ec6c: d65f03c0 ret <== NOT EXECUTED
000000004002eed0 <rtems_bdbuf_set_block_size>:
{
4002eed0: a9bd7bfd stp x29, x30, [sp, #-48]!
if (sync)
4002eed4: 72001c5f tst w2, #0xff
{
4002eed8: 910003fd mov x29, sp
4002eedc: a90153f3 stp x19, x20, [sp, #16]
4002eee0: 2a0103f4 mov w20, w1
4002eee4: aa0003f3 mov x19, x0
4002eee8: a9025bf5 stp x21, x22, [sp, #32]
if (sync)
4002eeec: 54000801 b.ne 4002efec <rtems_bdbuf_set_block_size+0x11c> // b.any
_Mutex_Acquire( mutex );
4002eef0: d00006b5 adrp x21, 40104000 <rtems_libio_iops+0x260>
4002eef4: 910c82b5 add x21, x21, #0x320
4002eef8: 910122a0 add x0, x21, #0x48
sc = RTEMS_INVALID_NUMBER;
4002eefc: 52800156 mov w22, #0xa // #10
4002ef00: 97ffea20 bl 40029780 <_Mutex_Acquire>
if (block_size > 0)
4002ef04: 35000114 cbnz w20, 4002ef24 <rtems_bdbuf_set_block_size+0x54>
_Mutex_Release( mutex );
4002ef08: 910122a0 add x0, x21, #0x48
4002ef0c: 97ffea39 bl 400297f0 <_Mutex_Release>
}
4002ef10: 2a1603e0 mov w0, w22
4002ef14: a94153f3 ldp x19, x20, [sp, #16]
4002ef18: a9425bf5 ldp x21, x22, [sp, #32]
4002ef1c: a8c37bfd ldp x29, x30, [sp], #48
4002ef20: d65f03c0 ret
if (size > bdbuf_config.buffer_max)
4002ef24: f0000081 adrp x1, 40041000 <__trunctfdf2+0x170>
4002ef28: 91368021 add x1, x1, #0xda0
size_t bds_per_group = rtems_bdbuf_bds_per_group (block_size);
4002ef2c: 2a1403e0 mov w0, w20
if (size > bdbuf_config.buffer_max)
4002ef30: b9403c22 ldr w2, [x1, #60]
4002ef34: eb02001f cmp x0, x2
4002ef38: 54fffe88 b.hi 4002ef08 <rtems_bdbuf_set_block_size+0x38> // b.pmore
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
4002ef3c: b9403821 ldr w1, [x1, #56]
4002ef40: d1000400 sub x0, x0, #0x1
4002ef44: 9ac10801 udiv x1, x0, x1
4002ef48: 91000420 add x0, x1, #0x1
for (bds_per_size = 1;
4002ef4c: b4000581 cbz x1, 4002effc <rtems_bdbuf_set_block_size+0x12c>
4002ef50: d2800022 mov x2, #0x1 // #1
4002ef54: d503201f nop
bds_per_size <<= 1)
4002ef58: 8b020042 add x2, x2, x2
for (bds_per_size = 1;
4002ef5c: eb02001f cmp x0, x2
4002ef60: 54ffffc8 b.hi 4002ef58 <rtems_bdbuf_set_block_size+0x88> // b.pmore
return bdbuf_cache.max_bds_per_group / bds_per_size;
4002ef64: f9401ea0 ldr x0, [x21, #56]
if (bds_per_group != 0)
4002ef68: eb02001f cmp x0, x2
return bdbuf_cache.max_bds_per_group / bds_per_size;
4002ef6c: 9ac20802 udiv x2, x0, x2
if (bds_per_group != 0)
4002ef70: 54000423 b.cc 4002eff4 <rtems_bdbuf_set_block_size+0x124> // b.lo, b.ul, b.last<== NEVER TAKEN
uint32_t media_blocks_per_block = block_size / dd->media_block_size;
4002ef74: b9402e65 ldr w5, [x19, #44]
int block_to_media_block_shift = 0;
4002ef78: 52800003 mov w3, #0x0 // #0
uint32_t media_blocks_per_block = block_size / dd->media_block_size;
4002ef7c: 1ac50a81 udiv w1, w20, w5
while ((one << block_to_media_block_shift) < media_blocks_per_block)
4002ef80: 7100043f cmp w1, #0x1
4002ef84: 54000109 b.ls 4002efa4 <rtems_bdbuf_set_block_size+0xd4> // b.plast
4002ef88: 52800024 mov w4, #0x1 // #1
4002ef8c: d503201f nop
++block_to_media_block_shift;
4002ef90: 11000463 add w3, w3, #0x1
while ((one << block_to_media_block_shift) < media_blocks_per_block)
4002ef94: 1ac32080 lsl w0, w4, w3
4002ef98: 6b01001f cmp w0, w1
4002ef9c: 54ffffa3 b.cc 4002ef90 <rtems_bdbuf_set_block_size+0xc0> // b.lo, b.ul, b.last
if ((dd->media_block_size << block_to_media_block_shift) != block_size)
4002efa0: 1ac320a5 lsl w5, w5, w3
dd->block_count = dd->size / media_blocks_per_block;
4002efa4: b9402a64 ldr w4, [x19, #40]
block_to_media_block_shift = -1;
4002efa8: 6b05029f cmp w20, w5
4002efac: 5a9f0063 csinv w3, w3, wzr, eq // eq = none
dd->block_to_media_block_shift = block_to_media_block_shift;
4002efb0: 29070e61 stp w1, w3, [x19, #56]
dd->block_size = block_size;
4002efb4: b9003274 str w20, [x19, #48]
rtems_bdbuf_do_purge_dev (dd);
4002efb8: aa1303e0 mov x0, x19
dd->bds_per_group = bds_per_group;
4002efbc: f9002262 str x2, [x19, #64]
rtems_status_code sc = RTEMS_SUCCESSFUL;
4002efc0: 52800016 mov w22, #0x0 // #0
dd->block_count = dd->size / media_blocks_per_block;
4002efc4: 1ac10881 udiv w1, w4, w1
4002efc8: b9003661 str w1, [x19, #52]
rtems_bdbuf_do_purge_dev (dd);
4002efcc: 97fff7d1 bl 4002cf10 <rtems_bdbuf_do_purge_dev>
4002efd0: 910122a0 add x0, x21, #0x48
4002efd4: 97ffea07 bl 400297f0 <_Mutex_Release>
}
4002efd8: 2a1603e0 mov w0, w22
4002efdc: a94153f3 ldp x19, x20, [sp, #16]
4002efe0: a9425bf5 ldp x21, x22, [sp, #32]
4002efe4: a8c37bfd ldp x29, x30, [sp], #48
4002efe8: d65f03c0 ret
rtems_bdbuf_syncdev (dd);
4002efec: 97ffff7d bl 4002ede0 <rtems_bdbuf_syncdev>
4002eff0: 17ffffc0 b 4002eef0 <rtems_bdbuf_set_block_size+0x20>
sc = RTEMS_INVALID_NUMBER;
4002eff4: 52800156 mov w22, #0xa // #10 <== NOT EXECUTED
4002eff8: 17ffffc4 b 4002ef08 <rtems_bdbuf_set_block_size+0x38> <== NOT EXECUTED
for (bds_per_size = 1;
4002effc: aa0003e2 mov x2, x0
4002f000: 17ffffd9 b 4002ef64 <rtems_bdbuf_set_block_size+0x94>
...
000000004002ec70 <rtems_bdbuf_sync>:
if (bd == NULL)
4002ec70: b4000920 cbz x0, 4002ed94 <rtems_bdbuf_sync+0x124> <== NEVER TAKEN
{
4002ec74: a9bd7bfd stp x29, x30, [sp, #-48]!
4002ec78: 910003fd mov x29, sp
4002ec7c: a90153f3 stp x19, x20, [sp, #16]
4002ec80: aa0003f3 mov x19, x0
4002ec84: f90013f5 str x21, [sp, #32]
_Mutex_Acquire( mutex );
4002ec88: d00006b5 adrp x21, 40104000 <rtems_libio_iops+0x260>
4002ec8c: 910c82b4 add x20, x21, #0x320
4002ec90: 91012280 add x0, x20, #0x48
4002ec94: 97ffeabb bl 40029780 <_Mutex_Acquire>
switch (bd->state)
4002ec98: b9404260 ldr w0, [x19, #64]
4002ec9c: 7100141f cmp w0, #0x5
4002eca0: 54000189 b.ls 4002ecd0 <rtems_bdbuf_sync+0x60> // b.plast
4002eca4: 7100181f cmp w0, #0x6
4002eca8: 54000181 b.ne 4002ecd8 <rtems_bdbuf_sync+0x68> // b.any <== NEVER TAKEN
rtems_bdbuf_discard_buffer_after_access (bd);
4002ecac: aa1303e0 mov x0, x19
4002ecb0: 97fff868 bl 4002ce50 <rtems_bdbuf_discard_buffer_after_access>
_Mutex_Release( mutex );
4002ecb4: 91012280 add x0, x20, #0x48
4002ecb8: 97ffeace bl 400297f0 <_Mutex_Release>
return RTEMS_SUCCESSFUL;
4002ecbc: 52800000 mov w0, #0x0 // #0
}
4002ecc0: a94153f3 ldp x19, x20, [sp, #16]
4002ecc4: f94013f5 ldr x21, [sp, #32]
4002ecc8: a8c37bfd ldp x29, x30, [sp], #48
4002eccc: d65f03c0 ret
switch (bd->state)
4002ecd0: 7100081f cmp w0, #0x2
4002ecd4: 54000068 b.hi 4002ece0 <rtems_bdbuf_sync+0x70> // b.pmore <== ALWAYS TAKEN
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_5);
4002ecd8: 52800181 mov w1, #0xc // #12 <== NOT EXECUTED
4002ecdc: 97fff6f1 bl 4002c8a0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
old_last = tail->previous;
4002ece0: f9407280 ldr x0, [x20, #224]
bd->state = state;
4002ece4: 52800101 mov w1, #0x8 // #8
the_node->next = tail;
4002ece8: 91036282 add x2, x20, #0xd8
4002ecec: f9000262 str x2, [x19]
4002ecf0: b9004261 str w1, [x19, #64]
if (bd->waiters)
4002ecf4: b9404661 ldr w1, [x19, #68]
tail->previous = the_node;
4002ecf8: f9007293 str x19, [x20, #224]
old_last->next = the_node;
4002ecfc: f9000013 str x19, [x0]
the_node->previous = old_last;
4002ed00: f9000660 str x0, [x19, #8]
4002ed04: 34000061 cbz w1, 4002ed10 <rtems_bdbuf_sync+0xa0>
if (waiters->count > 0)
4002ed08: b940ea80 ldr w0, [x20, #232]
4002ed0c: 350003e0 cbnz w0, 4002ed88 <rtems_bdbuf_sync+0x118>
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
4002ed10: b94322a0 ldr w0, [x21, #800]
4002ed14: 52800081 mov w1, #0x4 // #4
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4002ed18: 91044295 add x21, x20, #0x110
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
4002ed1c: 940004dd bl 40030090 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
4002ed20: 35000560 cbnz w0, 4002edcc <rtems_bdbuf_sync+0x15c> <== NEVER TAKEN
switch (bd->state)
4002ed24: b9404260 ldr w0, [x19, #64]
4002ed28: 71001c1f cmp w0, #0x7
4002ed2c: 54000088 b.hi 4002ed3c <rtems_bdbuf_sync+0xcc> // b.pmore
4002ed30: 35000140 cbnz w0, 4002ed58 <rtems_bdbuf_sync+0xe8> <== ALWAYS TAKEN
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_9);
4002ed34: 52800201 mov w1, #0x10 // #16 <== NOT EXECUTED
4002ed38: 97fff6da bl 4002c8a0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
switch (bd->state)
4002ed3c: 51002001 sub w1, w0, #0x8
4002ed40: 7100083f cmp w1, #0x2
4002ed44: 54ffff88 b.hi 4002ed34 <rtems_bdbuf_sync+0xc4> // b.pmore <== NEVER TAKEN
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4002ed48: aa1503e1 mov x1, x21
4002ed4c: aa1303e0 mov x0, x19
4002ed50: 97fff81c bl 4002cdc0 <rtems_bdbuf_wait>
break;
4002ed54: 17fffff4 b 4002ed24 <rtems_bdbuf_sync+0xb4>
if (bd->waiters == 0
4002ed58: b9404661 ldr w1, [x19, #68]
4002ed5c: 35fffac1 cbnz w1, 4002ecb4 <rtems_bdbuf_sync+0x44>
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
4002ed60: 51000401 sub w1, w0, #0x1
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
4002ed64: 7100043f cmp w1, #0x1
4002ed68: 54fffa68 b.hi 4002ecb4 <rtems_bdbuf_sync+0x44> // b.pmore <== NEVER TAKEN
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
4002ed6c: 7100041f cmp w0, #0x1
4002ed70: 54000160 b.eq 4002ed9c <rtems_bdbuf_sync+0x12c> // b.none
if (waiters->count > 0)
4002ed74: b9413a80 ldr w0, [x20, #312]
4002ed78: 34fff9e0 cbz w0, 4002ecb4 <rtems_bdbuf_sync+0x44>
_Condition_Broadcast( condition_variable );
4002ed7c: 91050280 add x0, x20, #0x140
4002ed80: 940005dc bl 400304f0 <_Condition_Broadcast>
}
4002ed84: 17ffffcc b 4002ecb4 <rtems_bdbuf_sync+0x44>
_Condition_Broadcast( condition_variable );
4002ed88: 9103c280 add x0, x20, #0xf0
4002ed8c: 940005d9 bl 400304f0 <_Condition_Broadcast>
}
4002ed90: 17ffffe0 b 4002ed10 <rtems_bdbuf_sync+0xa0>
return RTEMS_INVALID_ADDRESS;
4002ed94: 52800120 mov w0, #0x9 // #9 <== NOT EXECUTED
}
4002ed98: d65f03c0 ret <== NOT EXECUTED
if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)
4002ed9c: b9403261 ldr w1, [x19, #48]
4002eda0: f9401660 ldr x0, [x19, #40]
4002eda4: 97fff72f bl 4002ca60 <rtems_bdbuf_avl_remove.constprop.0.isra.0>
4002eda8: 35000160 cbnz w0, 4002edd4 <rtems_bdbuf_sync+0x164> <== NEVER TAKEN
before_node = after_node->next;
4002edac: f9405280 ldr x0, [x20, #160]
the_node->previous = after_node;
4002edb0: 91028281 add x1, x20, #0xa0
4002edb4: f9000661 str x1, [x19, #8]
bd->state = state;
4002edb8: b900427f str wzr, [x19, #64]
after_node->next = the_node;
4002edbc: f9005293 str x19, [x20, #160]
the_node->next = before_node;
4002edc0: f9000260 str x0, [x19]
before_node->previous = the_node;
4002edc4: f9000413 str x19, [x0, #8]
}
4002edc8: 17ffffeb b 4002ed74 <rtems_bdbuf_sync+0x104>
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);
4002edcc: d28000e0 mov x0, #0x7 // #7 <== NOT EXECUTED
4002edd0: 97fff6ac bl 4002c880 <rtems_bdbuf_fatal> <== NOT EXECUTED
4002edd4: b9404260 ldr w0, [x19, #64] <== NOT EXECUTED
4002edd8: 97fff7f6 bl 4002cdb0 <rtems_bdbuf_remove_from_tree.part.0.isra.0> <== NOT EXECUTED
4002eddc: 00000000 udf #0
000000004002ede0 <rtems_bdbuf_syncdev>:
{
4002ede0: a9bb7bfd stp x29, x30, [sp, #-80]!
4002ede4: 910003fd mov x29, sp
4002ede8: a90153f3 stp x19, x20, [sp, #16]
4002edec: aa0003f4 mov x20, x0
4002edf0: a9025bf5 stp x21, x22, [sp, #32]
_Mutex_Acquire( mutex );
4002edf4: d00006b5 adrp x21, 40104000 <rtems_libio_iops+0x260>
4002edf8: 910c82b3 add x19, x21, #0x320
4002edfc: 9101a276 add x22, x19, #0x68
4002ee00: f9001bf7 str x23, [sp, #48]
4002ee04: aa1603e0 mov x0, x22
4002ee08: 91012277 add x23, x19, #0x48
4002ee0c: 97ffea5d bl 40029780 <_Mutex_Acquire>
4002ee10: aa1703e0 mov x0, x23
4002ee14: 97ffea5b bl 40029780 <_Mutex_Acquire>
bdbuf_cache.sync_active = true;
4002ee18: 52800020 mov w0, #0x1 // #1
4002ee1c: 39022260 strb w0, [x19, #136]
bdbuf_cache.sync_requester = rtems_task_self ();
4002ee20: 94000568 bl 400303c0 <rtems_task_self>
4002ee24: 2a0003e2 mov w2, w0
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
4002ee28: b94322a0 ldr w0, [x21, #800]
4002ee2c: 52800081 mov w1, #0x4 // #4
bdbuf_cache.sync_requester = rtems_task_self ();
4002ee30: b9008e62 str w2, [x19, #140]
bdbuf_cache.sync_device = dd;
4002ee34: f9004a74 str x20, [x19, #144]
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
4002ee38: 94000496 bl 40030090 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
4002ee3c: 35000220 cbnz w0, 4002ee80 <rtems_bdbuf_syncdev+0xa0> <== NEVER TAKEN
_Mutex_Release( mutex );
4002ee40: aa1703e0 mov x0, x23
4002ee44: 97ffea6b bl 400297f0 <_Mutex_Release>
return rtems_event_system_receive(
4002ee48: 910133e3 add x3, sp, #0x4c
4002ee4c: 52800002 mov w2, #0x0 // #0
4002ee50: 52800001 mov w1, #0x0 // #0
4002ee54: 52b00000 mov w0, #0x80000000 // #-2147483648
4002ee58: 940004de bl 400301d0 <rtems_event_system_receive>
if (sc != RTEMS_SUCCESSFUL)
4002ee5c: 35000160 cbnz w0, 4002ee88 <rtems_bdbuf_syncdev+0xa8> <== NEVER TAKEN
4002ee60: aa1603e0 mov x0, x22
4002ee64: 97ffea63 bl 400297f0 <_Mutex_Release>
}
4002ee68: 52800000 mov w0, #0x0 // #0
4002ee6c: a94153f3 ldp x19, x20, [sp, #16]
4002ee70: a9425bf5 ldp x21, x22, [sp, #32]
4002ee74: f9401bf7 ldr x23, [sp, #48]
4002ee78: a8c57bfd ldp x29, x30, [sp], #80
4002ee7c: d65f03c0 ret
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);
4002ee80: d28000e0 mov x0, #0x7 // #7 <== NOT EXECUTED
4002ee84: 97fff67f bl 4002c880 <rtems_bdbuf_fatal> <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_TRANS_EVNT);
4002ee88: d28002c0 mov x0, #0x16 // #22 <== NOT EXECUTED
4002ee8c: 97fff67d bl 4002c880 <rtems_bdbuf_fatal> <== NOT EXECUTED
0000000040020f90 <rtems_bdpart_create>:
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
40020f90: a9bb7bfd stp x29, x30, [sp, #-80]!
40020f94: aa0003e5 mov x5, x0
40020f98: 910003fd mov x29, sp
40020f9c: a90153f3 stp x19, x20, [sp, #16]
40020fa0: aa0303f3 mov x19, x3
40020fa4: aa0403f4 mov x20, x4
40020fa8: a9025bf5 stp x21, x22, [sp, #32]
40020fac: aa0103f5 mov x21, x1
40020fb0: a90363f7 stp x23, x24, [sp, #48]
40020fb4: aa0203f7 mov x23, x2
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
40020fb8: b4000061 cbz x1, 40020fc4 <rtems_bdpart_create+0x34> <== NEVER TAKEN
&& format->type == RTEMS_BDPART_FORMAT_MBR
40020fbc: b9400020 ldr w0, [x1]
40020fc0: 34000480 cbz w0, 40021050 <rtems_bdpart_create+0xc0> <== ALWAYS TAKEN
&& format->mbr.dos_compatibility;
40020fc4: 52800018 mov w24, #0x0 // #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;
40020fc8: 52800036 mov w22, #0x1 // #1 <== NOT EXECUTED
40020fcc: b9004fff str wzr, [sp, #76]
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
/* Nothing to do */
return RTEMS_SUCCESSFUL;
40020fd0: 52800000 mov w0, #0x0 // #0
if (count == 0) {
40020fd4: b4000354 cbz x20, 4002103c <rtems_bdpart_create+0xac> <== NEVER TAKEN
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
40020fd8: f10002ff cmp x23, #0x0
return RTEMS_INVALID_ADDRESS;
40020fdc: 52800120 mov w0, #0x9 // #9
if (format == NULL || pt == NULL || dist == NULL) {
40020fe0: fa401a64 ccmp x19, #0x0, #0x4, ne // ne = any
40020fe4: fa401aa4 ccmp x21, #0x0, #0x4, ne // ne = any
40020fe8: 540002a0 b.eq 4002103c <rtems_bdpart_create+0xac> // b.none <== NEVER TAKEN
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, NULL, NULL, &disk_end);
40020fec: aa0503e0 mov x0, x5
40020ff0: 910133e3 add x3, sp, #0x4c
40020ff4: d2800002 mov x2, #0x0 // #0
40020ff8: d2800001 mov x1, #0x0 // #0
40020ffc: 94000131 bl 400214c0 <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
40021000: d2800006 mov x6, #0x0 // #0
if (sc != RTEMS_SUCCESSFUL) {
40021004: 340000a0 cbz w0, 40021018 <rtems_bdpart_create+0x88> <== ALWAYS TAKEN
40021008: 1400000d b 4002103c <rtems_bdpart_create+0xac> <== NOT EXECUTED
for (i = 0; i < count; ++i) {
4002100c: eb07029f cmp x20, x7
40021010: 540002c0 b.eq 40021068 <rtems_bdpart_create+0xd8> // b.none
40021014: aa0703e6 mov x6, x7
unsigned prev_sum = dist_sum;
dist_sum += dist [i];
40021018: b8667a65 ldr w5, [x19, x6, lsl #2]
for (i = 0; i < count; ++i) {
4002101c: 910004c7 add x7, x6, #0x1
40021020: 2b0000a1 adds w1, w5, w0
40021024: 1a9f37e0 cset w0, cs // cs = hs, nlast
if (dist_sum < prev_sum) {
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
40021028: 710000bf cmp w5, #0x0
4002102c: 7a401800 ccmp w0, #0x0, #0x0, ne // ne = any
dist_sum += dist [i];
40021030: 2a0103e0 mov w0, w1
if (dist [i] == 0) {
40021034: 54fffec0 b.eq 4002100c <rtems_bdpart_create+0x7c> // b.none <== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
40021038: 52800140 mov w0, #0xa // #10 <== NOT EXECUTED
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
return RTEMS_SUCCESSFUL;
}
4002103c: a94153f3 ldp x19, x20, [sp, #16]
40021040: a9425bf5 ldp x21, x22, [sp, #32]
40021044: a94363f7 ldp x23, x24, [sp, #48]
40021048: a8c57bfd ldp x29, x30, [sp], #80
4002104c: d65f03c0 ret
&& format->mbr.dos_compatibility;
40021050: 39402020 ldrb w0, [x1, #8]
40021054: 528007f6 mov w22, #0x3f // #63
40021058: 7100001f cmp w0, #0x0
4002105c: 1a9f07f8 cset w24, ne // ne = any
40021060: 1a9f16d6 csinc w22, w22, wzr, ne // ne = any
40021064: 17ffffda b 40020fcc <rtems_bdpart_create+0x3c>
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
40021068: b94002a2 ldr w2, [x21]
return RTEMS_NOT_IMPLEMENTED;
4002106c: 52800300 mov w0, #0x18 // #24
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
40021070: 35fffe62 cbnz w2, 4002103c <rtems_bdpart_create+0xac> <== NEVER TAKEN
disk_end -= (disk_end % record_space);
40021074: b9404fec ldr w12, [sp, #76]
overhead += record_space;
40021078: 510004c4 sub w4, w6, #0x1
4002107c: f10010ff cmp x7, #0x4
if (dos_compatibility) {
40021080: 35000518 cbnz w24, 40021120 <rtems_bdpart_create+0x190> <== ALWAYS TAKEN
overhead += record_space;
40021084: 1b167c84 mul w4, w4, w22 <== NOT EXECUTED
40021088: 1a968084 csel w4, w4, w22, hi // hi = pmore <== NOT EXECUTED
if ((overhead + count) > disk_end) {
4002108c: 8b2440e2 add x2, x7, w4, uxtw
return RTEMS_IO_ERROR;
40021090: 52800360 mov w0, #0x1b // #27
if ((overhead + count) > disk_end) {
40021094: eb2c405f cmp x2, w12, uxtw
40021098: 54fffd28 b.hi 4002103c <rtems_bdpart_create+0xac> // b.pmore <== NEVER TAKEN
free_space = disk_end - overhead;
4002109c: 4b040184 sub w4, w12, w4
for (i = 0; i < count; ++i) {
400210a0: aa1703e8 mov x8, x23
pos = record_space;
400210a4: 2a1603e0 mov w0, w22
for (i = 0; i < count; ++i) {
400210a8: d2800002 mov x2, #0x0 // #0
400210ac: 14000012 b 400210f4 <rtems_bdpart_create+0x164>
if (s == 0) {
400210b0: 6b01007f cmp w3, w1
400210b4: 54000043 b.cc 400210bc <rtems_bdpart_create+0x12c> // b.lo, b.ul, b.last<== NEVER TAKEN
s /= dist_sum;
400210b8: 1ac10865 udiv w5, w3, w1
if (count > 4 && i > 2) {
400210bc: f10010ff cmp x7, #0x4
400210c0: 0b1600a9 add w9, w5, w22
s += record_space - (s % record_space);
400210c4: 1ad608a3 udiv w3, w5, w22
pos += record_space;
400210c8: fa428840 ccmp x2, #0x2, #0x0, hi // hi = pmore
400210cc: 1a808160 csel w0, w11, w0, hi // hi = pmore
p->begin = pos;
400210d0: b9000100 str w0, [x8]
for (i = 0; i < count; ++i) {
400210d4: eb0200df cmp x6, x2
400210d8: 9100c108 add x8, x8, #0x30
400210dc: aa0a03e2 mov x2, x10
s += record_space - (s % record_space);
400210e0: 1b169465 msub w5, w3, w22, w5
if (count > 4 && i > 2) {
400210e4: 4b050000 sub w0, w0, w5
pos += s;
400210e8: 0b000120 add w0, w9, w0
p->end = pos;
400210ec: b81d4100 stur w0, [x8, #-44]
for (i = 0; i < count; ++i) {
400210f0: 54000260 b.eq 4002113c <rtems_bdpart_create+0x1ac> // b.none
rtems_blkdev_bnum s = free_space * dist [i];
400210f4: b8627a63 ldr w3, [x19, x2, lsl #2]
pos += record_space;
400210f8: 0b16000b add w11, w0, w22
for (i = 0; i < count; ++i) {
400210fc: 9100044a add x10, x2, #0x1
s = 1;
40021100: 52800025 mov w5, #0x1 // #1
if (s < free_space || s < dist [i]) {
40021104: 6b04007f cmp w3, w4
40021108: 1a842069 csel w9, w3, w4, cs // cs = hs, nlast
rtems_blkdev_bnum s = free_space * dist [i];
4002110c: 1b047c63 mul w3, w3, w4
if (s < free_space || s < dist [i]) {
40021110: 6b09007f cmp w3, w9
40021114: 54fffce2 b.cs 400210b0 <rtems_bdpart_create+0x120> // b.hs, b.nlast<== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
40021118: 52800140 mov w0, #0xa // #10 <== NOT EXECUTED
4002111c: 17ffffc8 b 4002103c <rtems_bdpart_create+0xac> <== NOT EXECUTED
disk_end -= (disk_end % record_space);
40021120: 1ad60980 udiv w0, w12, w22
overhead += record_space;
40021124: 1b167c84 mul w4, w4, w22
40021128: 1a968084 csel w4, w4, w22, hi // hi = pmore
disk_end -= (disk_end % record_space);
4002112c: 1b16b000 msub w0, w0, w22, w12
overhead += (count - 1) * record_space;
40021130: 1b0612c4 madd w4, w22, w6, w4
disk_end -= (disk_end % record_space);
40021134: 4b00018c sub w12, w12, w0
overhead += (count - 1) * record_space;
40021138: 17ffffd5 b 4002108c <rtems_bdpart_create+0xfc>
pt [count - 1].end = disk_end;
4002113c: d2800601 mov x1, #0x30 // #48
return RTEMS_SUCCESSFUL;
40021140: 52800000 mov w0, #0x0 // #0
pt [count - 1].end = disk_end;
40021144: 9b015ce7 madd x7, x7, x1, x23
40021148: b81d40ec stur w12, [x7, #-44]
return RTEMS_SUCCESSFUL;
4002114c: 17ffffbc b 4002103c <rtems_bdpart_create+0xac>
0000000040021150 <rtems_bdpart_dump>:
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
40021150: a9b87bfd stp x29, x30, [sp, #-128]!
40021154: 910003fd mov x29, sp
40021158: a90153f3 stp x19, x20, [sp, #16]
4002115c: aa0103f4 mov x20, x1
40021160: a90363f7 stp x23, x24, [sp, #48]
40021164: aa0003f8 mov x24, x0
size_t i = 0;
printf(
40021168: b0000100 adrp x0, 40042000 <test_state_strings+0x50>
4002116c: 91008000 add x0, x0, #0x20
40021170: 97ffff84 bl 40020f80 <__wrap_puts>
"------------+------------+-----------------------------------------------------\n"
" BEGIN | LAST | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
40021174: b4000614 cbz x20, 40021234 <rtems_bdpart_dump+0xe4> <== NEVER TAKEN
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
40021178: 90000117 adrp x23, 40041000 <__trunctfdf2+0x170>
4002117c: 913f82f7 add x23, x23, #0xfe0
40021180: 91002318 add x24, x24, #0x8
for (i = 0; i < count; ++i) {
40021184: d2800013 mov x19, #0x0 // #0
40021188: a9025bf5 stp x21, x22, [sp, #32]
4002118c: b0000115 adrp x21, 40042000 <test_state_strings+0x50>
40021190: 9105c2b5 add x21, x21, #0x170
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40021194: b0000116 adrp x22, 40042000 <test_state_strings+0x50>
40021198: 910582d6 add x22, x22, #0x160
4002119c: 14000013 b 400211e8 <rtems_bdpart_dump+0x98>
switch (type_mbr) {
400211a0: 39411fe1 ldrb w1, [sp, #71]
400211a4: 7100303f cmp w1, #0xc
400211a8: 54000820 b.eq 400212ac <rtems_bdpart_dump+0x15c> // b.none <== NEVER TAKEN
400211ac: 54000668 b.hi 40021278 <rtems_bdpart_dump+0x128> // b.pmore <== NEVER TAKEN
400211b0: 7100103f cmp w1, #0x4
400211b4: 54000760 b.eq 400212a0 <rtems_bdpart_dump+0x150> // b.none <== NEVER TAKEN
type = "FAT 32";
400211b8: b0000100 adrp x0, 40042000 <test_state_strings+0x50>
400211bc: 91002003 add x3, x0, #0x8
switch (type_mbr) {
400211c0: 71002c3f cmp w1, #0xb
400211c4: 54000441 b.ne 4002124c <rtems_bdpart_dump+0xfc> // b.any <== NEVER TAKEN
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
400211c8: 297f0b01 ldp w1, w2, [x24, #-8]
for (i = 0; i < count; ++i) {
400211cc: 91000673 add x19, x19, #0x1
printf(
400211d0: aa1503e0 mov x0, x21
for (i = 0; i < count; ++i) {
400211d4: 9100c318 add x24, x24, #0x30
printf(
400211d8: 51000442 sub w2, w2, #0x1
400211dc: 97ffff45 bl 40020ef0 <__wrap_printf>
for (i = 0; i < count; ++i) {
400211e0: eb13029f cmp x20, x19
400211e4: 54000260 b.eq 40021230 <rtems_bdpart_dump+0xe0> // b.none
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
400211e8: 91011fe1 add x1, sp, #0x47
400211ec: aa1803e0 mov x0, x24
uint8_t type_mbr = 0;
400211f0: 39011fff strb wzr, [sp, #71]
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
400211f4: 940000a3 bl 40021480 <rtems_bdpart_to_mbr_partition_type>
400211f8: 72001c1f tst w0, #0xff
400211fc: 54fffd21 b.ne 400211a0 <rtems_bdpart_dump+0x50> // b.any <== ALWAYS TAKEN
uuid_unparse_lower( type, str);
40021200: aa1803e0 mov x0, x24 <== NOT EXECUTED
40021204: 910123e1 add x1, sp, #0x48 <== NOT EXECUTED
40021208: 940019aa bl 400278b0 <uuid_unparse_lower> <== NOT EXECUTED
for (i = 0; i < count; ++i) {
4002120c: 91000673 add x19, x19, #0x1 <== NOT EXECUTED
printf(
40021210: 297f0b01 ldp w1, w2, [x24, #-8] <== NOT EXECUTED
type = type_buffer;
40021214: 910123e3 add x3, sp, #0x48 <== NOT EXECUTED
printf(
40021218: aa1503e0 mov x0, x21 <== NOT EXECUTED
for (i = 0; i < count; ++i) {
4002121c: 9100c318 add x24, x24, #0x30 <== NOT EXECUTED
printf(
40021220: 51000442 sub w2, w2, #0x1 <== NOT EXECUTED
40021224: 97ffff33 bl 40020ef0 <__wrap_printf> <== NOT EXECUTED
for (i = 0; i < count; ++i) {
40021228: eb13029f cmp x20, x19 <== NOT EXECUTED
4002122c: 54fffde1 b.ne 400211e8 <rtems_bdpart_dump+0x98> // b.any <== NOT EXECUTED
40021230: a9425bf5 ldp x21, x22, [sp, #32]
p->end - 1U,
type
);
}
puts( "------------+------------+-----------------------------------------------------");
40021234: b0000100 adrp x0, 40042000 <test_state_strings+0x50>
40021238: 91044000 add x0, x0, #0x110
}
4002123c: a94153f3 ldp x19, x20, [sp, #16]
40021240: a94363f7 ldp x23, x24, [sp, #48]
40021244: a8c87bfd ldp x29, x30, [sp], #128
puts( "------------+------------+-----------------------------------------------------");
40021248: 17ffff4e b 40020f80 <__wrap_puts>
type = "FAT 12";
4002124c: 90000100 adrp x0, 40041000 <__trunctfdf2+0x170> <== NOT EXECUTED
40021250: 913fc003 add x3, x0, #0xff0 <== NOT EXECUTED
switch (type_mbr) {
40021254: 7100043f cmp w1, #0x1 <== NOT EXECUTED
40021258: 54fffb80 b.eq 400211c8 <rtems_bdpart_dump+0x78> // b.none <== NOT EXECUTED
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
4002125c: 2a0103e3 mov w3, w1 <== NOT EXECUTED
40021260: aa1603e2 mov x2, x22 <== NOT EXECUTED
40021264: 910123e0 add x0, sp, #0x48 <== NOT EXECUTED
40021268: d2800681 mov x1, #0x34 // #52 <== NOT EXECUTED
4002126c: 94004fd9 bl 400351d0 <snprintf> <== NOT EXECUTED
type = type_buffer;
40021270: 910123e3 add x3, sp, #0x48 <== NOT EXECUTED
break;
40021274: 17ffffd5 b 400211c8 <rtems_bdpart_dump+0x78> <== NOT EXECUTED
switch (type_mbr) {
40021278: 7100383f cmp w1, #0xe <== NOT EXECUTED
4002127c: 540000c0 b.eq 40021294 <rtems_bdpart_dump+0x144> // b.none <== NOT EXECUTED
40021280: 7103683f cmp w1, #0xda <== NOT EXECUTED
40021284: 54fffec1 b.ne 4002125c <rtems_bdpart_dump+0x10c> // b.any <== NOT EXECUTED
type = "DATA";
40021288: b0000103 adrp x3, 40042000 <test_state_strings+0x50> <== NOT EXECUTED
4002128c: 91006063 add x3, x3, #0x18 <== NOT EXECUTED
40021290: 17ffffce b 400211c8 <rtems_bdpart_dump+0x78> <== NOT EXECUTED
type = "FAT 16 LBA";
40021294: 90000103 adrp x3, 40041000 <__trunctfdf2+0x170> <== NOT EXECUTED
40021298: 913fe063 add x3, x3, #0xff8 <== NOT EXECUTED
4002129c: 17ffffcb b 400211c8 <rtems_bdpart_dump+0x78> <== NOT EXECUTED
switch (type_mbr) {
400212a0: b0000103 adrp x3, 40042000 <test_state_strings+0x50> <== NOT EXECUTED
400212a4: 91004063 add x3, x3, #0x10 <== NOT EXECUTED
400212a8: 17ffffc8 b 400211c8 <rtems_bdpart_dump+0x78> <== NOT EXECUTED
type = "FAT 32 LBA";
400212ac: aa1703e3 mov x3, x23 <== NOT EXECUTED
400212b0: 17ffffc6 b 400211c8 <rtems_bdpart_dump+0x78> <== NOT EXECUTED
...
00000000400214c0 <rtems_bdpart_get_disk_data>:
{
400214c0: a9bb7bfd stp x29, x30, [sp, #-80]!
400214c4: 910003fd mov x29, sp
400214c8: a90153f3 stp x19, x20, [sp, #16]
400214cc: aa0303f4 mov x20, x3
400214d0: a9025bf5 stp x21, x22, [sp, #32]
400214d4: aa0203f6 mov x22, x2
sc = RTEMS_INVALID_NAME;
400214d8: 52800075 mov w21, #0x3 // #3
{
400214dc: f9001bf7 str x23, [sp, #48]
400214e0: aa0103f7 mov x23, x1
fd = open( disk_name, O_RDWR);
400214e4: 52800041 mov w1, #0x2 // #2
rtems_disk_device *dd = NULL;
400214e8: f90027ff str xzr, [sp, #72]
fd = open( disk_name, O_RDWR);
400214ec: 94000b71 bl 400242b0 <open>
if (fd < 0) {
400214f0: 37f80220 tbnz w0, #31, 40021534 <rtems_bdpart_get_disk_data+0x74> <== NEVER TAKEN
400214f4: d2884121 mov x1, #0x4209 // #16905
400214f8: f2a80101 movk x1, #0x4008, lsl #16
400214fc: 2a0003f3 mov w19, w0
40021500: 910123e2 add x2, sp, #0x48
40021504: 9400087f bl 40023700 <ioctl>
if (rv != 0) {
40021508: 35000220 cbnz w0, 4002154c <rtems_bdpart_get_disk_data+0x8c> <== NEVER TAKEN
disk_begin = dd->start;
4002150c: f94027e0 ldr x0, [sp, #72]
sc = RTEMS_IO_ERROR;
40021510: 52800375 mov w21, #0x1b // #27
*disk_end = dd->size;
40021514: 29448801 ldp w1, w2, [x0, #36]
40021518: b9000282 str w2, [x20]
if (disk_begin != 0) {
4002151c: b9403002 ldr w2, [x0, #48]
40021520: 7107fc5f cmp w2, #0x1ff
40021524: 7a408820 ccmp w1, #0x0, #0x0, hi // hi = pmore
40021528: 54000160 b.eq 40021554 <rtems_bdpart_get_disk_data+0x94> // b.none <== ALWAYS TAKEN
close( fd);
4002152c: 2a1303e0 mov w0, w19
40021530: 94000764 bl 400232c0 <close>
}
40021534: 2a1503e0 mov w0, w21
40021538: a94153f3 ldp x19, x20, [sp, #16]
4002153c: a9425bf5 ldp x21, x22, [sp, #32]
40021540: f9401bf7 ldr x23, [sp, #48]
40021544: a8c57bfd ldp x29, x30, [sp], #80
40021548: d65f03c0 ret
sc = RTEMS_INVALID_NAME;
4002154c: 52800075 mov w21, #0x3 // #3 <== NOT EXECUTED
40021550: 17fffff7 b 4002152c <rtems_bdpart_get_disk_data+0x6c> <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
40021554: f10002ff cmp x23, #0x0
40021558: fa401ac4 ccmp x22, #0x0, #0x4, ne // ne = any
4002155c: 54000140 b.eq 40021584 <rtems_bdpart_get_disk_data+0xc4> // b.none
*fd_ptr = fd;
40021560: b90002f3 str w19, [x23]
*dd_ptr = dd;
40021564: 52800015 mov w21, #0x0 // #0
40021568: f90002c0 str x0, [x22]
}
4002156c: 2a1503e0 mov w0, w21
40021570: a94153f3 ldp x19, x20, [sp, #16]
40021574: a9425bf5 ldp x21, x22, [sp, #32]
40021578: f9401bf7 ldr x23, [sp, #48]
4002157c: a8c57bfd ldp x29, x30, [sp], #80
40021580: d65f03c0 ret
rtems_status_code sc = RTEMS_SUCCESSFUL;
40021584: 52800015 mov w21, #0x0 // #0
40021588: 17ffffe9 b 4002152c <rtems_bdpart_get_disk_data+0x6c>
4002158c: 00000000 udf #0
0000000040021590 <rtems_bdpart_read>:
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
40021590: a9b87bfd stp x29, x30, [sp, #-128]!
40021594: 910003fd mov x29, sp
40021598: a90153f3 stp x19, x20, [sp, #16]
4002159c: a9025bf5 stp x21, x22, [sp, #32]
400215a0: aa0203f6 mov x22, x2
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_status_code esc = RTEMS_SUCCESSFUL; rtems_bdbuf_buffer *block = NULL; rtems_bdpart_partition *p = pt - 1;
400215a4: d100c042 sub x2, x2, #0x30
400215a8: a9068bff stp xzr, x2, [sp, #104]
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
400215ac: b4000563 cbz x3, 40021658 <rtems_bdpart_read+0xc8> <== NEVER TAKEN
400215b0: aa0103f5 mov x21, x1
rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */ rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */ rtems_blkdev_bnum disk_end = 0; size_t i = 0; const uint8_t *data = NULL; int fd = -1;
400215b4: 12800001 mov w1, #0xffffffff // #-1
400215b8: a90363f7 stp x23, x24, [sp, #48]
rtems_disk_device *dd = NULL;
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
400215bc: f10002bf cmp x21, #0x0
400215c0: aa0303f4 mov x20, x3
rtems_blkdev_bnum disk_end = 0;
400215c4: 290bffff stp wzr, wzr, [sp, #92]
if (format == NULL || pt == NULL || count == NULL) {
400215c8: fa401ac4 ccmp x22, #0x0, #0x4, ne // ne = any
int fd = -1;
400215cc: b90067e1 str w1, [sp, #100]
rtems_disk_device *dd = NULL;
400215d0: f9003fff str xzr, [sp, #120]
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
400215d4: f9400077 ldr x23, [x3]
if (format == NULL || pt == NULL || count == NULL) {
400215d8: 540003e0 b.eq 40021654 <rtems_bdpart_read+0xc4> // b.none <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
}
/* Set count to a save value */
*count = 0;
400215dc: f900029f str xzr, [x20]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
400215e0: 910183e3 add x3, sp, #0x60
400215e4: 9101e3e2 add x2, sp, #0x78
400215e8: 910193e1 add x1, sp, #0x64
400215ec: 97ffffb5 bl 400214c0 <rtems_bdpart_get_disk_data>
400215f0: 2a0003f3 mov w19, w0
if (sc != RTEMS_SUCCESSFUL) {
400215f4: 340000e0 cbz w0, 40021610 <rtems_bdpart_read+0x80> <== ALWAYS TAKEN
if (block != NULL) {
rtems_bdbuf_release( block);
}
return esc;
}
400215f8: 2a1303e0 mov w0, w19 <== NOT EXECUTED
400215fc: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40021600: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40021604: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40021608: a8c87bfd ldp x29, x30, [sp], #128 <== NOT EXECUTED
4002160c: d65f03c0 ret <== NOT EXECUTED
sc = rtems_bdpart_read_record( dd, 0, &block);
40021610: f9403fe0 ldr x0, [sp, #120]
40021614: 9101a3e2 add x2, sp, #0x68
40021618: 52800001 mov w1, #0x0 // #0
4002161c: 97ffff6d bl 400213d0 <rtems_bdpart_read_record>
40021620: 2a0003f3 mov w19, w0
if (sc != RTEMS_SUCCESSFUL) {
40021624: 34000260 cbz w0, 40021670 <rtems_bdpart_read+0xe0> <== ALWAYS TAKEN
if (fd >= 0) {
40021628: b94067e1 ldr w1, [sp, #100]
4002162c: 36f80e21 tbz w1, #31, 400217f0 <rtems_bdpart_read+0x260> <== ALWAYS TAKEN
if (block != NULL) {
40021630: f94037e0 ldr x0, [sp, #104] <== NOT EXECUTED
40021634: b4fffe20 cbz x0, 400215f8 <rtems_bdpart_read+0x68> <== NOT EXECUTED
rtems_bdbuf_release( block);
40021638: 9400352a bl 4002eae0 <rtems_bdbuf_release>
}
4002163c: 2a1303e0 mov w0, w19
40021640: a94153f3 ldp x19, x20, [sp, #16]
40021644: a9425bf5 ldp x21, x22, [sp, #32]
40021648: a94363f7 ldp x23, x24, [sp, #48]
4002164c: a8c87bfd ldp x29, x30, [sp], #128
40021650: d65f03c0 ret
40021654: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
40021658: 52800133 mov w19, #0x9 // #9 <== NOT EXECUTED
}
4002165c: 2a1303e0 mov w0, w19 <== NOT EXECUTED
40021660: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40021664: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40021668: a8c87bfd ldp x29, x30, [sp], #128 <== NOT EXECUTED
4002166c: d65f03c0 ret <== NOT EXECUTED
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
40021670: f94037e0 ldr x0, [sp, #104]
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
40021674: d2800601 mov x1, #0x30 // #48
40021678: f90023f9 str x25, [sp, #64]
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
4002167c: 910173e3 add x3, sp, #0x5c
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
40021680: 9b015af7 madd x23, x23, x1, x22
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
40021684: 9101c3e1 add x1, sp, #0x70
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
40021688: f9401c19 ldr x25, [x0, #56]
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
4002168c: aa1703e2 mov x2, x23
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
40021690: 9106fb38 add x24, x25, #0x1be
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
40021694: aa1803e0 mov x0, x24
40021698: 97ffff0a bl 400212c0 <rtems_bdpart_read_mbr_partition>
4002169c: 2a0003f3 mov w19, w0
if (sc != RTEMS_SUCCESSFUL) {
400216a0: 35000b20 cbnz w0, 40021804 <rtems_bdpart_read+0x274> <== NEVER TAKEN
400216a4: f9403be0 ldr x0, [sp, #112]
if (rtems_bdpart_mbr_partition_type( p->type) == RTEMS_BDPART_MBR_GPT) {
400216a8: 39402000 ldrb w0, [x0, #8]
400216ac: 7103b81f cmp w0, #0xee
400216b0: 54000b40 b.eq 40021818 <rtems_bdpart_read+0x288> // b.none <== NEVER TAKEN
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
400216b4: f94037e0 ldr x0, [sp, #104]
400216b8: f9401c01 ldr x1, [x0, #56]
format->type = RTEMS_BDPART_FORMAT_MBR;
400216bc: b90002bf str wzr, [x21]
400216c0: 9106ec20 add x0, x1, #0x1bb
400216c4: 9106dc21 add x1, x1, #0x1b7
value = (value << 8) + data [i];
400216c8: 385ff402 ldrb w2, [x0], #-1
for (i = 3; i >= 0; --i) {
400216cc: eb00003f cmp x1, x0
value = (value << 8) + data [i];
400216d0: 0b132053 add w19, w2, w19, lsl #8
for (i = 3; i >= 0; --i) {
400216d4: 54ffffa1 b.ne 400216c8 <rtems_bdpart_read+0x138> // b.any
}
return value;
400216d8: 9107bb39 add x25, x25, #0x1ee
format->mbr.dos_compatibility = true;
400216dc: 52800020 mov w0, #0x1 // #1
format->mbr.disk_id = rtems_uint32_from_little_endian(
400216e0: b90006b3 str w19, [x21, #4]
format->mbr.dos_compatibility = true;
400216e4: 390022a0 strb w0, [x21, #8]
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
400216e8: 91004318 add x24, x24, #0x10
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
400216ec: 910173e3 add x3, sp, #0x5c
400216f0: aa1803e0 mov x0, x24
400216f4: aa1703e2 mov x2, x23
400216f8: 9101c3e1 add x1, sp, #0x70
400216fc: 97fffef1 bl 400212c0 <rtems_bdpart_read_mbr_partition>
for (i = 1; i < 4; ++i) {
40021700: eb19031f cmp x24, x25
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
40021704: 2a0003f3 mov w19, w0
if (sc != RTEMS_SUCCESSFUL) {
40021708: 350007e0 cbnz w0, 40021804 <rtems_bdpart_read+0x274> <== NEVER TAKEN
for (i = 1; i < 4; ++i) {
4002170c: 54fffee1 b.ne 400216e8 <rtems_bdpart_read+0x158> // b.any
ebr = ep_begin;
40021710: b9405ff5 ldr w21, [sp, #92]
while (ebr != 0) {
40021714: 34000955 cbz w21, 4002183c <rtems_bdpart_read+0x2ac> <== NEVER TAKEN
sc = rtems_bdpart_read_record( dd, ebr, &block);
40021718: f9403fe0 ldr x0, [sp, #120]
4002171c: 9101a3e2 add x2, sp, #0x68
40021720: 2a1503e1 mov w1, w21
40021724: 97ffff2b bl 400213d0 <rtems_bdpart_read_record>
if (sc != RTEMS_SUCCESSFUL) {
40021728: 350007e0 cbnz w0, 40021824 <rtems_bdpart_read+0x294> <== NEVER TAKEN
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
4002172c: f94037e0 ldr x0, [sp, #104]
sc = rtems_bdpart_read_mbr_partition(
40021730: aa1703e2 mov x2, x23
40021734: 9101c3e1 add x1, sp, #0x70
40021738: d2800003 mov x3, #0x0 // #0
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
4002173c: f9401c00 ldr x0, [x0, #56]
sc = rtems_bdpart_read_mbr_partition(
40021740: 9106f800 add x0, x0, #0x1be
40021744: 97fffedf bl 400212c0 <rtems_bdpart_read_mbr_partition>
40021748: 2a0003e4 mov w4, w0
if (sc != RTEMS_SUCCESSFUL) {
4002174c: 35000720 cbnz w0, 40021830 <rtems_bdpart_read+0x2a0> <== NEVER TAKEN
tmp = p->begin + ebr;
40021750: f9403be3 ldr x3, [sp, #112]
40021754: b9400060 ldr w0, [x3]
40021758: 0b150001 add w1, w0, w21
if (tmp > p->begin) {
4002175c: 6b01001f cmp w0, w1
40021760: 54000562 b.cs 4002180c <rtems_bdpart_read+0x27c> // b.hs, b.nlast <== NEVER TAKEN
tmp = p->end + ebr;
40021764: b9400460 ldr w0, [x3, #4]
p->begin = tmp;
40021768: b9000061 str w1, [x3]
tmp = p->end + ebr;
4002176c: 0b150015 add w21, w0, w21
if (tmp > p->end) {
40021770: 6b15001f cmp w0, w21
40021774: 540004c2 b.cs 4002180c <rtems_bdpart_read+0x27c> // b.hs, b.nlast <== NEVER TAKEN
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
40021778: f94037e0 ldr x0, [sp, #104]
4002177c: f9401c06 ldr x6, [x0, #56]
p->end = tmp;
40021780: b9000475 str w21, [x3, #4]
for (i = 3; i >= 0; --i) {
40021784: 910764c1 add x1, x6, #0x1d9
40021788: 910754c5 add x5, x6, #0x1d5
value = (value << 8) + data [i];
4002178c: 385ff422 ldrb w2, [x1], #-1
for (i = 3; i >= 0; --i) {
40021790: eb0100bf cmp x5, x1
value = (value << 8) + data [i];
40021794: 0b042044 add w4, w2, w4, lsl #8
for (i = 3; i >= 0; --i) {
40021798: 54ffffa1 b.ne 4002178c <rtems_bdpart_read+0x1fc> // b.any
if (ebr != 0) {
4002179c: 394748c1 ldrb w1, [x6, #466]
400217a0: 7100009f cmp w4, #0x0
400217a4: 7a451820 ccmp w1, #0x5, #0x0, ne // ne = any
400217a8: 54000140 b.eq 400217d0 <rtems_bdpart_read+0x240> // b.none
*count = (size_t) (p - pt + 1);
400217ac: cb160060 sub x0, x3, x22
400217b0: b201f3e1 mov x1, #0xaaaaaaaaaaaaaaaa // #-6148914691236517206
400217b4: f2955561 movk x1, #0xaaab
400217b8: 9344fc00 asr x0, x0, #4
400217bc: f94023f9 ldr x25, [sp, #64]
400217c0: 9b017c00 mul x0, x0, x1
400217c4: 91000400 add x0, x0, #0x1
400217c8: f9000280 str x0, [x20]
400217cc: 17ffff97 b 40021628 <rtems_bdpart_read+0x98>
tmp = ebr + ep_begin;
400217d0: b9405ff5 ldr w21, [sp, #92]
400217d4: 0b150095 add w21, w4, w21
if (tmp > ebr) {
400217d8: 6b0402bf cmp w21, w4
400217dc: 54fff9e8 b.hi 40021718 <rtems_bdpart_read+0x188> // b.pmore <== ALWAYS TAKEN
if (fd >= 0) {
400217e0: b94067e1 ldr w1, [sp, #100] <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
400217e4: 52800373 mov w19, #0x1b // #27 <== NOT EXECUTED
400217e8: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
if (fd >= 0) {
400217ec: 37fff261 tbnz w1, #31, 40021638 <rtems_bdpart_read+0xa8> <== NOT EXECUTED
close( fd);
400217f0: 2a0103e0 mov w0, w1
400217f4: 940006b3 bl 400232c0 <close>
if (block != NULL) {
400217f8: f94037e0 ldr x0, [sp, #104]
400217fc: b5fff1e0 cbnz x0, 40021638 <rtems_bdpart_read+0xa8> <== ALWAYS TAKEN
40021800: 17ffff7e b 400215f8 <rtems_bdpart_read+0x68> <== NOT EXECUTED
40021804: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
40021808: 17ffff88 b 40021628 <rtems_bdpart_read+0x98> <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
4002180c: 52800373 mov w19, #0x1b // #27 <== NOT EXECUTED
40021810: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
40021814: 17ffff85 b 40021628 <rtems_bdpart_read+0x98> <== NOT EXECUTED
esc = RTEMS_NOT_IMPLEMENTED;
40021818: 52800313 mov w19, #0x18 // #24 <== NOT EXECUTED
4002181c: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
40021820: 17ffff82 b 40021628 <rtems_bdpart_read+0x98> <== NOT EXECUTED
40021824: 2a0003f3 mov w19, w0 <== NOT EXECUTED
40021828: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
4002182c: 17ffff7f b 40021628 <rtems_bdpart_read+0x98> <== NOT EXECUTED
40021830: 2a0003f3 mov w19, w0 <== NOT EXECUTED
40021834: f94023f9 ldr x25, [sp, #64] <== NOT EXECUTED
40021838: 17ffff7c b 40021628 <rtems_bdpart_read+0x98> <== NOT EXECUTED
*count = (size_t) (p - pt + 1);
4002183c: f9403be3 ldr x3, [sp, #112] <== NOT EXECUTED
40021840: 17ffffdb b 400217ac <rtems_bdpart_read+0x21c> <== NOT EXECUTED
...
0000000040021850 <rtems_bdpart_register>:
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
40021850: a9ba7bfd stp x29, x30, [sp, #-96]!
rtems_status_code esc = RTEMS_SUCCESSFUL; rtems_blkdev_bnum disk_end = 0; char *logical_disk_name = NULL; char *logical_disk_marker = NULL; size_t i = 0; int fd = -1;
40021854: 12800004 mov w4, #0xffffffff // #-1
{
40021858: 910003fd mov x29, sp
rtems_disk_device *dd = NULL;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
4002185c: 910143e3 add x3, sp, #0x50
{
40021860: a90153f3 stp x19, x20, [sp, #16]
40021864: aa0103f3 mov x19, x1
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
40021868: 910153e1 add x1, sp, #0x54
{
4002186c: a9025bf5 stp x21, x22, [sp, #32]
40021870: aa0203f6 mov x22, x2
40021874: aa0003f5 mov x21, x0
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
40021878: 910163e2 add x2, sp, #0x58
{
4002187c: a90363f7 stp x23, x24, [sp, #48]
int fd = -1;
40021880: 290a13ff stp wzr, w4, [sp, #80]
rtems_disk_device *dd = NULL;
40021884: f9002fff str xzr, [sp, #88]
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
40021888: 97ffff0e bl 400214c0 <rtems_bdpart_get_disk_data>
4002188c: 2a0003f8 mov w24, w0
if (sc != RTEMS_SUCCESSFUL) {
40021890: 340000e0 cbz w0, 400218ac <rtems_bdpart_register+0x5c> <== ALWAYS TAKEN
free( logical_disk_name);
close( fd);
return esc;
}
40021894: 2a1803e0 mov w0, w24 <== NOT EXECUTED
40021898: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002189c: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400218a0: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
400218a4: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
400218a8: d65f03c0 ret <== NOT EXECUTED
size_t disk_name_size = strlen( disk_name);
400218ac: aa1503e0 mov x0, x21
400218b0: 94004fa6 bl 40035748 <strlen>
400218b4: aa0003f4 mov x20, x0
char *logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
400218b8: 91001000 add x0, x0, #0x4
400218bc: 94000875 bl 40023a90 <malloc>
400218c0: aa0003f7 mov x23, x0
if (logical_disk_name != NULL) {
400218c4: b40003c0 cbz x0, 4002193c <rtems_bdpart_register+0xec> <== NEVER TAKEN
memcpy( logical_disk_name, disk_name, disk_name_size);
400218c8: aa1403e2 mov x2, x20
400218cc: aa1503e1 mov x1, x21
400218d0: a9046bf9 stp x25, x26, [sp, #64]
*marker = logical_disk_name + disk_name_size;
400218d4: 8b14001a add x26, x0, x20
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
400218d8: b0000119 adrp x25, 40042000 <test_state_strings+0x50>
400218dc: 91066339 add x25, x25, #0x198
for (i = 0; i < count; ++i) {
400218e0: d2800014 mov x20, #0x0 // #0
memcpy( logical_disk_name, disk_name, disk_name_size);
400218e4: 94004da5 bl 40034f78 <memcpy>
if (logical_disk_name == NULL) {
400218e8: 14000006 b 40021900 <rtems_bdpart_register+0xb0>
sc = rtems_blkdev_create_partition(
400218ec: 29400e62 ldp w2, w3, [x19]
if (sc != RTEMS_SUCCESSFUL) {
400218f0: 9100c273 add x19, x19, #0x30
sc = rtems_blkdev_create_partition(
400218f4: 4b020063 sub w3, w3, w2
400218f8: 940002c2 bl 40022400 <rtems_blkdev_create_partition>
if (sc != RTEMS_SUCCESSFUL) {
400218fc: 35000340 cbnz w0, 40021964 <rtems_bdpart_register+0x114> <== NEVER TAKEN
for (i = 0; i < count; ++i) {
40021900: eb16029f cmp x20, x22
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40021904: aa1903e2 mov x2, x25
40021908: aa1a03e0 mov x0, x26
4002190c: 91000694 add x20, x20, #0x1
40021910: d2800081 mov x1, #0x4 // #4
for (i = 0; i < count; ++i) {
40021914: 540002a0 b.eq 40021968 <rtems_bdpart_register+0x118> // b.none
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40021918: aa1403e3 mov x3, x20
4002191c: 94004e2d bl 400351d0 <snprintf>
40021920: 2a0003e2 mov w2, w0
sc = rtems_blkdev_create_partition(
40021924: aa1503e1 mov x1, x21
40021928: aa1703e0 mov x0, x23
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
4002192c: 71000c5f cmp w2, #0x3
40021930: 54fffded b.le 400218ec <rtems_bdpart_register+0x9c> <== ALWAYS TAKEN
40021934: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
sc = RTEMS_INVALID_NAME;
40021938: 52800078 mov w24, #0x3 // #3 <== NOT EXECUTED
free( logical_disk_name);
4002193c: aa1703e0 mov x0, x23
40021940: 940006d8 bl 400234a0 <free>
close( fd);
40021944: b94057e0 ldr w0, [sp, #84]
40021948: 9400065e bl 400232c0 <close>
}
4002194c: 2a1803e0 mov w0, w24
40021950: a94153f3 ldp x19, x20, [sp, #16]
40021954: a9425bf5 ldp x21, x22, [sp, #32]
40021958: a94363f7 ldp x23, x24, [sp, #48]
4002195c: a8c67bfd ldp x29, x30, [sp], #96
40021960: d65f03c0 ret
40021964: 2a0003f8 mov w24, w0 <== NOT EXECUTED
40021968: a9446bf9 ldp x25, x26, [sp, #64]
4002196c: 17fffff4 b 4002193c <rtems_bdpart_register+0xec>
0000000040021970 <rtems_bdpart_register_from_disk>:
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
40021970: d10d03ff sub sp, sp, #0x340
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_bdpart_format format; rtems_bdpart_partition pt [RTEMS_BDPART_PARTITION_NUMBER_HINT]; size_t count = RTEMS_BDPART_PARTITION_NUMBER_HINT;
40021974: d2800204 mov x4, #0x10 // #16
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
40021978: 910103e2 add x2, sp, #0x40
4002197c: 910083e3 add x3, sp, #0x20
40021980: 9100a3e1 add x1, sp, #0x28
{
40021984: a9007bfd stp x29, x30, [sp]
40021988: 910003fd mov x29, sp
4002198c: f9000bf3 str x19, [sp, #16]
40021990: aa0003f3 mov x19, x0
size_t count = RTEMS_BDPART_PARTITION_NUMBER_HINT;
40021994: f90013e4 str x4, [sp, #32]
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
40021998: 97fffefe bl 40021590 <rtems_bdpart_read>
if (sc != RTEMS_SUCCESSFUL) {
4002199c: 350000a0 cbnz w0, 400219b0 <rtems_bdpart_register_from_disk+0x40> <== NEVER TAKEN
return sc;
}
/* Register partitions */
return rtems_bdpart_register( disk_name, pt, count);
400219a0: f94013e2 ldr x2, [sp, #32]
400219a4: 910103e1 add x1, sp, #0x40
400219a8: aa1303e0 mov x0, x19
400219ac: 97ffffa9 bl 40021850 <rtems_bdpart_register>
}
400219b0: a9407bfd ldp x29, x30, [sp]
400219b4: f9400bf3 ldr x19, [sp, #16]
400219b8: 910d03ff add sp, sp, #0x340
400219bc: d65f03c0 ret
00000000400219c0 <rtems_bdpart_unregister>:
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt RTEMS_UNUSED,
size_t count
)
{
400219c0: a9bb7bfd stp x29, x30, [sp, #-80]!
rtems_status_code esc = RTEMS_SUCCESSFUL; rtems_blkdev_bnum disk_end = 0; char *logical_disk_name = NULL; char *logical_disk_marker = NULL; size_t i = 0; int fd = -1;
400219c4: 12800004 mov w4, #0xffffffff // #-1
{
400219c8: 910003fd mov x29, sp
rtems_disk_device *dd = NULL;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
400219cc: 910103e3 add x3, sp, #0x40
400219d0: 910113e1 add x1, sp, #0x44
{
400219d4: a90153f3 stp x19, x20, [sp, #16]
400219d8: aa0203f4 mov x20, x2
400219dc: aa0003f3 mov x19, x0
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
400219e0: 910123e2 add x2, sp, #0x48
{
400219e4: a9025bf5 stp x21, x22, [sp, #32]
int fd = -1;
400219e8: 290813ff stp wzr, w4, [sp, #64]
rtems_disk_device *dd = NULL;
400219ec: f90027ff str xzr, [sp, #72]
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
400219f0: 97fffeb4 bl 400214c0 <rtems_bdpart_get_disk_data>
400219f4: 2a0003f6 mov w22, w0
if (sc != RTEMS_SUCCESSFUL) {
400219f8: 340000c0 cbz w0, 40021a10 <rtems_bdpart_unregister+0x50> <== ALWAYS TAKEN
free( logical_disk_name);
close( fd);
return esc;
}
400219fc: 2a1603e0 mov w0, w22 <== NOT EXECUTED
40021a00: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40021a04: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40021a08: a8c57bfd ldp x29, x30, [sp], #80 <== NOT EXECUTED
40021a0c: d65f03c0 ret <== NOT EXECUTED
size_t disk_name_size = strlen( disk_name);
40021a10: aa1303e0 mov x0, x19
40021a14: a90363f7 stp x23, x24, [sp, #48]
40021a18: 94004f4c bl 40035748 <strlen>
40021a1c: aa0003f7 mov x23, x0
char *logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
40021a20: 91001000 add x0, x0, #0x4
40021a24: 9400081b bl 40023a90 <malloc>
40021a28: aa0003f5 mov x21, x0
if (logical_disk_name != NULL) {
40021a2c: b40002e0 cbz x0, 40021a88 <rtems_bdpart_unregister+0xc8> <== NEVER TAKEN
memcpy( logical_disk_name, disk_name, disk_name_size);
40021a30: aa1303e1 mov x1, x19
40021a34: aa1703e2 mov x2, x23
*marker = logical_disk_name + disk_name_size;
40021a38: 8b170018 add x24, x0, x23
for (i = 0; i < count; ++i) {
40021a3c: d2800013 mov x19, #0x0 // #0
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40021a40: b0000117 adrp x23, 40042000 <test_state_strings+0x50>
40021a44: 910662f7 add x23, x23, #0x198
memcpy( logical_disk_name, disk_name, disk_name_size);
40021a48: 94004d4c bl 40034f78 <memcpy>
if (logical_disk_name == NULL) {
40021a4c: 14000004 b 40021a5c <rtems_bdpart_unregister+0x9c>
rv = unlink( logical_disk_name);
40021a50: aa1503e0 mov x0, x21
40021a54: 94000f4b bl 40025780 <unlink>
if (rv != 0) {
40021a58: 35000180 cbnz w0, 40021a88 <rtems_bdpart_unregister+0xc8> <== NEVER TAKEN
for (i = 0; i < count; ++i) {
40021a5c: eb14027f cmp x19, x20
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40021a60: aa1703e2 mov x2, x23
40021a64: aa1803e0 mov x0, x24
40021a68: 91000673 add x19, x19, #0x1
40021a6c: d2800081 mov x1, #0x4 // #4
for (i = 0; i < count; ++i) {
40021a70: 540000c0 b.eq 40021a88 <rtems_bdpart_unregister+0xc8> // b.none
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40021a74: aa1303e3 mov x3, x19
40021a78: 94004dd6 bl 400351d0 <snprintf>
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
40021a7c: 71000c1f cmp w0, #0x3
40021a80: 54fffe8d b.le 40021a50 <rtems_bdpart_unregister+0x90> <== ALWAYS TAKEN
sc = RTEMS_INVALID_NAME;
40021a84: 52800076 mov w22, #0x3 // #3 <== NOT EXECUTED
free( logical_disk_name);
40021a88: aa1503e0 mov x0, x21
40021a8c: 94000685 bl 400234a0 <free>
close( fd);
40021a90: b94047e0 ldr w0, [sp, #68]
40021a94: 9400060b bl 400232c0 <close>
}
40021a98: 2a1603e0 mov w0, w22
40021a9c: a94153f3 ldp x19, x20, [sp, #16]
40021aa0: a9425bf5 ldp x21, x22, [sp, #32]
close( fd);
40021aa4: a94363f7 ldp x23, x24, [sp, #48]
}
40021aa8: a8c57bfd ldp x29, x30, [sp], #80
40021aac: d65f03c0 ret
0000000040021b50 <rtems_bdpart_write>:
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
40021b50: a9b87bfd stp x29, x30, [sp, #-128]!
40021b54: 910003fd mov x29, sp
40021b58: a9025bf5 stp x21, x22, [sp, #32]
40021b5c: aa0103f6 mov x22, x1
40021b60: aa0303f5 mov x21, x3
40021b64: a90363f7 stp x23, x24, [sp, #48]
40021b68: a9046bf9 stp x25, x26, [sp, #64]
40021b6c: aa0203f9 mov x25, x2
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;
40021b70: b4000061 cbz x1, 40021b7c <rtems_bdpart_write+0x2c> <== NEVER TAKEN
&& format->type == RTEMS_BDPART_FORMAT_MBR
40021b74: b9400021 ldr w1, [x1]
40021b78: 340006e1 cbz w1, 40021c54 <rtems_bdpart_write+0x104> <== ALWAYS TAKEN
&& format->mbr.dos_compatibility;
40021b7c: 52800018 mov w24, #0x0 // #0 <== NOT EXECUTED
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
40021b80: 5280003a mov w26, #0x1 // #1 <== NOT EXECUTED
rtems_blkdev_bnum disk_end = 0;
40021b84: b9006bff str wzr, [sp, #104] <== NOT EXECUTED
rtems_bdbuf_buffer *block = NULL;
40021b88: f9003bff str xzr, [sp, #112] <== NOT EXECUTED
size_t ppc = 0; /* Primary partition count */ size_t i = 0; uint8_t *data = NULL; int fd = -1;
40021b8c: 12800001 mov w1, #0xffffffff // #-1
40021b90: b9006fe1 str w1, [sp, #108]
rtems_disk_device *dd = NULL;
40021b94: f9003fff str xzr, [sp, #120]
/* Check if we have something to do */
if (count == 0) {
/* Nothing to do */
return RTEMS_SUCCESSFUL;
40021b98: 52800017 mov w23, #0x0 // #0
if (count == 0) {
40021b9c: b4000515 cbz x21, 40021c3c <rtems_bdpart_write+0xec> <== NEVER TAKEN
}
/* Check parameter */
if (format == NULL || pt == NULL) {
40021ba0: f10002df cmp x22, #0x0
return RTEMS_INVALID_ADDRESS;
40021ba4: 52800137 mov w23, #0x9 // #9
if (format == NULL || pt == NULL) {
40021ba8: fa401b24 ccmp x25, #0x0, #0x4, ne // ne = any
40021bac: 54000480 b.eq 40021c3c <rtems_bdpart_write+0xec> // b.none <== NEVER TAKEN
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
40021bb0: 9101a3e3 add x3, sp, #0x68
40021bb4: 9101e3e2 add x2, sp, #0x78
40021bb8: 9101b3e1 add x1, sp, #0x6c
40021bbc: 97fffe41 bl 400214c0 <rtems_bdpart_get_disk_data>
40021bc0: 2a0003f7 mov w23, w0
if (sc != RTEMS_SUCCESSFUL) {
40021bc4: 350003c0 cbnz w0, 40021c3c <rtems_bdpart_write+0xec> <== NEVER TAKEN
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
40021bc8: a90153f3 stp x19, x20, [sp, #16]
disk_end -= (disk_end % record_space);
40021bcc: b9406be3 ldr w3, [sp, #104]
if (dos_compatibility) {
40021bd0: 35000518 cbnz w24, 40021c70 <rtems_bdpart_write+0x120> <== ALWAYS TAKEN
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
40021bd4: aa1903e0 mov x0, x25
}
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
40021bd8: d2800013 mov x19, #0x0 // #0
40021bdc: 14000009 b 40021c00 <rtems_bdpart_write+0xb0>
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that partitions do not overlap */
if (i > 0 && pt [i - 1].end > p->begin) {
40021be0: b4000093 cbz x19, 40021bf0 <rtems_bdpart_write+0xa0>
40021be4: b85d4001 ldur w1, [x0, #-44]
40021be8: 6b01009f cmp w4, w1
40021bec: 540001a3 b.cc 40021c20 <rtems_bdpart_write+0xd0> // b.lo, b.ul, b.last<== NEVER TAKEN
for (i = 0; i < count; ++i) {
40021bf0: 9100c000 add x0, x0, #0x30
40021bf4: eb1402bf cmp x21, x20
40021bf8: 540005c0 b.eq 40021cb0 <rtems_bdpart_write+0x160> // b.none
40021bfc: aa1403f3 mov x19, x20
if (p->begin >= disk_end || p->end > disk_end) {
40021c00: b9400004 ldr w4, [x0]
for (i = 0; i < count; ++i) {
40021c04: 91000674 add x20, x19, #0x1
if (p->begin >= disk_end || p->end > disk_end) {
40021c08: 6b03009f cmp w4, w3
40021c0c: 540000a2 b.cs 40021c20 <rtems_bdpart_write+0xd0> // b.hs, b.nlast <== NEVER TAKEN
40021c10: b9400405 ldr w5, [x0, #4]
if (p->begin >= p->end) {
40021c14: 6b05009f cmp w4, w5
40021c18: 7a4330a2 ccmp w5, w3, #0x2, cc // cc = lo, ul, last
40021c1c: 54fffe29 b.ls 40021be0 <rtems_bdpart_write+0x90> // b.plast <== ALWAYS TAKEN
esc = RTEMS_INVALID_NUMBER;
40021c20: 52800157 mov w23, #0xa // #10 <== NOT EXECUTED
}
}
cleanup:
if (fd >= 0) {
40021c24: b9406fe0 ldr w0, [sp, #108]
40021c28: 36f803c0 tbz w0, #31, 40021ca0 <rtems_bdpart_write+0x150> <== ALWAYS TAKEN
close( fd);
}
if (block != NULL) {
40021c2c: f9403be0 ldr x0, [sp, #112] <== NOT EXECUTED
40021c30: b40002a0 cbz x0, 40021c84 <rtems_bdpart_write+0x134> <== NOT EXECUTED
rtems_bdbuf_sync( block);
40021c34: 9400340f bl 4002ec70 <rtems_bdbuf_sync>
40021c38: a94153f3 ldp x19, x20, [sp, #16]
}
return esc;
}
40021c3c: 2a1703e0 mov w0, w23
40021c40: a9425bf5 ldp x21, x22, [sp, #32]
40021c44: a94363f7 ldp x23, x24, [sp, #48]
40021c48: a9446bf9 ldp x25, x26, [sp, #64]
40021c4c: a8c87bfd ldp x29, x30, [sp], #128
40021c50: d65f03c0 ret
&& format->mbr.dos_compatibility;
40021c54: 394022c1 ldrb w1, [x22, #8]
40021c58: 34fff921 cbz w1, 40021b7c <rtems_bdpart_write+0x2c> <== NEVER TAKEN
40021c5c: 52800038 mov w24, #0x1 // #1
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
40021c60: 528007fa mov w26, #0x3f // #63
rtems_blkdev_bnum disk_end = 0;
40021c64: b9006bff str wzr, [sp, #104]
rtems_bdbuf_buffer *block = NULL;
40021c68: f9003bff str xzr, [sp, #112]
rtems_blkdev_bnum record_space =
40021c6c: 17ffffc8 b 40021b8c <rtems_bdpart_write+0x3c>
disk_end -= (disk_end % record_space);
40021c70: 1ada0860 udiv w0, w3, w26
40021c74: 1b1a8c00 msub w0, w0, w26, w3
40021c78: 4b000063 sub w3, w3, w0
40021c7c: b9006be3 str w3, [sp, #104]
40021c80: 17ffffd5 b 40021bd4 <rtems_bdpart_write+0x84>
}
40021c84: 2a1703e0 mov w0, w23 <== NOT EXECUTED
40021c88: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40021c8c: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40021c90: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
40021c94: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40021c98: a8c87bfd ldp x29, x30, [sp], #128 <== NOT EXECUTED
40021c9c: d65f03c0 ret <== NOT EXECUTED
close( fd);
40021ca0: 94000588 bl 400232c0 <close>
if (block != NULL) {
40021ca4: f9403be0 ldr x0, [sp, #112]
40021ca8: b5fffc60 cbnz x0, 40021c34 <rtems_bdpart_write+0xe4> <== ALWAYS TAKEN
40021cac: 17fffff6 b 40021c84 <rtems_bdpart_write+0x134> <== NOT EXECUTED
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
40021cb0: b94002c0 ldr w0, [x22]
esc = RTEMS_NOT_IMPLEMENTED;
40021cb4: 52800317 mov w23, #0x18 // #24
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
40021cb8: 35fffb60 cbnz w0, 40021c24 <rtems_bdpart_write+0xd4> <== NEVER TAKEN
ppc = count <= 4 ? count : 3;
40021cbc: f10012bf cmp x21, #0x4
40021cc0: 540001e9 b.ls 40021cfc <rtems_bdpart_write+0x1ac> // b.plast <== NEVER TAKEN
if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
40021cc4: 350015f8 cbnz w24, 40021f80 <rtems_bdpart_write+0x430> <== ALWAYS TAKEN
40021cc8: d2800603 mov x3, #0x30 // #48
40021ccc: 91024320 add x0, x25, #0x90
40021cd0: 9b036683 madd x3, x20, x3, x25
40021cd4: 14000003 b 40021ce0 <rtems_bdpart_write+0x190>
for (i = ppc; i < count; ++i) {
40021cd8: eb03001f cmp x0, x3
40021cdc: 540001e0 b.eq 40021d18 <rtems_bdpart_write+0x1c8> // b.none
if ((pt [i].begin - pt [i - 1].end) < record_space) {
40021ce0: b85d4002 ldur w2, [x0, #-44]
for (i = ppc; i < count; ++i) {
40021ce4: 9100c000 add x0, x0, #0x30
if ((pt [i].begin - pt [i - 1].end) < record_space) {
40021ce8: b85d0001 ldur w1, [x0, #-48]
40021cec: 4b020021 sub w1, w1, w2
40021cf0: 6b1a003f cmp w1, w26
40021cf4: 54ffff22 b.cs 40021cd8 <rtems_bdpart_write+0x188> // b.hs, b.nlast <== ALWAYS TAKEN
40021cf8: 17ffffca b 40021c20 <rtems_bdpart_write+0xd0> <== NOT EXECUTED
if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
40021cfc: 340000b8 cbz w24, 40021d10 <rtems_bdpart_write+0x1c0> <== NOT EXECUTED
40021d00: b9400320 ldr w0, [x25] <== NOT EXECUTED
esc = RTEMS_INVALID_NUMBER;
40021d04: 52800157 mov w23, #0xa // #10 <== NOT EXECUTED
if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
40021d08: 7100fc1f cmp w0, #0x3f <== NOT EXECUTED
40021d0c: 54fff8c1 b.ne 40021c24 <rtems_bdpart_write+0xd4> // b.any <== NOT EXECUTED
40021d10: aa1403f8 mov x24, x20 <== NOT EXECUTED
40021d14: 14000002 b 40021d1c <rtems_bdpart_write+0x1cc> <== NOT EXECUTED
40021d18: d2800078 mov x24, #0x3 // #3
40021d1c: 91002335 add x21, x25, #0x8
40021d20: d2800617 mov x23, #0x30 // #48
40021d24: 9b175697 madd x23, x20, x23, x21
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
40021d28: 91019fe1 add x1, sp, #0x67
40021d2c: aa1503e0 mov x0, x21
uint8_t type = 0;
40021d30: 39019fff strb wzr, [sp, #103]
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
40021d34: 97fffdd3 bl 40021480 <rtems_bdpart_to_mbr_partition_type>
40021d38: 72001c1f tst w0, #0xff
40021d3c: 54001180 b.eq 40021f6c <rtems_bdpart_write+0x41c> // b.none <== NEVER TAKEN
if (p->flags > 0xffU) {
40021d40: f94012a0 ldr x0, [x21, #32]
for (i = 0; i < count; ++i) {
40021d44: 9100c2b5 add x21, x21, #0x30
if (p->flags > 0xffU) {
40021d48: f103fc1f cmp x0, #0xff
40021d4c: 54001108 b.hi 40021f6c <rtems_bdpart_write+0x41c> // b.pmore <== NEVER TAKEN
for (i = 0; i < count; ++i) {
40021d50: eb1702bf cmp x21, x23
40021d54: 54fffea1 b.ne 40021d28 <rtems_bdpart_write+0x1d8> // b.any
sc = rtems_bdpart_new_record( dd, 0, &block);
40021d58: f9403fe0 ldr x0, [sp, #120]
40021d5c: 9101c3e2 add x2, sp, #0x70
40021d60: 52800001 mov w1, #0x0 // #0
40021d64: 97ffff53 bl 40021ab0 <rtems_bdpart_new_record>
40021d68: 2a0003f7 mov w23, w0
if (sc != RTEMS_SUCCESSFUL) {
40021d6c: 35fff5c0 cbnz w0, 40021c24 <rtems_bdpart_write+0xd4> <== NEVER TAKEN
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
40021d70: f9403be3 ldr x3, [sp, #112]
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
40021d74: aa1903e2 mov x2, x25
rtems_uint32_to_little_endian(
40021d78: b94006c1 ldr w1, [x22, #4]
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
40021d7c: f9401c60 ldr x0, [x3, #56]
{
int i;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
value >>= 8;
40021d80: 53087c26 lsr w6, w1, #8
40021d84: 53107c25 lsr w5, w1, #16
40021d88: 53187c24 lsr w4, w1, #24
data [i] = (uint8_t) value;
40021d8c: 3906e001 strb w1, [x0, #440]
40021d90: 3906e406 strb w6, [x0, #441]
40021d94: 3906e805 strb w5, [x0, #442]
40021d98: 3906ec04 strb w4, [x0, #443]
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
40021d9c: f9401c61 ldr x1, [x3, #56]
40021da0: 9106f820 add x0, x1, #0x1be
for (i = 0; i < ppc; ++i) {
40021da4: 8b181021 add x1, x1, x24, lsl #4
40021da8: 9106f82c add x12, x1, #0x1be
40021dac: d503201f nop
rtems_bdpart_write_mbr_partition(
40021db0: 29400443 ldp w3, w1, [x2]
for (i = 0; i < ppc; ++i) {
40021db4: 9100c042 add x2, x2, #0x30
40021db8: 385d804b ldurb w11, [x2, #-40]
rtems_bdpart_write_mbr_partition(
40021dbc: 4b030021 sub w1, w1, w3
40021dc0: 385f8044 ldurb w4, [x2, #-8]
value >>= 8;
40021dc4: 53087c6a lsr w10, w3, #8
40021dc8: 53107c69 lsr w9, w3, #16
40021dcc: 53087c27 lsr w7, w1, #8
40021dd0: 53107c26 lsr w6, w1, #16
40021dd4: 53187c25 lsr w5, w1, #24
40021dd8: 53187c68 lsr w8, w3, #24
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
40021ddc: 3900100b strb w11, [x0, #4]
data [i] = (uint8_t) value;
40021de0: 39002003 strb w3, [x0, #8]
40021de4: 3900240a strb w10, [x0, #9]
40021de8: 39002809 strb w9, [x0, #10]
40021dec: 39002c08 strb w8, [x0, #11]
40021df0: 39003001 strb w1, [x0, #12]
40021df4: 39003407 strb w7, [x0, #13]
40021df8: 39003806 strb w6, [x0, #14]
40021dfc: 39003c05 strb w5, [x0, #15]
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
40021e00: 38010404 strb w4, [x0], #16
for (i = 0; i < ppc; ++i) {
40021e04: eb0c001f cmp x0, x12
40021e08: 54fffd41 b.ne 40021db0 <rtems_bdpart_write+0x260> // b.any
if (ppc != count) {
40021e0c: eb18029f cmp x20, x24
40021e10: 54fff0a0 b.eq 40021c24 <rtems_bdpart_write+0xd4> // b.none <== NEVER TAKEN
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
40021e14: d2800602 mov x2, #0x30 // #48
rtems_bdpart_write_mbr_partition(
40021e18: b9406be1 ldr w1, [sp, #104]
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
40021e1c: 528000b5 mov w21, #0x5 // #5
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
40021e20: 9b027f02 mul x2, x24, x2
rtems_bdpart_write_mbr_partition(
40021e24: 0b010341 add w1, w26, w1
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
40021e28: 8b020336 add x22, x25, x2
40021e2c: b8626b34 ldr w20, [x25, x2]
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
40021e30: 3900001f strb wzr, [x0]
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
40021e34: 4b1a0283 sub w3, w20, w26
rtems_bdpart_write_mbr_partition(
40021e38: 4b140021 sub w1, w1, w20
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
40021e3c: 39001015 strb w21, [x0, #4]
value >>= 8;
40021e40: 53087c69 lsr w9, w3, #8
40021e44: 53107c68 lsr w8, w3, #16
40021e48: 53187c67 lsr w7, w3, #24
40021e4c: 53087c26 lsr w6, w1, #8
40021e50: 53107c25 lsr w5, w1, #16
40021e54: 53187c24 lsr w4, w1, #24
data [i] = (uint8_t) value;
40021e58: 39002003 strb w3, [x0, #8]
40021e5c: 39002409 strb w9, [x0, #9]
40021e60: 39002808 strb w8, [x0, #10]
40021e64: 39002c07 strb w7, [x0, #11]
40021e68: 39003001 strb w1, [x0, #12]
40021e6c: 39003406 strb w6, [x0, #13]
40021e70: 39003805 strb w5, [x0, #14]
40021e74: 39003c04 strb w4, [x0, #15]
for (i = ppc; i < count; ++i) {
40021e78: 54ffed69 b.ls 40021c24 <rtems_bdpart_write+0xd4> // b.plast <== NEVER TAKEN
ebr = p->begin - record_space;
40021e7c: b8626b22 ldr w2, [x25, x2]
40021e80: a90573fb stp x27, x28, [sp, #80]
40021e84: aa1603fc mov x28, x22
40021e88: aa1803fb mov x27, x24
sc = rtems_bdpart_new_record( dd, ebr, &block);
40021e8c: f9403fe0 ldr x0, [sp, #120]
40021e90: 4b1a0041 sub w1, w2, w26
40021e94: 9101c3e2 add x2, sp, #0x70
40021e98: 97ffff06 bl 40021ab0 <rtems_bdpart_new_record>
if (sc != RTEMS_SUCCESSFUL) {
40021e9c: 350006c0 cbnz w0, 40021f74 <rtems_bdpart_write+0x424> <== NEVER TAKEN
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
40021ea0: f9403be3 ldr x3, [sp, #112]
for (i = ppc; i < count; ++i) {
40021ea4: 91000762 add x2, x27, #0x1
rtems_bdpart_write_mbr_partition(
40021ea8: 294006c4 ldp w4, w1, [x22]
for (i = ppc; i < count; ++i) {
40021eac: eb13037f cmp x27, x19
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
40021eb0: f9401c60 ldr x0, [x3, #56]
rtems_bdpart_write_mbr_partition(
40021eb4: 4b040021 sub w1, w1, w4
40021eb8: 394022c7 ldrb w7, [x22, #8]
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
40021ebc: aa0203fb mov x27, x2
rtems_bdpart_write_mbr_partition(
40021ec0: 3940a2c8 ldrb w8, [x22, #40]
value >>= 8;
40021ec4: 53087c26 lsr w6, w1, #8
40021ec8: 53107c25 lsr w5, w1, #16
40021ecc: 53187c24 lsr w4, w1, #24
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
40021ed0: 3906f808 strb w8, [x0, #446]
40021ed4: 9100c2d6 add x22, x22, #0x30
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
40021ed8: 39070807 strb w7, [x0, #450]
data [i] = (uint8_t) value;
40021edc: 3907181a strb w26, [x0, #454]
40021ee0: 39071c1f strb wzr, [x0, #455]
40021ee4: 3907201f strb wzr, [x0, #456]
40021ee8: 3907241f strb wzr, [x0, #457]
40021eec: 39072801 strb w1, [x0, #458]
40021ef0: 39072c06 strb w6, [x0, #459]
40021ef4: 39073005 strb w5, [x0, #460]
40021ef8: 39073404 strb w4, [x0, #461]
for (i = ppc; i < count; ++i) {
40021efc: 540003e0 b.eq 40021f78 <rtems_bdpart_write+0x428> // b.none
if (i > ppc) {
40021f00: eb18005f cmp x2, x24
rtems_blkdev_bnum begin = p->begin - record_space;
40021f04: b9403382 ldr w2, [x28, #48]
if (i > ppc) {
40021f08: 540002e9 b.ls 40021f64 <rtems_bdpart_write+0x414> // b.plast <== NEVER TAKEN
rtems_bdpart_write_mbr_partition(
40021f0c: b9406be1 ldr w1, [sp, #104]
40021f10: 4b140044 sub w4, w2, w20
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,
40021f14: f9401c60 ldr x0, [x3, #56]
rtems_bdpart_write_mbr_partition(
40021f18: 0b010341 add w1, w26, w1
40021f1c: 4b020021 sub w1, w1, w2
value >>= 8;
40021f20: 53087c88 lsr w8, w4, #8
40021f24: 53107c87 lsr w7, w4, #16
40021f28: 53187c86 lsr w6, w4, #24
40021f2c: 53187c22 lsr w2, w1, #24
40021f30: 53087c25 lsr w5, w1, #8
40021f34: 53107c23 lsr w3, w1, #16
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
40021f38: 3907381f strb wzr, [x0, #462]
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
40021f3c: 39074815 strb w21, [x0, #466]
data [i] = (uint8_t) value;
40021f40: 39075804 strb w4, [x0, #470]
40021f44: 39075c08 strb w8, [x0, #471]
40021f48: 39076007 strb w7, [x0, #472]
40021f4c: 39076406 strb w6, [x0, #473]
40021f50: 39076801 strb w1, [x0, #474]
40021f54: 39076c05 strb w5, [x0, #475]
40021f58: 39077003 strb w3, [x0, #476]
40021f5c: 39077402 strb w2, [x0, #477]
ebr = p->begin - record_space;
40021f60: b9403382 ldr w2, [x28, #48]
40021f64: 9100c39c add x28, x28, #0x30
40021f68: 17ffffc9 b 40021e8c <rtems_bdpart_write+0x33c>
goto cleanup;
40021f6c: 52800097 mov w23, #0x4 // #4 <== NOT EXECUTED
40021f70: 17ffff2d b 40021c24 <rtems_bdpart_write+0xd4> <== NOT EXECUTED
40021f74: 2a0003f7 mov w23, w0 <== NOT EXECUTED
40021f78: a94573fb ldp x27, x28, [sp, #80]
40021f7c: 17ffff2a b 40021c24 <rtems_bdpart_write+0xd4>
if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
40021f80: b9400320 ldr w0, [x25]
40021f84: 7100fc1f cmp w0, #0x3f
40021f88: 54ffea00 b.eq 40021cc8 <rtems_bdpart_write+0x178> // b.none <== ALWAYS TAKEN
40021f8c: 17ffff25 b 40021c20 <rtems_bdpart_write+0xd0> <== NOT EXECUTED
0000000040022400 <rtems_blkdev_create_partition>:
const char *partition,
const char *parent_block_device,
rtems_blkdev_bnum media_block_begin,
rtems_blkdev_bnum media_block_count
)
{
40022400: a9b57bfd stp x29, x30, [sp, #-176]!
40022404: 910003fd mov x29, sp
40022408: a90153f3 stp x19, x20, [sp, #16]
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
}
} else {
sc = RTEMS_INVALID_ID;
4002240c: 52800094 mov w20, #0x4 // #4
{
40022410: a9025bf5 stp x21, x22, [sp, #32]
40022414: 2a0203f6 mov w22, w2
40022418: 2a0303f5 mov w21, w3
4002241c: a90363f7 stp x23, x24, [sp, #48]
40022420: aa0003f7 mov x23, x0
int fd = open(parent_block_device, O_RDWR);
40022424: aa0103e0 mov x0, x1
40022428: 52800041 mov w1, #0x2 // #2
4002242c: 940007a1 bl 400242b0 <open>
if (fd >= 0) {
40022430: 37f80180 tbnz w0, #31, 40022460 <rtems_blkdev_create_partition+0x60>
rv = fstat(fd, &st);
40022434: 2a0003f3 mov w19, w0
40022438: 910123e1 add x1, sp, #0x48
4002243c: 94000459 bl 400235a0 <fstat>
if (rv == 0 && S_ISBLK(st.st_mode)) {
40022440: 350001c0 cbnz w0, 40022478 <rtems_blkdev_create_partition+0x78> <== NEVER TAKEN
40022444: b9405be0 ldr w0, [sp, #88]
sc = RTEMS_INVALID_NODE;
40022448: 528002b4 mov w20, #0x15 // #21
if (rv == 0 && S_ISBLK(st.st_mode)) {
4002244c: 12140c00 and w0, w0, #0xf000
40022450: 7140181f cmp w0, #0x6, lsl #12
40022454: 54000160 b.eq 40022480 <rtems_blkdev_create_partition+0x80> // b.none
close(fd);
40022458: 2a1303e0 mov w0, w19
4002245c: 94000399 bl 400232c0 <close>
}
return sc;
}
40022460: 2a1403e0 mov w0, w20
40022464: a94153f3 ldp x19, x20, [sp, #16]
40022468: a9425bf5 ldp x21, x22, [sp, #32]
4002246c: a94363f7 ldp x23, x24, [sp, #48]
40022470: a8cb7bfd ldp x29, x30, [sp], #176
40022474: d65f03c0 ret
sc = RTEMS_INVALID_NODE;
40022478: 528002b4 mov w20, #0x15 // #21 <== NOT EXECUTED
4002247c: 17fffff7 b 40022458 <rtems_blkdev_create_partition+0x58> <== NOT EXECUTED
40022480: 910103e2 add x2, sp, #0x40
40022484: 2a1303e0 mov w0, w19
40022488: d2884121 mov x1, #0x4209 // #16905
4002248c: f2a80101 movk x1, #0x4008, lsl #16
sc = RTEMS_NOT_IMPLEMENTED;
40022490: 52800314 mov w20, #0x18 // #24
40022494: 9400049b bl 40023700 <ioctl>
if (rv == 0) {
40022498: 35fffe00 cbnz w0, 40022458 <rtems_blkdev_create_partition+0x58>
rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
4002249c: d2801400 mov x0, #0xa0 // #160
sc = RTEMS_NO_MEMORY;
400224a0: 52800354 mov w20, #0x1a // #26
rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
400224a4: 9400057b bl 40023a90 <malloc>
400224a8: aa0003f8 mov x24, x0
if (ctx != NULL) {
400224ac: b4fffd60 cbz x0, 40022458 <rtems_blkdev_create_partition+0x58>
sc = rtems_disk_init_log(
400224b0: f94023e1 ldr x1, [sp, #64]
400224b4: 2a1503e3 mov w3, w21
400224b8: 2a1603e2 mov w2, w22
400224bc: 9400003d bl 400225b0 <rtems_disk_init_log>
400224c0: 2a0003f4 mov w20, w0
if (sc == RTEMS_SUCCESSFUL) {
400224c4: 350001a0 cbnz w0, 400224f8 <rtems_blkdev_create_partition+0xf8>
rv = IMFS_make_generic_node(
400224c8: 90000102 adrp x2, 40042000 <test_state_strings+0x50>
400224cc: aa1703e0 mov x0, x23
400224d0: aa1803e3 mov x3, x24
400224d4: 91068042 add x2, x2, #0x1a0
400224d8: 528c3fe1 mov w1, #0x61ff // #25087
ctx->fd = fd;
400224dc: b9009b13 str w19, [x24, #152]
rv = IMFS_make_generic_node(
400224e0: 940010b4 bl 400267b0 <IMFS_make_generic_node>
if (rv != 0) {
400224e4: 34fffbe0 cbz w0, 40022460 <rtems_blkdev_create_partition+0x60>
free(ctx);
400224e8: aa1803e0 mov x0, x24
sc = RTEMS_UNSATISFIED;
400224ec: 528001b4 mov w20, #0xd // #13
free(ctx);
400224f0: 940003ec bl 400234a0 <free>
if (sc != RTEMS_SUCCESSFUL) {
400224f4: 17ffffd9 b 40022458 <rtems_blkdev_create_partition+0x58>
free(ctx);
400224f8: aa1803e0 mov x0, x24
400224fc: 940003e9 bl 400234a0 <free>
if (sc != RTEMS_SUCCESSFUL) {
40022500: 17ffffd6 b 40022458 <rtems_blkdev_create_partition+0x58>
...
0000000040021560 <rtems_blkdev_generic_ioctl>:
rtems_device_driver
rtems_blkdev_generic_ioctl(
rtems_device_major_number major RTEMS_UNUSED,
rtems_device_minor_number minor RTEMS_UNUSED,
void * arg)
{
40021560: a9be7bfd stp x29, x30, [sp, #-32]!
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)
40021564: d2884020 mov x0, #0x4201 // #16897
40021568: f2b80500 movk x0, #0xc028, lsl #16
{
4002156c: 910003fd mov x29, sp
if (args->command != RTEMS_BLKIO_REQUEST)
40021570: f9400441 ldr x1, [x2, #8]
{
40021574: f9000bf3 str x19, [sp, #16]
40021578: aa0203f3 mov x19, x2
if (args->command != RTEMS_BLKIO_REQUEST)
4002157c: eb00003f cmp x1, x0
40021580: 54000160 b.eq 400215ac <rtems_blkdev_generic_ioctl+0x4c> // b.none <== NEVER TAKEN
rtems_disk_device *dd = iop->data1;
40021584: f9400040 ldr x0, [x2]
{
args->ioctl_return = dd->ioctl(dd,
40021588: f9400842 ldr x2, [x2, #16]
rtems_disk_device *dd = iop->data1;
4002158c: f9402400 ldr x0, [x0, #72]
args->ioctl_return = dd->ioctl(dd,
40021590: f9402403 ldr x3, [x0, #72]
40021594: d63f0060 blr x3
40021598: b9001a60 str w0, [x19, #24]
*/
args->ioctl_return = -1;
}
return RTEMS_SUCCESSFUL;
}
4002159c: 52800000 mov w0, #0x0 // #0
400215a0: f9400bf3 ldr x19, [sp, #16]
400215a4: a8c27bfd ldp x29, x30, [sp], #32
400215a8: d65f03c0 ret
args->ioctl_return = -1;
400215ac: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
400215b0: b9001840 str w0, [x2, #24] <== NOT EXECUTED
}
400215b4: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
400215b8: f9400bf3 ldr x19, [sp, #16] <== NOT EXECUTED
400215bc: a8c27bfd ldp x29, x30, [sp], #32 <== NOT EXECUTED
400215c0: d65f03c0 ret <== NOT EXECUTED
...
00000000400212f0 <rtems_blkdev_generic_read>:
rtems_device_driver
rtems_blkdev_generic_read(
rtems_device_major_number major RTEMS_UNUSED,
rtems_device_minor_number minor RTEMS_UNUSED,
void * arg)
{
400212f0: a9ba7bfd stp x29, x30, [sp, #-96]! <== NOT EXECUTED
400212f4: 910003fd mov x29, sp <== NOT EXECUTED
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
400212f8: a9400041 ldp x1, x0, [x2] <== NOT EXECUTED
{
400212fc: a9046bf9 stp x25, x26, [sp, #64] <== NOT EXECUTED
40021300: a90363f7 stp x23, x24, [sp, #48] <== NOT EXECUTED
40021304: aa0203f7 mov x23, x2 <== NOT EXECUTED
40021308: a90153f3 stp x19, x20, [sp, #16] <== NOT EXECUTED
rtems_disk_device *dd = iop->data1;
4002130c: f9402439 ldr x25, [x1, #72] <== NOT EXECUTED
{
40021310: a9025bf5 stp x21, x22, [sp, #32] <== NOT EXECUTED
uint32_t count = args->count;
40021314: b9401855 ldr w21, [x2, #24] <== NOT EXECUTED
char *buf = args->buffer;
40021318: f9400856 ldr x22, [x2, #16] <== NOT EXECUTED
uint32_t block_size = dd->block_size;
4002131c: b9403338 ldr w24, [x25, #48] <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
args->bytes_moved = 0;
40021320: b900205f str wzr, [x2, #32] <== NOT EXECUTED
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
40021324: 2a1803f4 mov w20, w24 <== NOT EXECUTED
40021328: 9ad40c1a sdiv x26, x0, x20 <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4002132c: 1b148354 msub w20, w26, w20, w0 <== NOT EXECUTED
while (count > 0)
40021330: 35000235 cbnz w21, 40021374 <rtems_blkdev_generic_read+0x84> <== NOT EXECUTED
40021334: 14000023 b 400213c0 <rtems_blkdev_generic_read+0xd0> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
40021338: f9402fe1 ldr x1, [sp, #88] <== NOT EXECUTED
rc = rtems_bdbuf_release(diskbuf);
args->bytes_moved += copy;
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
4002133c: 8b0402d6 add x22, x22, x4 <== NOT EXECUTED
blkofs = 0;
block++;
40021340: 1100075a add w26, w26, #0x1 <== NOT EXECUTED
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
40021344: f9401c21 ldr x1, [x1, #56] <== NOT EXECUTED
40021348: 8b344021 add x1, x1, w20, uxtw <== NOT EXECUTED
4002134c: 940045ca bl 40032a74 <memcpy> <== NOT EXECUTED
rc = rtems_bdbuf_release(diskbuf);
40021350: f9402fe0 ldr x0, [sp, #88] <== NOT EXECUTED
40021354: 94002ae3 bl 4002bee0 <rtems_bdbuf_release> <== NOT EXECUTED
40021358: 2a0003f4 mov w20, w0 <== NOT EXECUTED
args->bytes_moved += copy;
4002135c: b94022e3 ldr w3, [x23, #32] <== NOT EXECUTED
while (count > 0)
40021360: 6b1302b5 subs w21, w21, w19 <== NOT EXECUTED
args->bytes_moved += copy;
40021364: 0b130063 add w3, w3, w19 <== NOT EXECUTED
40021368: b90022e3 str w3, [x23, #32] <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
4002136c: 350003a0 cbnz w0, 400213e0 <rtems_blkdev_generic_read+0xf0> <== NOT EXECUTED
while (count > 0)
40021370: 54000280 b.eq 400213c0 <rtems_blkdev_generic_read+0xd0> // b.none <== NOT EXECUTED
rc = rtems_bdbuf_read(dd, block, &diskbuf);
40021374: 910163e2 add x2, sp, #0x58 <== NOT EXECUTED
40021378: 2a1a03e1 mov w1, w26 <== NOT EXECUTED
4002137c: aa1903e0 mov x0, x25 <== NOT EXECUTED
40021380: 94002a58 bl 4002bce0 <rtems_bdbuf_read> <== NOT EXECUTED
copy = block_size - blkofs;
40021384: 4b140303 sub w3, w24, w20 <== NOT EXECUTED
rc = rtems_bdbuf_read(dd, block, &diskbuf);
40021388: 2a0003e1 mov w1, w0 <== NOT EXECUTED
4002138c: 6b15007f cmp w3, w21 <== NOT EXECUTED
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
40021390: aa1603e0 mov x0, x22 <== NOT EXECUTED
40021394: 1a959064 csel w4, w3, w21, ls // ls = plast <== NOT EXECUTED
40021398: 1a959073 csel w19, w3, w21, ls // ls = plast <== NOT EXECUTED
4002139c: aa0403e2 mov x2, x4 <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
400213a0: 34fffcc1 cbz w1, 40021338 <rtems_blkdev_generic_read+0x48> <== NOT EXECUTED
}
return rc;
}
400213a4: 2a0103e0 mov w0, w1 <== NOT EXECUTED
400213a8: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400213ac: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400213b0: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
400213b4: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
400213b8: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
400213bc: d65f03c0 ret <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
400213c0: 52800001 mov w1, #0x0 // #0 <== NOT EXECUTED
}
400213c4: 2a0103e0 mov w0, w1 <== NOT EXECUTED
400213c8: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400213cc: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400213d0: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
400213d4: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
400213d8: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
400213dc: d65f03c0 ret <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
400213e0: 2a0003e1 mov w1, w0 <== NOT EXECUTED
}
400213e4: 2a0103e0 mov w0, w1 <== NOT EXECUTED
400213e8: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400213ec: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400213f0: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
400213f4: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
400213f8: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
400213fc: d65f03c0 ret <== NOT EXECUTED
0000000040021400 <rtems_blkdev_generic_write>:
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major RTEMS_UNUSED,
rtems_device_minor_number minor RTEMS_UNUSED,
void * arg)
{
40021400: a9ba7bfd stp x29, x30, [sp, #-96]! <== NOT EXECUTED
40021404: 910003fd mov x29, sp <== NOT EXECUTED
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
40021408: a9400041 ldp x1, x0, [x2] <== NOT EXECUTED
{
4002140c: a90363f7 stp x23, x24, [sp, #48] <== NOT EXECUTED
40021410: a90153f3 stp x19, x20, [sp, #16] <== NOT EXECUTED
uint32_t count = args->count;
40021414: b9401854 ldr w20, [x2, #24] <== NOT EXECUTED
{
40021418: a9046bf9 stp x25, x26, [sp, #64] <== NOT EXECUTED
rtems_disk_device *dd = iop->data1;
4002141c: f9402438 ldr x24, [x1, #72] <== NOT EXECUTED
{
40021420: a9025bf5 stp x21, x22, [sp, #32] <== NOT EXECUTED
40021424: aa0203f6 mov x22, x2 <== NOT EXECUTED
char *buf = args->buffer;
40021428: f9400855 ldr x21, [x2, #16] <== NOT EXECUTED
uint32_t block_size = dd->block_size;
4002142c: b9403317 ldr w23, [x24, #48] <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
args->bytes_moved = 0;
40021430: b900205f str wzr, [x2, #32] <== NOT EXECUTED
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
40021434: 2a1703f3 mov w19, w23 <== NOT EXECUTED
40021438: 9ad30c1a sdiv x26, x0, x19 <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4002143c: 1b138353 msub w19, w26, w19, w0 <== NOT EXECUTED
while (count > 0)
40021440: 35000314 cbnz w20, 400214a0 <rtems_blkdev_generic_write+0xa0> <== NOT EXECUTED
40021444: 14000028 b 400214e4 <rtems_blkdev_generic_write+0xe4> <== NOT EXECUTED
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dd, block, &diskbuf);
40021448: 940029de bl 4002bbc0 <rtems_bdbuf_get> <== NOT EXECUTED
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
4002144c: 4b1302e3 sub w3, w23, w19 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
40021450: aa1503e1 mov x1, x21 <== NOT EXECUTED
40021454: 6b14007f cmp w3, w20 <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
40021458: 350003a0 cbnz w0, 400214cc <rtems_blkdev_generic_write+0xcc> <== NOT EXECUTED
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
4002145c: f9402fe0 ldr x0, [sp, #88] <== NOT EXECUTED
40021460: 1a949062 csel w2, w3, w20, ls // ls = plast <== NOT EXECUTED
40021464: 1a949079 csel w25, w3, w20, ls // ls = plast <== NOT EXECUTED
rc = rtems_bdbuf_release_modified(diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
40021468: 8b0202b5 add x21, x21, x2 <== NOT EXECUTED
blkofs = 0;
block++;
4002146c: 1100075a add w26, w26, #0x1 <== NOT EXECUTED
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
40021470: f9401c00 ldr x0, [x0, #56] <== NOT EXECUTED
40021474: 8b334000 add x0, x0, w19, uxtw <== NOT EXECUTED
40021478: 9400457f bl 40032a74 <memcpy> <== NOT EXECUTED
args->bytes_moved += copy;
4002147c: b94022c1 ldr w1, [x22, #32] <== NOT EXECUTED
rc = rtems_bdbuf_release_modified(diskbuf);
40021480: f9402fe0 ldr x0, [sp, #88] <== NOT EXECUTED
args->bytes_moved += copy;
40021484: 0b190021 add w1, w1, w25 <== NOT EXECUTED
40021488: b90022c1 str w1, [x22, #32] <== NOT EXECUTED
rc = rtems_bdbuf_release_modified(diskbuf);
4002148c: 94002ad5 bl 4002bfe0 <rtems_bdbuf_release_modified> <== NOT EXECUTED
40021490: 2a0003f3 mov w19, w0 <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
40021494: 350001c0 cbnz w0, 400214cc <rtems_blkdev_generic_write+0xcc> <== NOT EXECUTED
while (count > 0)
40021498: 6b190294 subs w20, w20, w25 <== NOT EXECUTED
4002149c: 54000240 b.eq 400214e4 <rtems_blkdev_generic_write+0xe4> // b.none <== NOT EXECUTED
if ((blkofs == 0) && (count >= block_size))
400214a0: 7100027f cmp w19, #0x0 <== NOT EXECUTED
rc = rtems_bdbuf_read(dd, block, &diskbuf);
400214a4: 2a1a03e1 mov w1, w26 <== NOT EXECUTED
400214a8: 910163e2 add x2, sp, #0x58 <== NOT EXECUTED
400214ac: aa1803e0 mov x0, x24 <== NOT EXECUTED
if ((blkofs == 0) && (count >= block_size))
400214b0: 7a5402e2 ccmp w23, w20, #0x2, eq // eq = none <== NOT EXECUTED
400214b4: 54fffca9 b.ls 40021448 <rtems_blkdev_generic_write+0x48> // b.plast<== NOT EXECUTED
rc = rtems_bdbuf_read(dd, block, &diskbuf);
400214b8: 94002a0a bl 4002bce0 <rtems_bdbuf_read> <== NOT EXECUTED
copy = block_size - blkofs;
400214bc: 4b1302e3 sub w3, w23, w19 <== NOT EXECUTED
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
400214c0: aa1503e1 mov x1, x21 <== NOT EXECUTED
400214c4: 6b14007f cmp w3, w20 <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
400214c8: 34fffca0 cbz w0, 4002145c <rtems_blkdev_generic_write+0x5c> <== NOT EXECUTED
}
return rc;
}
400214cc: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400214d0: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400214d4: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
400214d8: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
400214dc: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
400214e0: d65f03c0 ret <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
400214e4: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
}
400214e8: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400214ec: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400214f0: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
400214f4: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
400214f8: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
400214fc: d65f03c0 ret <== NOT EXECUTED
000000004002f0b0 <rtems_blkdev_ioctl>:
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
4002f0b0: 52884064 mov w4, #0x4203 // #16899
4002f0b4: 72a80084 movk w4, #0x4004, lsl #16
{
4002f0b8: aa0003e3 mov x3, x0
switch (req)
4002f0bc: 6b04003f cmp w1, w4
4002f0c0: 54000940 b.eq 4002f1e8 <rtems_blkdev_ioctl+0x138> // b.none
{
4002f0c4: a9bf7bfd stp x29, x30, [sp, #-16]!
4002f0c8: 910003fd mov x29, sp
switch (req)
4002f0cc: 54000229 b.ls 4002f110 <rtems_blkdev_ioctl+0x60> // b.plast
4002f0d0: 52884164 mov w4, #0x420b // #16907
4002f0d4: 72a80104 movk w4, #0x4008, lsl #16
4002f0d8: 6b04003f cmp w1, w4
4002f0dc: 540008e0 b.eq 4002f1f8 <rtems_blkdev_ioctl+0x148> // b.none
4002f0e0: 540004a9 b.ls 4002f174 <rtems_blkdev_ioctl+0xc4> // b.plast
4002f0e4: 52884083 mov w3, #0x4204 // #16900
4002f0e8: 72b00083 movk w3, #0x8004, lsl #16
4002f0ec: 6b03003f cmp w1, w3
4002f0f0: 540008c1 b.ne 4002f208 <rtems_blkdev_ioctl+0x158> // b.any <== NEVER 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);
4002f0f4: b9400041 ldr w1, [x2]
4002f0f8: 52800022 mov w2, #0x1 // #1
4002f0fc: 97ffff75 bl 4002eed0 <rtems_bdbuf_set_block_size>
if (sc != RTEMS_SUCCESSFUL) {
4002f100: 350005e0 cbnz w0, 4002f1bc <rtems_blkdev_ioctl+0x10c> <== NEVER TAKEN
int rc = 0;
4002f104: 52800000 mov w0, #0x0 // #0
rc = -1;
break;
}
return rc;
}
4002f108: a8c17bfd ldp x29, x30, [sp], #16
4002f10c: d65f03c0 ret
switch (req)
4002f110: 52884184 mov w4, #0x420c // #16908
4002f114: 72a40004 movk w4, #0x2000, lsl #16
4002f118: 6b04003f cmp w1, w4
4002f11c: 54000440 b.eq 4002f1a4 <rtems_blkdev_ioctl+0xf4> // b.none
4002f120: 54000149 b.ls 4002f148 <rtems_blkdev_ioctl+0x98> // b.plast
4002f124: 52884040 mov w0, #0x4202 // #16898
4002f128: 72a80080 movk w0, #0x4004, lsl #16
4002f12c: 6b00003f cmp w1, w0
4002f130: 540006c1 b.ne 4002f208 <rtems_blkdev_ioctl+0x158> // b.any <== NEVER TAKEN
*(uint32_t *) argp = dd->media_block_size;
4002f134: b9402c61 ldr w1, [x3, #44]
int rc = 0;
4002f138: 52800000 mov w0, #0x0 // #0
*(uint32_t *) argp = dd->media_block_size;
4002f13c: b9000041 str w1, [x2]
}
4002f140: a8c17bfd ldp x29, x30, [sp], #16
4002f144: d65f03c0 ret
switch (req)
4002f148: 528840c2 mov w2, #0x4206 // #16902
4002f14c: 72a40002 movk w2, #0x2000, lsl #16
4002f150: 6b02003f cmp w1, w2
4002f154: 54000300 b.eq 4002f1b4 <rtems_blkdev_ioctl+0x104> // b.none
4002f158: 11001042 add w2, w2, #0x4
4002f15c: 6b02003f cmp w1, w2
4002f160: 54000541 b.ne 4002f208 <rtems_blkdev_ioctl+0x158> // b.any
rtems_bdbuf_purge_dev(dd);
4002f164: 97ffff4b bl 4002ee90 <rtems_bdbuf_purge_dev>
int rc = 0;
4002f168: 52800000 mov w0, #0x0 // #0
}
4002f16c: a8c17bfd ldp x29, x30, [sp], #16
4002f170: d65f03c0 ret
switch (req)
4002f174: 528840a0 mov w0, #0x4205 // #16901
4002f178: 72a80080 movk w0, #0x4004, lsl #16
4002f17c: 6b00003f cmp w1, w0
4002f180: 540002a0 b.eq 4002f1d4 <rtems_blkdev_ioctl+0x124> // b.none
4002f184: 52884120 mov w0, #0x4209 // #16905
4002f188: 72a80100 movk w0, #0x4008, lsl #16
4002f18c: 6b00003f cmp w1, w0
4002f190: 540003c1 b.ne 4002f208 <rtems_blkdev_ioctl+0x158> // b.any <== NEVER TAKEN
*(rtems_disk_device **) argp = dd;
4002f194: f9000043 str x3, [x2]
int rc = 0;
4002f198: 52800000 mov w0, #0x0 // #0
}
4002f19c: a8c17bfd ldp x29, x30, [sp], #16
4002f1a0: d65f03c0 ret
rtems_bdbuf_reset_device_stats(dd);
4002f1a4: 97ffffaf bl 4002f060 <rtems_bdbuf_reset_device_stats>
int rc = 0;
4002f1a8: 52800000 mov w0, #0x0 // #0
}
4002f1ac: a8c17bfd ldp x29, x30, [sp], #16
4002f1b0: d65f03c0 ret
sc = rtems_bdbuf_syncdev(dd);
4002f1b4: 97ffff0b bl 4002ede0 <rtems_bdbuf_syncdev>
if (sc != RTEMS_SUCCESSFUL) {
4002f1b8: 34fffa60 cbz w0, 4002f104 <rtems_blkdev_ioctl+0x54> <== ALWAYS TAKEN
errno = EIO;
4002f1bc: 940015b4 bl 4003488c <__errno> <== NOT EXECUTED
4002f1c0: aa0003e1 mov x1, x0 <== NOT EXECUTED
4002f1c4: 528000a2 mov w2, #0x5 // #5 <== NOT EXECUTED
rc = -1;
4002f1c8: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
errno = EIO;
4002f1cc: b9000022 str w2, [x1] <== NOT EXECUTED
rc = -1;
4002f1d0: 17ffffce b 4002f108 <rtems_blkdev_ioctl+0x58> <== NOT EXECUTED
*(rtems_blkdev_bnum *) argp = dd->size;
4002f1d4: b9402861 ldr w1, [x3, #40]
int rc = 0;
4002f1d8: 52800000 mov w0, #0x0 // #0
*(rtems_blkdev_bnum *) argp = dd->size;
4002f1dc: b9000041 str w1, [x2]
}
4002f1e0: a8c17bfd ldp x29, x30, [sp], #16
4002f1e4: d65f03c0 ret
*(uint32_t *) argp = dd->block_size;
4002f1e8: b9403061 ldr w1, [x3, #48]
int rc = 0;
4002f1ec: 52800000 mov w0, #0x0 // #0
*(uint32_t *) argp = dd->block_size;
4002f1f0: b9000041 str w1, [x2]
}
4002f1f4: d65f03c0 ret
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
4002f1f8: aa0203e1 mov x1, x2
4002f1fc: 97ffff85 bl 4002f010 <rtems_bdbuf_get_device_stats>
int rc = 0;
4002f200: 52800000 mov w0, #0x0 // #0
4002f204: 17ffffc1 b 4002f108 <rtems_blkdev_ioctl+0x58>
errno = EINVAL;
4002f208: 940015a1 bl 4003488c <__errno>
4002f20c: aa0003e1 mov x1, x0
4002f210: 528002c2 mov w2, #0x16 // #22
rc = -1;
4002f214: 12800000 mov w0, #0xffffffff // #-1
errno = EINVAL;
4002f218: b9000022 str w2, [x1]
}
4002f21c: a8c17bfd ldp x29, x30, [sp], #16
4002f220: d65f03c0 ret
...
0000000040021b10 <rtems_disk_create_log>:
{
40021b10: a9b97bfd stp x29, x30, [sp, #-112]!
40021b14: 910003fd mov x29, sp
40021b18: a9025bf5 stp x21, x22, [sp, #32]
_Mutex_Acquire( mutex );
40021b1c: f00006f5 adrp x21, 40100000 <_RTEMS_tasks_Information>
40021b20: 9103a2b5 add x21, x21, #0xe8
40021b24: a9046bf9 stp x25, x26, [sp, #64]
diskdevs_protected = true;
40021b28: d0000719 adrp x25, 40103000 <_Thread_Heads+0x8>
{
40021b2c: aa0003f6 mov x22, x0
40021b30: 2a0303fa mov w26, w3
40021b34: aa1503e0 mov x0, x21
40021b38: a90153f3 stp x19, x20, [sp, #16]
40021b3c: aa0103f3 mov x19, x1
40021b40: a90363f7 stp x23, x24, [sp, #48]
40021b44: 2a0203f7 mov w23, w2
diskdevs_protected = true;
40021b48: 52800038 mov w24, #0x1 // #1
{
40021b4c: f9002bfb str x27, [sp, #80]
40021b50: aa0403fb mov x27, x4
char *alloc_name = NULL;
40021b54: a9067fff stp xzr, xzr, [sp, #96]
40021b58: 94001552 bl 400270a0 <_Mutex_Acquire>
phys_dd = get_disk_entry(phys, true);
40021b5c: aa1303e0 mov x0, x19
40021b60: 2a1803e1 mov w1, w24
diskdevs_protected = true;
40021b64: 39208338 strb w24, [x25, #2080]
phys_dd = get_disk_entry(phys, true);
40021b68: 97fffe9a bl 400215d0 <get_disk_entry>
if (phys_dd == NULL) {
40021b6c: b4000560 cbz x0, 40021c18 <rtems_disk_create_log+0x108>
sc = create_disk(dev, name, &dd, &alloc_name);
40021b70: aa0003f4 mov x20, x0
40021b74: aa1b03e1 mov x1, x27
40021b78: 9101a3e3 add x3, sp, #0x68
40021b7c: 910183e2 add x2, sp, #0x60
40021b80: aa1603e0 mov x0, x22
40021b84: 97fffeb7 bl 40021660 <create_disk>
40021b88: 2a0003f3 mov w19, w0
if (sc != RTEMS_SUCCESSFUL) {
40021b8c: 350001c0 cbnz w0, 40021bc4 <rtems_disk_create_log+0xb4>
sc = rtems_disk_init_log(
40021b90: f94033e0 ldr x0, [sp, #96]
40021b94: 2a1703e2 mov w2, w23
40021b98: aa1403e1 mov x1, x20
40021b9c: 2a1a03e3 mov w3, w26
40021ba0: 94000114 bl 40021ff0 <rtems_disk_init_log>
40021ba4: 2a0003f3 mov w19, w0
++phys_dd->uses;
40021ba8: b9402280 ldr w0, [x20, #32]
dd->name = alloc_name;
40021bac: a9460be1 ldp x1, x2, [sp, #96]
dd->dev = dev;
40021bb0: f9000036 str x22, [x1]
dd->name = alloc_name;
40021bb4: f9000c22 str x2, [x1, #24]
++phys_dd->uses;
40021bb8: 11000400 add w0, w0, #0x1
40021bbc: b9002280 str w0, [x20, #32]
if (sc != RTEMS_SUCCESSFUL) {
40021bc0: 35000193 cbnz w19, 40021bf0 <rtems_disk_create_log+0xe0>
_Mutex_Release( mutex );
40021bc4: aa1503e0 mov x0, x21
diskdevs_protected = false;
40021bc8: 3920833f strb wzr, [x25, #2080]
40021bcc: 94001551 bl 40027110 <_Mutex_Release>
}
40021bd0: 2a1303e0 mov w0, w19
40021bd4: a94153f3 ldp x19, x20, [sp, #16]
40021bd8: a9425bf5 ldp x21, x22, [sp, #32]
40021bdc: a94363f7 ldp x23, x24, [sp, #48]
40021be0: a9446bf9 ldp x25, x26, [sp, #64]
40021be4: f9402bfb ldr x27, [sp, #80]
40021be8: a8c77bfd ldp x29, x30, [sp], #112
40021bec: d65f03c0 ret
dd->ioctl = null_handler;
40021bf0: 90000000 adrp x0, 40021000 <Init+0x700>
40021bf4: 91194000 add x0, x0, #0x650
40021bf8: f9002420 str x0, [x1, #72]
dd = get_disk_entry(dev, true);
40021bfc: aa1603e0 mov x0, x22
40021c00: 2a1803e1 mov w1, w24
40021c04: 97fffe73 bl 400215d0 <get_disk_entry>
if (dd == NULL) {
40021c08: b4fffde0 cbz x0, 40021bc4 <rtems_disk_create_log+0xb4> <== NEVER TAKEN
dd->deleted = true;
40021c0c: 39016018 strb w24, [x0, #88]
rtems_disk_cleanup(dd);
40021c10: 97ffff1c bl 40021880 <rtems_disk_cleanup.constprop.0>
return RTEMS_SUCCESSFUL;
40021c14: 17ffffec b 40021bc4 <rtems_disk_create_log+0xb4>
40021c18: aa1503e0 mov x0, x21
diskdevs_protected = false;
40021c1c: 3920833f strb wzr, [x25, #2080]
return RTEMS_INVALID_ID;
40021c20: 52800093 mov w19, #0x4 // #4
40021c24: 9400153b bl 40027110 <_Mutex_Release>
}
40021c28: 2a1303e0 mov w0, w19
40021c2c: a94153f3 ldp x19, x20, [sp, #16]
40021c30: a9425bf5 ldp x21, x22, [sp, #32]
40021c34: a94363f7 ldp x23, x24, [sp, #48]
40021c38: a9446bf9 ldp x25, x26, [sp, #64]
40021c3c: f9402bfb ldr x27, [sp, #80]
40021c40: a8c77bfd ldp x29, x30, [sp], #112
40021c44: d65f03c0 ret
...
0000000040021a00 <rtems_disk_create_phys>:
{
40021a00: a9b97bfd stp x29, x30, [sp, #-112]!
40021a04: 910003fd mov x29, sp
40021a08: a90153f3 stp x19, x20, [sp, #16]
char *alloc_name = NULL;
40021a0c: a9067fff stp xzr, xzr, [sp, #96]
if (handler == NULL) {
40021a10: b4000723 cbz x3, 40021af4 <rtems_disk_create_phys+0xf4>
mutex->_Queue._name = name;
}
static __inline void rtems_mutex_lock( rtems_mutex *mutex )
{
_Mutex_Acquire( mutex );
40021a14: a9025bf5 stp x21, x22, [sp, #32]
40021a18: f00006f6 adrp x22, 40100000 <_RTEMS_tasks_Information>
40021a1c: 9103a2d6 add x22, x22, #0xe8
40021a20: a90363f7 stp x23, x24, [sp, #48]
diskdevs_protected = true;
40021a24: d0000718 adrp x24, 40103000 <_Thread_Heads+0x8>
40021a28: aa0503f3 mov x19, x5
40021a2c: aa0003f5 mov x21, x0
40021a30: 2a0103f7 mov w23, w1
40021a34: aa0303f4 mov x20, x3
40021a38: aa1603e0 mov x0, x22
40021a3c: a9046bf9 stp x25, x26, [sp, #64]
40021a40: 2a0203fa mov w26, w2
40021a44: 52800039 mov w25, #0x1 // #1
40021a48: f9002bfb str x27, [sp, #80]
40021a4c: aa0403fb mov x27, x4
40021a50: 94001594 bl 400270a0 <_Mutex_Acquire>
40021a54: 39208319 strb w25, [x24, #2080]
sc = create_disk(dev, name, &dd, &alloc_name);
40021a58: aa1303e1 mov x1, x19
40021a5c: 9101a3e3 add x3, sp, #0x68
40021a60: 910183e2 add x2, sp, #0x60
40021a64: aa1503e0 mov x0, x21
40021a68: 97fffefe bl 40021660 <create_disk>
40021a6c: 2a0003f3 mov w19, w0
if (sc != RTEMS_SUCCESSFUL) {
40021a70: 35000180 cbnz w0, 40021aa0 <rtems_disk_create_phys+0xa0>
sc = rtems_disk_init_phys(
40021a74: f94033e0 ldr x0, [sp, #96]
40021a78: 2a1703e1 mov w1, w23
40021a7c: aa1b03e4 mov x4, x27
40021a80: aa1403e3 mov x3, x20
40021a84: 2a1a03e2 mov w2, w26
40021a88: 94000132 bl 40021f50 <rtems_disk_init_phys>
40021a8c: 2a0003f3 mov w19, w0
dd->name = alloc_name;
40021a90: a94603e1 ldp x1, x0, [sp, #96]
dd->dev = dev;
40021a94: f9000035 str x21, [x1]
dd->name = alloc_name;
40021a98: f9000c20 str x0, [x1, #24]
if (sc != RTEMS_SUCCESSFUL) {
40021a9c: 35000193 cbnz w19, 40021acc <rtems_disk_create_phys+0xcc>
}
static __inline void rtems_mutex_unlock( rtems_mutex *mutex )
{
_Mutex_Release( mutex );
40021aa0: aa1603e0 mov x0, x22
diskdevs_protected = false;
40021aa4: 3920831f strb wzr, [x24, #2080]
40021aa8: 9400159a bl 40027110 <_Mutex_Release>
}
40021aac: 2a1303e0 mov w0, w19
40021ab0: a94153f3 ldp x19, x20, [sp, #16]
return RTEMS_SUCCESSFUL;
40021ab4: a9425bf5 ldp x21, x22, [sp, #32]
40021ab8: a94363f7 ldp x23, x24, [sp, #48]
40021abc: a9446bf9 ldp x25, x26, [sp, #64]
40021ac0: f9402bfb ldr x27, [sp, #80]
}
40021ac4: a8c77bfd ldp x29, x30, [sp], #112
40021ac8: d65f03c0 ret
dd->ioctl = null_handler;
40021acc: 90000000 adrp x0, 40021000 <Init+0x700>
40021ad0: 91194000 add x0, x0, #0x650
40021ad4: f9002420 str x0, [x1, #72]
static rtems_status_code
disk_delete_locked(dev_t dev)
{
rtems_disk_device *dd = NULL;
dd = get_disk_entry(dev, true);
40021ad8: aa1503e0 mov x0, x21
40021adc: 2a1903e1 mov w1, w25
40021ae0: 97fffebc bl 400215d0 <get_disk_entry>
if (dd == NULL) {
40021ae4: b4fffde0 cbz x0, 40021aa0 <rtems_disk_create_phys+0xa0> <== NEVER TAKEN
return RTEMS_INVALID_ID;
}
dd->deleted = true;
40021ae8: 39016019 strb w25, [x0, #88]
rtems_disk_cleanup(dd);
40021aec: 97ffff65 bl 40021880 <rtems_disk_cleanup.constprop.0>
return RTEMS_SUCCESSFUL;
40021af0: 17ffffec b 40021aa0 <rtems_disk_create_phys+0xa0>
return RTEMS_INVALID_ADDRESS;
40021af4: 52800133 mov w19, #0x9 // #9
}
40021af8: 2a1303e0 mov w0, w19
40021afc: a94153f3 ldp x19, x20, [sp, #16]
40021b00: a8c77bfd ldp x29, x30, [sp], #112
40021b04: d65f03c0 ret
...
0000000040021c50 <rtems_disk_delete>:
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
40021c50: a9bd7bfd stp x29, x30, [sp, #-48]!
40021c54: 910003fd mov x29, sp
40021c58: a90153f3 stp x19, x20, [sp, #16]
_Mutex_Acquire( mutex );
40021c5c: f00006f3 adrp x19, 40100000 <_RTEMS_tasks_Information>
40021c60: 9103a273 add x19, x19, #0xe8
40021c64: f90013f5 str x21, [sp, #32]
diskdevs_protected = true;
40021c68: d0000715 adrp x21, 40103000 <_Thread_Heads+0x8>
{
40021c6c: aa0003f4 mov x20, x0
40021c70: aa1303e0 mov x0, x19
40021c74: 9400150b bl 400270a0 <_Mutex_Acquire>
diskdevs_protected = true;
40021c78: 52800025 mov w5, #0x1 // #1
dd = get_disk_entry(dev, true);
40021c7c: aa1403e0 mov x0, x20
40021c80: 2a0503e1 mov w1, w5
diskdevs_protected = true;
40021c84: 392082a5 strb w5, [x21, #2080]
dd = get_disk_entry(dev, true);
40021c88: 97fffe52 bl 400215d0 <get_disk_entry>
if (dd == NULL) {
40021c8c: b4000180 cbz x0, 40021cbc <rtems_disk_delete+0x6c> <== NEVER TAKEN
dd->deleted = true;
40021c90: 39016005 strb w5, [x0, #88]
return RTEMS_SUCCESSFUL;
40021c94: 52800014 mov w20, #0x0 // #0
rtems_disk_cleanup(dd);
40021c98: 97fffefa bl 40021880 <rtems_disk_cleanup.constprop.0>
diskdevs_protected = false;
40021c9c: 392082bf strb wzr, [x21, #2080]
_Mutex_Release( mutex );
40021ca0: aa1303e0 mov x0, x19
40021ca4: 9400151b bl 40027110 <_Mutex_Release>
disk_lock();
sc = disk_delete_locked(dev);
disk_unlock();
return sc;
}
40021ca8: 2a1403e0 mov w0, w20
40021cac: a94153f3 ldp x19, x20, [sp, #16]
40021cb0: f94013f5 ldr x21, [sp, #32]
40021cb4: a8c37bfd ldp x29, x30, [sp], #48
40021cb8: d65f03c0 ret
40021cbc: aa1303e0 mov x0, x19 <== NOT EXECUTED
return RTEMS_INVALID_ID;
40021cc0: 52800094 mov w20, #0x4 // #4 <== NOT EXECUTED
diskdevs_protected = false;
40021cc4: 392082bf strb wzr, [x21, #2080] <== NOT EXECUTED
40021cc8: 94001512 bl 40027110 <_Mutex_Release> <== NOT EXECUTED
}
40021ccc: 2a1403e0 mov w0, w20 <== NOT EXECUTED
40021cd0: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40021cd4: f94013f5 ldr x21, [sp, #32] <== NOT EXECUTED
40021cd8: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
40021cdc: d65f03c0 ret <== NOT EXECUTED
0000000040021ea0 <rtems_disk_io_done>:
rtems_status_code
rtems_disk_io_done(void)
{
40021ea0: a9bc7bfd stp x29, x30, [sp, #-64]!
40021ea4: 910003fd mov x29, sp
40021ea8: a90363f7 stp x23, x24, [sp, #48]
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
40021eac: d0000718 adrp x24, 40103000 <_Thread_Heads+0x8>
40021eb0: b9483300 ldr w0, [x24, #2096]
{
40021eb4: a90153f3 stp x19, x20, [sp, #16]
40021eb8: a9025bf5 stp x21, x22, [sp, #32]
rtems_disk_device_table *dtab = disktab + major;
40021ebc: d0000716 adrp x22, 40103000 <_Thread_Heads+0x8>
40021ec0: f94416d3 ldr x19, [x22, #2088]
for (major = 0; major < disktab_size; ++major) {
40021ec4: 34000300 cbz w0, 40021f24 <rtems_disk_io_done+0x84> <== NEVER TAKEN
40021ec8: 9120c317 add x23, x24, #0x830
40021ecc: 52800015 mov w21, #0x0 // #0
rtems_disk_device_table *dtab = disktab + major;
40021ed0: d37c7ea0 ubfiz x0, x21, #4, #32
40021ed4: 8b000274 add x20, x19, x0
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
40021ed8: f8606a61 ldr x1, [x19, x0]
for (minor = 0; minor < dtab->size; ++minor) {
40021edc: b9400a82 ldr w2, [x20, #8]
40021ee0: 34000162 cbz w2, 40021f0c <rtems_disk_io_done+0x6c>
40021ee4: 52800013 mov w19, #0x0 // #0
rtems_disk_device *dd = dtab->minor [minor];
40021ee8: f8735820 ldr x0, [x1, w19, uxtw #3]
for (minor = 0; minor < dtab->size; ++minor) {
40021eec: 11000673 add w19, w19, #0x1
if (dd != NULL) {
40021ef0: b4000080 cbz x0, 40021f00 <rtems_disk_io_done+0x60> <== ALWAYS TAKEN
free_disk_device(dd);
40021ef4: 97fffe4b bl 40021820 <free_disk_device> <== NOT EXECUTED
40021ef8: b9400a82 ldr w2, [x20, #8] <== NOT EXECUTED
}
}
free(dtab->minor);
40021efc: f9400281 ldr x1, [x20] <== NOT EXECUTED
for (minor = 0; minor < dtab->size; ++minor) {
40021f00: 6b13005f cmp w2, w19
40021f04: 54ffff28 b.hi 40021ee8 <rtems_disk_io_done+0x48> // b.pmore
}
free(disktab);
40021f08: f94416d3 ldr x19, [x22, #2088]
free(dtab->minor);
40021f0c: aa0103e0 mov x0, x1
40021f10: 94000198 bl 40022570 <free>
for (major = 0; major < disktab_size; ++major) {
40021f14: 110006b5 add w21, w21, #0x1
40021f18: b94002e0 ldr w0, [x23]
40021f1c: 6b15001f cmp w0, w21
40021f20: 54fffd88 b.hi 40021ed0 <rtems_disk_io_done+0x30> // b.pmore
free(disktab);
40021f24: aa1303e0 mov x0, x19
40021f28: 94000192 bl 40022570 <free>
disktab = NULL;
disktab_size = 0;
return RTEMS_SUCCESSFUL;
}
40021f2c: 52800000 mov w0, #0x0 // #0
disktab = NULL;
40021f30: f90416df str xzr, [x22, #2088]
disktab_size = 0;
40021f34: b908331f str wzr, [x24, #2096]
}
40021f38: a94153f3 ldp x19, x20, [sp, #16]
40021f3c: a9425bf5 ldp x21, x22, [sp, #32]
40021f40: a94363f7 ldp x23, x24, [sp, #48]
40021f44: a8c47bfd ldp x29, x30, [sp], #64
40021f48: d65f03c0 ret
40021f4c: 00000000 udf #0
0000000040021e20 <rtems_disk_io_initialize>:
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
40021e20: a9be7bfd stp x29, x30, [sp, #-32]!
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
40021e24: 52800000 mov w0, #0x0 // #0
{
40021e28: 910003fd mov x29, sp
40021e2c: a90153f3 stp x19, x20, [sp, #16]
if (disktab_size > 0) {
40021e30: d0000713 adrp x19, 40103000 <_Thread_Heads+0x8>
40021e34: b9483261 ldr w1, [x19, #2096]
40021e38: 34000081 cbz w1, 40021e48 <rtems_disk_io_initialize+0x28> <== ALWAYS TAKEN
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
}
40021e3c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40021e40: a8c27bfd ldp x29, x30, [sp], #32 <== NOT EXECUTED
40021e44: d65f03c0 ret <== NOT EXECUTED
disktab = calloc(size, sizeof(rtems_disk_device_table));
40021e48: d0000714 adrp x20, 40103000 <_Thread_Heads+0x8>
40021e4c: d2800201 mov x1, #0x10 // #16
40021e50: d2800100 mov x0, #0x8 // #8
40021e54: 94000143 bl 40022360 <calloc>
40021e58: f9041680 str x0, [x20, #2088]
if (disktab == NULL) {
40021e5c: b4000180 cbz x0, 40021e8c <rtems_disk_io_initialize+0x6c> <== NEVER TAKEN
sc = rtems_bdbuf_init();
40021e60: 94002748 bl 4002bb80 <rtems_bdbuf_init>
if (sc != RTEMS_SUCCESSFUL) {
40021e64: 350000c0 cbnz w0, 40021e7c <rtems_disk_io_initialize+0x5c> <== NEVER TAKEN
disktab_size = size;
40021e68: 52800101 mov w1, #0x8 // #8
40021e6c: b9083261 str w1, [x19, #2096]
}
40021e70: a94153f3 ldp x19, x20, [sp, #16]
40021e74: a8c27bfd ldp x29, x30, [sp], #32
40021e78: d65f03c0 ret
free(disktab);
40021e7c: f9441680 ldr x0, [x20, #2088] <== NOT EXECUTED
40021e80: 940001bc bl 40022570 <free> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
40021e84: 528001a0 mov w0, #0xd // #13 <== NOT EXECUTED
40021e88: 17ffffed b 40021e3c <rtems_disk_io_initialize+0x1c> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
40021e8c: 52800340 mov w0, #0x1a // #26 <== NOT EXECUTED
40021e90: 17ffffeb b 40021e3c <rtems_disk_io_initialize+0x1c> <== NOT EXECUTED
...
0000000040021ce0 <rtems_disk_obtain>:
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
40021ce0: a9bd7bfd stp x29, x30, [sp, #-48]!
40021ce4: 910003fd mov x29, sp
40021ce8: a90153f3 stp x19, x20, [sp, #16]
#else
static inline uint64_t AArch64_interrupt_disable( void )
{
uint64_t level;
__asm__ volatile (
40021cec: d53b4225 mrs x5, daif
40021cf0: d50342df msr daifset, #0x2
rtems_disk_device *dd = NULL;
rtems_interrupt_lock_context lock_context;
rtems_interrupt_lock_acquire(&diskdevs_lock, &lock_context);
if (!diskdevs_protected) {
40021cf4: d0000714 adrp x20, 40103000 <_Thread_Heads+0x8>
40021cf8: 39608281 ldrb w1, [x20, #2080]
40021cfc: 72001c3f tst w1, #0xff
40021d00: 54000121 b.ne 40021d24 <rtems_disk_obtain+0x44> // b.any <== NEVER TAKEN
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
40021d04: 97fffe33 bl 400215d0 <get_disk_entry>
40021d08: aa0003f3 mov x19, x0
return level;
}
static inline void AArch64_interrupt_enable( uint64_t level )
{
__asm__ volatile (
40021d0c: 92407ca5 and x5, x5, #0xffffffff
40021d10: d51b4225 msr daif, x5
dd = get_disk_entry(dev, false);
disk_unlock();
}
return dd;
}
40021d14: aa1303e0 mov x0, x19
40021d18: a94153f3 ldp x19, x20, [sp, #16]
40021d1c: a8c37bfd ldp x29, x30, [sp], #48
40021d20: d65f03c0 ret
40021d24: aa0003f3 mov x19, x0 <== NOT EXECUTED
rtems_interrupt_lock_release(&diskdevs_lock, &lock_context);
40021d28: f90013f5 str x21, [sp, #32] <== NOT EXECUTED
40021d2c: 92407ca5 and x5, x5, #0xffffffff <== NOT EXECUTED
40021d30: d51b4225 msr daif, x5 <== NOT EXECUTED
_Mutex_Acquire( mutex );
40021d34: f00006f5 adrp x21, 40100000 <_RTEMS_tasks_Information> <== NOT EXECUTED
40021d38: 9103a2b5 add x21, x21, #0xe8 <== NOT EXECUTED
40021d3c: aa1503e0 mov x0, x21 <== NOT EXECUTED
40021d40: 940014d8 bl 400270a0 <_Mutex_Acquire> <== NOT EXECUTED
diskdevs_protected = true;
40021d44: 52800022 mov w2, #0x1 // #1 <== NOT EXECUTED
dd = get_disk_entry(dev, false);
40021d48: 52800001 mov w1, #0x0 // #0 <== NOT EXECUTED
diskdevs_protected = true;
40021d4c: 39208282 strb w2, [x20, #2080] <== NOT EXECUTED
dd = get_disk_entry(dev, false);
40021d50: aa1303e0 mov x0, x19 <== NOT EXECUTED
40021d54: 97fffe1f bl 400215d0 <get_disk_entry> <== NOT EXECUTED
diskdevs_protected = false;
40021d58: 3920829f strb wzr, [x20, #2080] <== NOT EXECUTED
dd = get_disk_entry(dev, false);
40021d5c: aa0003f3 mov x19, x0 <== NOT EXECUTED
_Mutex_Release( mutex );
40021d60: aa1503e0 mov x0, x21 <== NOT EXECUTED
40021d64: 940014eb bl 40027110 <_Mutex_Release> <== NOT EXECUTED
}
40021d68: aa1303e0 mov x0, x19 <== NOT EXECUTED
40021d6c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40021d70: f94013f5 ldr x21, [sp, #32] <== NOT EXECUTED
40021d74: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
40021d78: d65f03c0 ret <== NOT EXECUTED
40021d7c: 00000000 udf #0
0000000040021d80 <rtems_disk_release>:
rtems_status_code
rtems_disk_release(rtems_disk_device *dd)
{
40021d80: a9bd7bfd stp x29, x30, [sp, #-48]!
40021d84: 910003fd mov x29, sp
40021d88: a90153f3 stp x19, x20, [sp, #16]
rtems_interrupt_lock_context lock_context; dev_t dev = dd->dev;
40021d8c: f9400014 ldr x20, [x0]
__asm__ volatile (
40021d90: d53b4222 mrs x2, daif
40021d94: d50342df msr daifset, #0x2
unsigned uses = 0;
bool deleted = false;
rtems_interrupt_lock_acquire(&diskdevs_lock, &lock_context);
uses = --dd->uses;
40021d98: b9402001 ldr w1, [x0, #32]
deleted = dd->deleted;
40021d9c: 39416003 ldrb w3, [x0, #88]
uses = --dd->uses;
40021da0: 71000421 subs w1, w1, #0x1
40021da4: b9002001 str w1, [x0, #32]
__asm__ volatile (
40021da8: 92407c40 and x0, x2, #0xffffffff
40021dac: d51b4220 msr daif, x0
rtems_interrupt_lock_release(&diskdevs_lock, &lock_context);
if (uses == 0 && deleted) {
40021db0: 7a400864 ccmp w3, #0x0, #0x4, eq // eq = none
40021db4: 540000a1 b.ne 40021dc8 <rtems_disk_release+0x48> // b.any
rtems_disk_delete(dev);
}
return RTEMS_SUCCESSFUL;
}
40021db8: 52800000 mov w0, #0x0 // #0
40021dbc: a94153f3 ldp x19, x20, [sp, #16]
40021dc0: a8c37bfd ldp x29, x30, [sp], #48
40021dc4: d65f03c0 ret
_Mutex_Acquire( mutex );
40021dc8: f00006f3 adrp x19, 40100000 <_RTEMS_tasks_Information>
40021dcc: 9103a273 add x19, x19, #0xe8
40021dd0: f90013f5 str x21, [sp, #32]
diskdevs_protected = true;
40021dd4: d0000715 adrp x21, 40103000 <_Thread_Heads+0x8>
40021dd8: aa1303e0 mov x0, x19
40021ddc: 940014b1 bl 400270a0 <_Mutex_Acquire>
40021de0: 52800025 mov w5, #0x1 // #1
dd = get_disk_entry(dev, true);
40021de4: aa1403e0 mov x0, x20
40021de8: 2a0503e1 mov w1, w5
diskdevs_protected = true;
40021dec: 392082a5 strb w5, [x21, #2080]
dd = get_disk_entry(dev, true);
40021df0: 97fffdf8 bl 400215d0 <get_disk_entry>
if (dd == NULL) {
40021df4: b4000060 cbz x0, 40021e00 <rtems_disk_release+0x80> <== NEVER TAKEN
dd->deleted = true;
40021df8: 39016005 strb w5, [x0, #88]
rtems_disk_cleanup(dd);
40021dfc: 97fffea1 bl 40021880 <rtems_disk_cleanup.constprop.0>
_Mutex_Release( mutex );
40021e00: aa1303e0 mov x0, x19
diskdevs_protected = false;
40021e04: 392082bf strb wzr, [x21, #2080]
40021e08: 940014c2 bl 40027110 <_Mutex_Release>
}
40021e0c: 52800000 mov w0, #0x0 // #0
40021e10: a94153f3 ldp x19, x20, [sp, #16]
40021e14: f94013f5 ldr x21, [sp, #32]
40021e18: a8c37bfd ldp x29, x30, [sp], #48
40021e1c: d65f03c0 ret
00000000400245e0 <rtems_fdisk_initialize>:
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg RTEMS_UNUSED)
{
400245e0: a9b87bfd stp x29, x30, [sp, #-128]!
400245e4: 910003fd mov x29, sp
400245e8: a90363f7 stp x23, x24, [sp, #48]
400245ec: 2a0003f8 mov w24, w0
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
400245f0: d2804000 mov x0, #0x200 // #512
{
400245f4: a90573fb stp x27, x28, [sp, #80]
400245f8: b90067f8 str w24, [sp, #100]
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
400245fc: 9400037d bl 400253f0 <malloc>
40024600: f0000761 adrp x1, 40113000 <flashdisk_data+0xf2a0>
40024604: f907a020 str x0, [x1, #3904]
if (!rtems_fdisk_crc16_factor)
40024608: b4001f60 cbz x0, 400249f4 <rtems_fdisk_initialize+0x414> <== NEVER TAKEN
4002460c: aa0003e6 mov x6, x0
40024610: d2800004 mov x4, #0x0 // #0
40024614: 128f7ee3 mov w3, #0xffff8408 // #-31736
40024618: a90153f3 stp x19, x20, [sp, #16]
4002461c: d503201f nop
uint16_t v = b;
40024620: 12003c80 and w0, w4, #0xffff
for (i = 8; i--;)
40024624: 5280011b mov w27, #0x8 // #8
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
40024628: 72000002 ands w2, w0, #0x1
4002462c: 53017c00 lsr w0, w0, #1
40024630: 4a030001 eor w1, w0, w3
40024634: 12003c21 and w1, w1, #0xffff
40024638: 1a810000 csel w0, w0, w1, eq // eq = none
for (i = 8; i--;)
4002463c: 7100077b subs w27, w27, #0x1
40024640: 54ffff41 b.ne 40024628 <rtems_fdisk_initialize+0x48> // b.any
rtems_fdisk_crc16_factor[b] = v & 0xffff;
40024644: 782478c0 strh w0, [x6, x4, lsl #1]
for (b = 0; b < 256; b++)
40024648: 91000484 add x4, x4, #0x1
4002464c: f104009f cmp x4, #0x100
40024650: 54fffe81 b.ne 40024620 <rtems_fdisk_initialize+0x40> // b.any
sc = rtems_fdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
fd = calloc (rtems_flashdisk_configuration_size, sizeof (*fd));
40024654: 900006e0 adrp x0, 40100000 <_IO_Driver_address_table>
40024658: b9411014 ldr w20, [x0, #272]
4002465c: d2801a01 mov x1, #0xd0 // #208
40024660: 2a1403e0 mov w0, w20
40024664: 94000127 bl 40024b00 <calloc>
40024668: aa0003f3 mov x19, x0
if (!fd)
4002466c: b4001c20 cbz x0, 400249f0 <rtems_fdisk_initialize+0x410> <== NEVER TAKEN
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++, fd++)
40024670: 34001e34 cbz w20, 40024a34 <rtems_fdisk_initialize+0x454> <== NEVER TAKEN
40024674: a9025bf5 stp x21, x22, [sp, #32]
const rtems_flashdisk_config* c = rtems_flashdisk_configuration;
40024678: d0000156 adrp x22, 4004e000 <_User_extensions_Initial_extensions+0x30>
4002467c: 910822d6 add x22, x22, #0x208
40024680: 52800194 mov w20, #0xc // #12
40024684: a9046bf9 stp x25, x26, [sp, #64]
static __inline void
_Mutex_Initialize_named(struct _Mutex_Control *_mutex, const char *_name)
{
struct _Mutex_Control _init = _MUTEX_NAMED_INITIALIZER(_name);
*_mutex = _init;
40024688: f0000159 adrp x25, 4004f000 <black_list.3+0x9d0>
4002468c: 9105a320 add x0, x25, #0x168
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++, fd++)
40024690: b90063ff str wzr, [sp, #96]
40024694: f90037e0 str x0, [sp, #104]
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
40024698: d28c85e4 mov x4, #0x642f // #25647
4002469c: f2aecca4 movk x4, #0x7665, lsl #16
400246a0: 52800c20 mov w0, #0x61 // #97
400246a4: f2ccc5e4 movk x4, #0x662f, lsl #32
400246a8: f2ec8c84 movk x4, #0x6464, lsl #48
uint32_t blocks = 0;
int ret;
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
400246ac: b94067e5 ldr w5, [sp, #100]
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
400246b0: 294066dc ldp w28, w25, [x22]
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
400246b4: f9003be4 str x4, [sp, #112]
fd->unavail_blocks = c->unavail_blocks;
400246b8: 294256c3 ldp w3, w21, [x22, #16]
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
400246bc: 7900f3e0 strh w0, [sp, #120]
fd->avail_compact_segs = c->avail_compact_segs;
400246c0: 294306c2 ldp w2, w1, [x22, #24]
fd->compact_segs = c->compact_segs;
400246c4: 29010a63 stp w3, w2, [x19, #8]
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
400246c8: b94063e4 ldr w4, [sp, #96]
fd->info_level = c->info_level;
400246cc: b94022c0 ldr w0, [x22, #32]
fd->minor = minor;
400246d0: 29001265 stp w5, w4, [x19]
fd->block_size = c->block_size;
400246d4: 29027261 stp w1, w28, [x19, #16]
fd->unavail_blocks = c->unavail_blocks;
400246d8: b9002675 str w21, [x19, #36]
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
400246dc: 3901e7e4 strb w4, [sp, #121]
fd->info_level = c->info_level;
400246e0: b900ca60 str w0, [x19, #200]
for (device = 0; device < c->device_count; device++)
400246e4: 34000459 cbz w25, 4002476c <rtems_fdisk_initialize+0x18c> <== NEVER TAKEN
400246e8: f94006c1 ldr x1, [x22, #8]
400246ec: 5100072b sub w11, w25, #0x1
400246f0: 52800300 mov w0, #0x18 // #24
uint32_t blocks = 0;
400246f4: 52800018 mov w24, #0x0 // #0
400246f8: 9100602a add x10, x1, #0x18
400246fc: 9ba0296b umaddl x11, w11, w0, x10
for (s = 0; s < dd->segment_count; s++)
40024700: b9400020 ldr w0, [x1]
40024704: 340002a0 cbz w0, 40024758 <rtems_fdisk_initialize+0x178> <== NEVER TAKEN
40024708: f9400424 ldr x4, [x1, #8]
4002470c: 51000400 sub w0, w0, #0x1
uint32_t count = 0;
40024710: 52800006 mov w6, #0x0 // #0
40024714: 91003083 add x3, x4, #0xc
40024718: 9bb40c08 umaddl x8, w0, w20, x3
4002471c: d503201f nop
return sd->size / page_size;
40024720: b9400880 ldr w0, [x4, #8]
for (s = 0; s < dd->segment_count; s++)
40024724: eb03011f cmp x8, x3
rtems_fdisk_page_desc_pages (sd, page_size)) * sd->count;
40024728: 79400087 ldrh w7, [x4]
for (s = 0; s < dd->segment_count; s++)
4002472c: aa0303e4 mov x4, x3
40024730: 91003063 add x3, x3, #0xc
return sd->size / page_size;
40024734: 1adc0800 udiv w0, w0, w28
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
40024738: 531d7001 lsl w1, w0, #3
(rtems_fdisk_pages_in_segment (sd, page_size) -
4002473c: 51000400 sub w0, w0, #0x1
return ((bytes - 1) / page_size) + 1;
40024740: 51000421 sub w1, w1, #0x1
40024744: 1adc0821 udiv w1, w1, w28
(rtems_fdisk_pages_in_segment (sd, page_size) -
40024748: 4b010000 sub w0, w0, w1
count +=
4002474c: 1b071806 madd w6, w0, w7, w6
for (s = 0; s < dd->segment_count; s++)
40024750: 54fffe81 b.ne 40024720 <rtems_fdisk_initialize+0x140> // b.any <== NEVER TAKEN
blocks += rtems_fdisk_blocks_in_device (&c->devices[device],
40024754: 0b060318 add w24, w24, w6
for (device = 0; device < c->device_count; device++)
40024758: eb0a017f cmp x11, x10
4002475c: aa0a03e1 mov x1, x10
40024760: 54000080 b.eq 40024770 <rtems_fdisk_initialize+0x190> // b.none <== ALWAYS TAKEN
40024764: 9100614a add x10, x10, #0x18 <== NOT EXECUTED
40024768: 17ffffe6 b 40024700 <rtems_fdisk_initialize+0x120> <== NOT EXECUTED
uint32_t blocks = 0;
4002476c: 52800018 mov w24, #0x0 // #0 <== NOT EXECUTED
c->block_size);
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
40024770: 2a1c03e0 mov w0, w28
40024774: 9400031f bl 400253f0 <malloc>
40024778: f9006260 str x0, [x19, #192]
if (!fd->copy_buffer)
4002477c: b4001560 cbz x0, 40024a28 <rtems_fdisk_initialize+0x448> <== NEVER TAKEN
return RTEMS_NO_MEMORY;
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
40024780: 2a1803e0 mov w0, w24
40024784: d2800201 mov x1, #0x10 // #16
40024788: 940000de bl 40024b00 <calloc>
4002478c: f9000e60 str x0, [x19, #24]
if (!fd->blocks)
40024790: b40014c0 cbz x0, 40024a28 <rtems_fdisk_initialize+0x448> <== NEVER TAKEN
return RTEMS_NO_MEMORY;
fd->block_count = blocks;
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
40024794: 2a1903e0 mov w0, w25
40024798: d2800301 mov x1, #0x18 // #24
fd->block_count = blocks;
4002479c: b9002278 str w24, [x19, #32]
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
400247a0: 940000d8 bl 40024b00 <calloc>
400247a4: f9001a60 str x0, [x19, #48]
if (!fd->devices)
400247a8: b4001400 cbz x0, 40024a28 <rtems_fdisk_initialize+0x448> <== NEVER TAKEN
400247ac: f94037e5 ldr x5, [sp, #104]
return RTEMS_NO_MEMORY;
rtems_mutex_init (&fd->lock, "Flash Disk");
sc = rtems_blkdev_create(name, c->block_size, blocks - fd->unavail_blocks,
400247b0: 4b150302 sub w2, w24, w21
400247b4: 2a1c03e1 mov w1, w28
400247b8: 9101c3e0 add x0, sp, #0x70
400247bc: aa1303e4 mov x4, x19
400247c0: f0ffffe3 adrp x3, 40023000 <rtems_fdisk_recover_block_mappings>
400247c4: 910ec063 add x3, x3, #0x3b0
400247c8: 29147e7f stp wzr, wzr, [x19, #160]
400247cc: a90afe7f stp xzr, xzr, [x19, #168]
400247d0: f9005e65 str x5, [x19, #184]
400247d4: 940032f7 bl 400313b0 <rtems_blkdev_create>
400247d8: 2a0003f5 mov w21, w0
rtems_fdisk_ioctl, fd);
if (sc != RTEMS_SUCCESSFUL)
400247dc: 35000d00 cbnz w0, 4002497c <rtems_fdisk_initialize+0x39c> <== NEVER TAKEN
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
400247e0: b94006d5 ldr w21, [x22, #4]
400247e4: 34000755 cbz w21, 400248cc <rtems_fdisk_initialize+0x2ec> <== NEVER TAKEN
400247e8: f94006d9 ldr x25, [x22, #8]
400247ec: 5280001c mov w28, #0x0 // #0
400247f0: f9401a78 ldr x24, [x19, #48]
400247f4: d503201f nop
for (segment = 0; segment < dd->segment_count; segment++)
400247f8: b9400320 ldr w0, [x25]
400247fc: 340004e0 cbz w0, 40024898 <rtems_fdisk_initialize+0x2b8> <== NEVER TAKEN
40024800: f9400721 ldr x1, [x25, #8]
40024804: 51000417 sub w23, w0, #0x1
uint32_t count = 0;
40024808: 5280001a mov w26, #0x0 // #0
4002480c: 91003020 add x0, x1, #0xc
40024810: 9bb402e3 umaddl x3, w23, w20, x0
40024814: d503201f nop
count += dd->segments[segment].count;
40024818: 79400022 ldrh w2, [x1]
for (segment = 0; segment < dd->segment_count; segment++)
4002481c: eb00007f cmp x3, x0
40024820: aa0003e1 mov x1, x0
40024824: 91003000 add x0, x0, #0xc
count += dd->segments[segment].count;
40024828: 0b02035a add w26, w26, w2
for (segment = 0; segment < dd->segment_count; segment++)
4002482c: 54ffff61 b.ne 40024818 <rtems_fdisk_initialize+0x238> // b.any <== NEVER TAKEN
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
40024830: 2a1a03e0 mov w0, w26
40024834: d2800801 mov x1, #0x40 // #64
40024838: 940000b2 bl 40024b00 <calloc>
4002483c: f9000300 str x0, [x24]
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
40024840: b4000de0 cbz x0, 400249fc <rtems_fdisk_initialize+0x41c> <== NEVER TAKEN
40024844: f9400723 ldr x3, [x25, #8]
40024848: 91003066 add x6, x3, #0xc
4002484c: 9bb41aea umaddl x10, w23, w20, x6
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++)
40024850: 79400064 ldrh w4, [x3]
40024854: 34000184 cbz w4, 40024884 <rtems_fdisk_initialize+0x2a4> <== NEVER TAKEN
40024858: aa0003e1 mov x1, x0
4002485c: 52800002 mov w2, #0x0 // #0
{
sc->descriptor = sd;
40024860: f9000423 str x3, [x1, #8]
sc->device = device;
sc->segment = seg_segment;
40024864: 2902083c stp w28, w2, [x1, #16]
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
40024868: 11000442 add w2, w2, #0x1
sc->erased = 0;
4002486c: b900383f str wzr, [x1, #56]
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
40024870: 6b04005f cmp w2, w4
40024874: 91010021 add x1, x1, #0x40
40024878: 54ffff41 b.ne 40024860 <rtems_fdisk_initialize+0x280> // b.any
4002487c: d37a7c42 ubfiz x2, x2, #6, #32
40024880: 8b020000 add x0, x0, x2
for (segment = 0; segment < c->devices[device].segment_count; segment++)
40024884: eb06015f cmp x10, x6
40024888: aa0603e3 mov x3, x6
4002488c: 54000120 b.eq 400248b0 <rtems_fdisk_initialize+0x2d0> // b.none <== ALWAYS TAKEN
40024890: 910030c6 add x6, x6, #0xc <== NOT EXECUTED
40024894: 17ffffef b 40024850 <rtems_fdisk_initialize+0x270> <== NOT EXECUTED
fd->devices[device].segments = calloc (segment_count,
40024898: d2800801 mov x1, #0x40 // #64 <== NOT EXECUTED
4002489c: d2800000 mov x0, #0x0 // #0 <== NOT EXECUTED
400248a0: 94000098 bl 40024b00 <calloc> <== NOT EXECUTED
400248a4: f9000300 str x0, [x24] <== NOT EXECUTED
if (!fd->devices[device].segments)
400248a8: b4000aa0 cbz x0, 400249fc <rtems_fdisk_initialize+0x41c> <== NOT EXECUTED
uint32_t count = 0;
400248ac: 5280001a mov w26, #0x0 // #0 <== NOT EXECUTED
}
}
fd->devices[device].segment_count = segment_count;
400248b0: b9000b1a str w26, [x24, #8]
for (device = 0; device < c->device_count; device++)
400248b4: 1100079c add w28, w28, #0x1
fd->devices[device].descriptor = &c->devices[device];
400248b8: f9000b19 str x25, [x24, #16]
for (device = 0; device < c->device_count; device++)
400248bc: 6b15039f cmp w28, w21
400248c0: 91006339 add x25, x25, #0x18
400248c4: 91006318 add x24, x24, #0x18
400248c8: 54fff981 b.ne 400247f8 <rtems_fdisk_initialize+0x218> // b.any <== NEVER TAKEN
}
fd->device_count = c->device_count;
ret = rtems_fdisk_recover_block_mappings (fd);
400248cc: aa1303e0 mov x0, x19
fd->device_count = c->device_count;
400248d0: b9003a75 str w21, [x19, #56]
ret = rtems_fdisk_recover_block_mappings (fd);
400248d4: 97fff9cb bl 40023000 <rtems_fdisk_recover_block_mappings>
400248d8: 2a0003fc mov w28, w0
if (ret)
400248dc: 35000660 cbnz w0, 400249a8 <rtems_fdisk_initialize+0x3c8> <== NEVER TAKEN
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
strerror (ret), ret);
return ret;
}
ret = rtems_fdisk_compact (fd);
400248e0: aa1303e0 mov x0, x19
400248e4: 97fff913 bl 40022d30 <rtems_fdisk_compact>
400248e8: 2a0003fc mov w28, w0
if (ret)
400248ec: 35000240 cbnz w0, 40024934 <rtems_fdisk_initialize+0x354> <== NEVER TAKEN
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++, fd++)
400248f0: b94063e1 ldr w1, [sp, #96]
400248f4: 900006e0 adrp x0, 40100000 <_IO_Driver_address_table>
400248f8: b9411000 ldr w0, [x0, #272]
400248fc: 9100a2d6 add x22, x22, #0x28
40024900: 11000421 add w1, w1, #0x1
40024904: b90063e1 str w1, [sp, #96]
40024908: 91034273 add x19, x19, #0xd0
4002490c: 6b01001f cmp w0, w1
40024910: 54ffec48 b.hi 40024698 <rtems_fdisk_initialize+0xb8> // b.pmore <== NEVER TAKEN
40024914: a94153f3 ldp x19, x20, [sp, #16]
40024918: a9425bf5 ldp x21, x22, [sp, #32]
4002491c: a9446bf9 ldp x25, x26, [sp, #64]
return ret;
}
}
return RTEMS_SUCCESSFUL;
}
40024920: 2a1b03e0 mov w0, w27
40024924: a94363f7 ldp x23, x24, [sp, #48]
40024928: a94573fb ldp x27, x28, [sp, #80]
4002492c: a8c87bfd ldp x29, x30, [sp], #128
40024930: d65f03c0 ret
unlink (name);
40024934: 9101c3e0 add x0, sp, #0x70 <== NOT EXECUTED
40024938: 94000a4a bl 40027260 <unlink> <== NOT EXECUTED
free (fd->copy_buffer);
4002493c: f9406260 ldr x0, [x19, #192] <== NOT EXECUTED
return ret;
40024940: 2a1c03f5 mov w21, w28 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
40024944: 2a1503fb mov w27, w21 <== NOT EXECUTED
free (fd->copy_buffer);
40024948: 9400012e bl 40024e00 <free> <== NOT EXECUTED
free (fd->blocks);
4002494c: f9400e60 ldr x0, [x19, #24] <== NOT EXECUTED
40024950: 9400012c bl 40024e00 <free> <== NOT EXECUTED
free (fd->devices);
40024954: f9401a60 ldr x0, [x19, #48] <== NOT EXECUTED
40024958: 9400012a bl 40024e00 <free> <== NOT EXECUTED
rtems_fdisk_error ("compacting of disk failed: %s (%d)",
4002495c: 2a1c03e0 mov w0, w28 <== NOT EXECUTED
40024960: 940073e5 bl 400418f4 <strerror> <== NOT EXECUTED
40024964: 2a1c03e2 mov w2, w28 <== NOT EXECUTED
40024968: aa0003e1 mov x1, x0 <== NOT EXECUTED
4002496c: f0000140 adrp x0, 4004f000 <black_list.3+0x9d0> <== NOT EXECUTED
40024970: 9106e000 add x0, x0, #0x1b8 <== NOT EXECUTED
40024974: 97fff5bb bl 40022060 <rtems_fdisk_error> <== NOT EXECUTED
return ret;
40024978: 17ffffe7 b 40024914 <rtems_fdisk_initialize+0x334> <== NOT EXECUTED
free (fd->copy_buffer);
4002497c: f9406260 ldr x0, [x19, #192] <== NOT EXECUTED
return RTEMS_NO_MEMORY;
40024980: 2a1503fb mov w27, w21 <== NOT EXECUTED
free (fd->copy_buffer);
40024984: 9400011f bl 40024e00 <free> <== NOT EXECUTED
free (fd->blocks);
40024988: f9400e60 ldr x0, [x19, #24] <== NOT EXECUTED
4002498c: 9400011d bl 40024e00 <free> <== NOT EXECUTED
free (fd->devices);
40024990: f9401a60 ldr x0, [x19, #48] <== NOT EXECUTED
40024994: 9400011b bl 40024e00 <free> <== NOT EXECUTED
rtems_fdisk_error ("disk create phy failed");
40024998: f0000140 adrp x0, 4004f000 <black_list.3+0x9d0> <== NOT EXECUTED
4002499c: 9105e000 add x0, x0, #0x178 <== NOT EXECUTED
400249a0: 97fff5b0 bl 40022060 <rtems_fdisk_error> <== NOT EXECUTED
return sc;
400249a4: 17ffffdc b 40024914 <rtems_fdisk_initialize+0x334> <== NOT EXECUTED
unlink (name);
400249a8: 9101c3e0 add x0, sp, #0x70 <== NOT EXECUTED
400249ac: 94000a2d bl 40027260 <unlink> <== NOT EXECUTED
free (fd->copy_buffer);
400249b0: f9406260 ldr x0, [x19, #192] <== NOT EXECUTED
return ret;
400249b4: 2a1c03f5 mov w21, w28 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
400249b8: 2a1503fb mov w27, w21 <== NOT EXECUTED
free (fd->copy_buffer);
400249bc: 94000111 bl 40024e00 <free> <== NOT EXECUTED
free (fd->blocks);
400249c0: f9400e60 ldr x0, [x19, #24] <== NOT EXECUTED
400249c4: 9400010f bl 40024e00 <free> <== NOT EXECUTED
free (fd->devices);
400249c8: f9401a60 ldr x0, [x19, #48] <== NOT EXECUTED
400249cc: 9400010d bl 40024e00 <free> <== NOT EXECUTED
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
400249d0: 2a1c03e0 mov w0, w28 <== NOT EXECUTED
400249d4: 940073c8 bl 400418f4 <strerror> <== NOT EXECUTED
400249d8: 2a1c03e2 mov w2, w28 <== NOT EXECUTED
400249dc: aa0003e1 mov x1, x0 <== NOT EXECUTED
400249e0: f0000140 adrp x0, 4004f000 <black_list.3+0x9d0> <== NOT EXECUTED
400249e4: 91064000 add x0, x0, #0x190 <== NOT EXECUTED
400249e8: 97fff59e bl 40022060 <rtems_fdisk_error> <== NOT EXECUTED
return ret;
400249ec: 17ffffca b 40024914 <rtems_fdisk_initialize+0x334> <== NOT EXECUTED
400249f0: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
return RTEMS_NO_MEMORY;
400249f4: 5280035b mov w27, #0x1a // #26 <== NOT EXECUTED
400249f8: 17ffffca b 40024920 <rtems_fdisk_initialize+0x340> <== NOT EXECUTED
unlink (name);
400249fc: 9101c3e0 add x0, sp, #0x70 <== NOT EXECUTED
40024a00: 94000a18 bl 40027260 <unlink> <== NOT EXECUTED
free (fd->copy_buffer);
40024a04: f9406260 ldr x0, [x19, #192] <== NOT EXECUTED
return RTEMS_NO_MEMORY;
40024a08: 52800355 mov w21, #0x1a // #26 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
40024a0c: 2a1503fb mov w27, w21 <== NOT EXECUTED
free (fd->copy_buffer);
40024a10: 940000fc bl 40024e00 <free> <== NOT EXECUTED
free (fd->blocks);
40024a14: f9400e60 ldr x0, [x19, #24] <== NOT EXECUTED
40024a18: 940000fa bl 40024e00 <free> <== NOT EXECUTED
free (fd->devices);
40024a1c: f9401a60 ldr x0, [x19, #48] <== NOT EXECUTED
40024a20: 940000f8 bl 40024e00 <free> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
40024a24: 17ffffbc b 40024914 <rtems_fdisk_initialize+0x334> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
40024a28: 52800355 mov w21, #0x1a // #26 <== NOT EXECUTED
40024a2c: 2a1503fb mov w27, w21 <== NOT EXECUTED
40024a30: 17ffffb9 b 40024914 <rtems_fdisk_initialize+0x334> <== NOT EXECUTED
40024a34: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40024a38: 17ffffba b 40024920 <rtems_fdisk_initialize+0x340> <== NOT EXECUTED
40024a3c: 00000000 udf #0
0000000040022dd0 <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)
{
40022dd0: a9b97bfd stp x29, x30, [sp, #-112]!
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));
40022dd4: d2804301 mov x1, #0x218 // #536
{
40022dd8: 910003fd mov x29, sp
40022ddc: a9025bf5 stp x21, x22, [sp, #32]
40022de0: aa0003f6 mov x22, x0
disk_desc = (rtems_disk_desc_t *) calloc(1, sizeof(rtems_disk_desc_t));
40022de4: d2800020 mov x0, #0x1 // #1
{
40022de8: a9046bf9 stp x25, x26, [sp, #64]
disk_desc = (rtems_disk_desc_t *) calloc(1, sizeof(rtems_disk_desc_t));
40022dec: 94000125 bl 40023280 <calloc>
if (disk_desc == NULL)
40022df0: b4000ac0 cbz x0, 40022f48 <rtems_ide_part_table_initialize+0x178> <== NEVER TAKEN
{
return RTEMS_NO_MEMORY;
}
/* get partition table */
rc = partition_table_get(dev_name, disk_desc);
40022df4: aa0003e1 mov x1, x0
40022df8: a90363f7 stp x23, x24, [sp, #48]
40022dfc: aa0003f8 mov x24, x0
40022e00: aa1603e0 mov x0, x22
40022e04: 97fffeb7 bl 400228e0 <partition_table_get>
40022e08: 2a0003fa mov w26, w0
if (rc != RTEMS_SUCCESSFUL)
40022e0c: 350008e0 cbnz w0, 40022f28 <rtems_ide_part_table_initialize+0x158> <== NEVER 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++)
40022e10: b9401f00 ldr w0, [x24, #28]
40022e14: 91008317 add x23, x24, #0x20
40022e18: a90153f3 stp x19, x20, [sp, #16]
40022e1c: 7100001f cmp w0, #0x0
40022e20: 540004ed b.le 40022ebc <rtems_ide_part_table_initialize+0xec> <== NEVER TAKEN
40022e24: 91008317 add x23, x24, #0x20
40022e28: 90000119 adrp x25, 40042000 <test_state_strings+0x50>
40022e2c: 91090339 add x25, x25, #0x240
40022e30: aa1703f4 mov x20, x23
40022e34: 52800013 mov w19, #0x0 // #0
40022e38: f9002bfb str x27, [sp, #80]
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);
40022e3c: 9000011b adrp x27, 40042000 <test_state_strings+0x50>
40022e40: 9109237b add x27, x27, #0x248
40022e44: 14000004 b 40022e54 <rtems_ide_part_table_initialize+0x84>
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
40022e48: b9401f00 ldr w0, [x24, #28]
40022e4c: 6b00027f cmp w19, w0
40022e50: 5400034a b.ge 40022eb8 <rtems_ide_part_table_initialize+0xe8> // b.tcont
sprintf(name, "%s%d", dev_name, part_num + 1);
40022e54: 11000673 add w19, w19, #0x1
40022e58: aa1903e1 mov x1, x25
40022e5c: 2a1303e3 mov w3, w19
40022e60: aa1603e2 mov x2, x22
40022e64: 910183e0 add x0, sp, #0x60
40022e68: 94004931 bl 4003532c <sprintf>
part_desc = disk_desc->partitions[part_num];
40022e6c: f9400283 ldr x3, [x20]
rc = rtems_blkdev_create_partition(name, dev_name, part_desc->start,
40022e70: aa1603e1 mov x1, x22
40022e74: 910183e0 add x0, sp, #0x60
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
40022e78: 91002294 add x20, x20, #0x8
if (part_desc == NULL)
40022e7c: b4fffe63 cbz x3, 40022e48 <rtems_ide_part_table_initialize+0x78>
rc = rtems_blkdev_create_partition(name, dev_name, part_desc->start,
40022e80: 29408c62 ldp w2, w3, [x3, #4]
40022e84: 97fffd5f bl 40022400 <rtems_blkdev_create_partition>
40022e88: 2a0003f5 mov w21, w0
if (rc != RTEMS_SUCCESSFUL)
40022e8c: 34fffde0 cbz w0, 40022e48 <rtems_ide_part_table_initialize+0x78> <== ALWAYS TAKEN
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
40022e90: 97fff7cc bl 40020dc0 <__getreent> <== NOT EXECUTED
40022e94: f9400800 ldr x0, [x0, #16] <== NOT EXECUTED
40022e98: 2a1503e3 mov w3, w21 <== NOT EXECUTED
40022e9c: 910183e2 add x2, sp, #0x60 <== NOT EXECUTED
40022ea0: aa1b03e1 mov x1, x27 <== NOT EXECUTED
40022ea4: 94004769 bl 40034c48 <fprintf> <== NOT EXECUTED
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
40022ea8: b9401f00 ldr w0, [x24, #28] <== NOT EXECUTED
40022eac: 6b00027f cmp w19, w0 <== NOT EXECUTED
40022eb0: 54fffd2b b.lt 40022e54 <rtems_ide_part_table_initialize+0x84> // b.tstop<== NOT EXECUTED
40022eb4: d503201f nop <== NOT EXECUTED
40022eb8: f9402bfb ldr x27, [sp, #80]
40022ebc: 91010316 add x22, x24, #0x40
partition_free(disk_desc->partitions[part_num]);
40022ec0: f94002f4 ldr x20, [x23]
if (part_desc == NULL)
40022ec4: b40001b4 cbz x20, 40022ef8 <rtems_ide_part_table_initialize+0x128>
return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
40022ec8: 39400680 ldrb w0, [x20, #1]
if (is_extended(part_desc->sys_type))
40022ecc: 12001800 and w0, w0, #0x7f
40022ed0: 7100141f cmp w0, #0x5
40022ed4: 540000e1 b.ne 40022ef0 <rtems_ide_part_table_initialize+0x120> // b.any<== ALWAYS TAKEN
40022ed8: 91008293 add x19, x20, #0x20 <== NOT EXECUTED
40022edc: 91010295 add x21, x20, #0x40 <== NOT EXECUTED
partition_free(part_desc->sub_part[part_num]);
40022ee0: f8408660 ldr x0, [x19], #8 <== NOT EXECUTED
40022ee4: 97ffff07 bl 40022b00 <partition_free> <== NOT EXECUTED
for (part_num = 0;
40022ee8: eb15027f cmp x19, x21 <== NOT EXECUTED
40022eec: 54ffffa1 b.ne 40022ee0 <rtems_ide_part_table_initialize+0x110> // b.any<== NOT EXECUTED
free(part_desc);
40022ef0: aa1403e0 mov x0, x20
40022ef4: 9400016b bl 400234a0 <free>
for (part_num = 0;
40022ef8: 910022f7 add x23, x23, #0x8
40022efc: eb1602ff cmp x23, x22
40022f00: 54fffe01 b.ne 40022ec0 <rtems_ide_part_table_initialize+0xf0> // b.any
free(disk_desc);
40022f04: aa1803e0 mov x0, x24
40022f08: 94000166 bl 400234a0 <free>
}
40022f0c: a94153f3 ldp x19, x20, [sp, #16]
40022f10: a94363f7 ldp x23, x24, [sp, #48]
}
partition_table_free(disk_desc);
return RTEMS_SUCCESSFUL;
}
40022f14: 2a1a03e0 mov w0, w26
40022f18: a9425bf5 ldp x21, x22, [sp, #32]
40022f1c: a9446bf9 ldp x25, x26, [sp, #64]
40022f20: a8c77bfd ldp x29, x30, [sp], #112
40022f24: d65f03c0 ret
free(disk_desc);
40022f28: aa1803e0 mov x0, x24 <== NOT EXECUTED
40022f2c: 9400015d bl 400234a0 <free> <== NOT EXECUTED
}
40022f30: 2a1a03e0 mov w0, w26 <== NOT EXECUTED
40022f34: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
return rc;
40022f38: a94363f7 ldp x23, x24, [sp, #48] <== NOT EXECUTED
}
40022f3c: a9446bf9 ldp x25, x26, [sp, #64] <== NOT EXECUTED
40022f40: a8c77bfd ldp x29, x30, [sp], #112 <== NOT EXECUTED
40022f44: d65f03c0 ret <== NOT EXECUTED
return RTEMS_NO_MEMORY;
40022f48: 5280035a mov w26, #0x1a // #26 <== NOT EXECUTED
40022f4c: 17fffff2 b 40022f14 <rtems_ide_part_table_initialize+0x144> <== NOT EXECUTED
0000000040021ab0 <rtems_sparse_disk_create_and_register>:
{
40021ab0: a9bc7bfd stp x29, x30, [sp, #-64]!
40021ab4: 910003fd mov x29, sp
40021ab8: a90153f3 stp x19, x20, [sp, #16]
40021abc: 2a0103f4 mov w20, w1
size_t const alloc_size = sizeof( rtems_sparse_disk )
40021ac0: d2800a01 mov x1, #0x50 // #80
40021ac4: 8b225021 add x1, x1, w2, uxtw #4
{
40021ac8: 2a0203f3 mov w19, w2
size_t const data_size = blocks_with_buffer * media_block_size;
40021acc: 1b027e82 mul w2, w20, w2
{
40021ad0: a9025bf5 stp x21, x22, [sp, #32]
40021ad4: aa0003f5 mov x21, x0
40021ad8: 2a0303f6 mov w22, w3
rtems_sparse_disk *const sd = (rtems_sparse_disk *) malloc(
40021adc: 8b010040 add x0, x2, x1
{
40021ae0: f9001bf7 str x23, [sp, #48]
40021ae4: 12001c97 and w23, w4, #0xff
rtems_sparse_disk *const sd = (rtems_sparse_disk *) malloc(
40021ae8: 940001a6 bl 40022180 <malloc>
if ( sparse_disk != NULL ) {
40021aec: b40001c0 cbz x0, 40021b24 <rtems_sparse_disk_create_and_register+0x74> <== NEVER TAKEN
sc = rtems_sparse_disk_register(
40021af0: aa0003e1 mov x1, x0
40021af4: 2a1703e5 mov w5, w23
40021af8: 2a1603e4 mov w4, w22
40021afc: 2a1303e3 mov w3, w19
40021b00: 2a1403e2 mov w2, w20
40021b04: aa1503e0 mov x0, x21
}
40021b08: a94153f3 ldp x19, x20, [sp, #16]
sc = rtems_sparse_disk_register(
40021b0c: 90000006 adrp x6, 40021000 <Init+0x440>
40021b10: 911c00c6 add x6, x6, #0x700
}
40021b14: a9425bf5 ldp x21, x22, [sp, #32]
40021b18: f9401bf7 ldr x23, [sp, #48]
40021b1c: a8c47bfd ldp x29, x30, [sp], #64
sc = rtems_sparse_disk_register(
40021b20: 17ffffa0 b 400219a0 <rtems_sparse_disk_register>
}
40021b24: 52800340 mov w0, #0x1a // #26 <== NOT EXECUTED
40021b28: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40021b2c: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40021b30: f9401bf7 ldr x23, [sp, #48] <== NOT EXECUTED
40021b34: a8c47bfd ldp x29, x30, [sp], #64 <== NOT EXECUTED
40021b38: d65f03c0 ret <== NOT EXECUTED
40021b3c: 00000000 udf #0
00000000400219a0 <rtems_sparse_disk_register>:
uint8_t fill_pattern,
rtems_sparse_disk_delete_handler sparse_disk_delete )
{
rtems_status_code sc;
if ( blocks_with_buffer <= media_block_count ) {
400219a0: 6b04007f cmp w3, w4
400219a4: 54000069 b.ls 400219b0 <rtems_sparse_disk_register+0x10> // b.plast<== ALWAYS TAKEN
sparse_disk_ioctl,
sparse_disk
);
}
} else {
sc = RTEMS_INVALID_NUMBER;
400219a8: 52800140 mov w0, #0xa // #10 <== NOT EXECUTED
}
return sc;
}
400219ac: d65f03c0 ret <== NOT EXECUTED
{
400219b0: a9bb7bfd stp x29, x30, [sp, #-80]!
400219b4: 910003fd mov x29, sp
400219b8: a9025bf5 stp x21, x22, [sp, #32]
400219bc: aa0103f5 mov x21, x1
if ( NULL == sd )
400219c0: b40006a1 cbz x1, 40021a94 <rtems_sparse_disk_register+0xf4> <== NEVER TAKEN
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
400219c4: d2800a07 mov x7, #0x50 // #80
400219c8: 2a0203f6 mov w22, w2
400219cc: a90153f3 stp x19, x20, [sp, #16]
400219d0: 2a0303f4 mov w20, w3
400219d4: 8b2350f3 add x19, x7, w3, uxtw #4
400219d8: aa1303e2 mov x2, x19
400219dc: 52800001 mov w1, #0x0 // #0
400219e0: a90363f7 stp x23, x24, [sp, #48]
400219e4: 2a0403f7 mov w23, w4
400219e8: aa0003f8 mov x24, x0
400219ec: aa1503e0 mov x0, x21
400219f0: a9046bf9 stp x25, x26, [sp, #64]
400219f4: 12001cba and w26, w5, #0xff
400219f8: aa0603f9 mov x25, x6
400219fc: 9400669a bl 4003b464 <memset>
memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
40021a00: 1b167e82 mul w2, w20, w22
sd->fill_pattern = fill_pattern;
40021a04: 390102ba strb w26, [x21, #64]
memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
40021a08: 8b1302b3 add x19, x21, x19
40021a0c: 2a1a03e1 mov w1, w26
40021a10: aa1303e0 mov x0, x19
40021a14: 94006694 bl 4003b464 <memset>
static __inline void
_Mutex_Initialize_named(struct _Mutex_Control *_mutex, const char *_name)
{
struct _Mutex_Control _init = _MUTEX_NAMED_INITIALIZER(_name);
*_mutex = _init;
40021a18: a9007ebf stp xzr, xzr, [x21]
data += sizeof( rtems_sparse_disk );
40021a1c: 910142a1 add x1, x21, #0x50
40021a20: f0000120 adrp x0, 40048000 <bsp_section_rodata_begin+0x78>
40021a24: 911bc000 add x0, x0, #0x6f0
40021a28: a90102bf stp xzr, x0, [x21, #16]
sd->blocks_with_buffer = blocks_with_buffer;
40021a2c: b90022b4 str w20, [x21, #32]
sd->delete_handler = sparse_disk_delete;
40021a30: f9001eb9 str x25, [x21, #56]
sd->key_table = (rtems_sparse_disk_key *) data;
40021a34: f90026a1 str x1, [x21, #72]
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
40021a38: 34000154 cbz w20, 40021a60 <rtems_sparse_disk_register+0xc0> <== NEVER TAKEN
40021a3c: 51000683 sub w3, w20, #0x1
40021a40: 9101a2b4 add x20, x21, #0x68
40021a44: 2a1603e1 mov w1, w22
40021a48: 910162a5 add x5, x21, #0x58
40021a4c: 8b235294 add x20, x20, w3, uxtw #4
sd->key_table[i].data = data;
40021a50: f80104b3 str x19, [x5], #16
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
40021a54: 8b010273 add x19, x19, x1
40021a58: eb1400bf cmp x5, x20
40021a5c: 54ffffa1 b.ne 40021a50 <rtems_sparse_disk_register+0xb0> // b.any
sc = rtems_blkdev_create(
40021a60: 2a1703e2 mov w2, w23
40021a64: aa1803e0 mov x0, x24
40021a68: a94153f3 ldp x19, x20, [sp, #16]
40021a6c: aa1503e4 mov x4, x21
40021a70: a94363f7 ldp x23, x24, [sp, #48]
40021a74: 2a1603e1 mov w1, w22
40021a78: a9446bf9 ldp x25, x26, [sp, #64]
sd->media_block_size = media_block_size;
40021a7c: b90032b6 str w22, [x21, #48]
}
40021a80: a9425bf5 ldp x21, x22, [sp, #32]
sc = rtems_blkdev_create(
40021a84: 90000003 adrp x3, 40021000 <Init+0x440>
40021a88: 911c4063 add x3, x3, #0x710
}
40021a8c: a8c57bfd ldp x29, x30, [sp], #80
sc = rtems_blkdev_create(
40021a90: 140029c8 b 4002c1b0 <rtems_blkdev_create>
return RTEMS_INVALID_ADDRESS;
40021a94: 52800120 mov w0, #0x9 // #9 <== NOT EXECUTED
}
40021a98: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40021a9c: a8c57bfd ldp x29, x30, [sp], #80 <== NOT EXECUTED
40021aa0: d65f03c0 ret <== NOT EXECUTED
...